`b588850`

fixes

Authored by

espadonne 8 months ago

SHA: b588850ac8e624d1147acbd89775acd59d369a99
Parents: 59d53dc
Tree: 055dccf

2 changed files

Status	File	+	-
M	`js/entities.js`	138	56
M	`js/game.js`	75	7

js/entities.jsmodified

      // DAWN PHASE: Check and consume stamina
      if (gamePhase === 'DAWN') {
        if (jumpStamina < jumpCost) {
--        // Not enough stamina to jump
          isExhausted = true
--        return // Can't jump
++        return
+       }
--      // Consume stamina for jump
        jumpStamina -= jumpCost
        stats.totalJumps++
++      // Delay stamina regen after each jump during DAWN
++      if (gamePhase === 'DAWN') {
++        staminaRegenCooldown = 60 // 1s at 60fps
++      }
+     }
      // PHASE 4B: Track wind jumps
      this.vel = direction
      this.isAirborne = true
      this.canJump = false
--    this.lastAnchorPoint = this.pos.copy()
++
++    // FIX: Ensure lastAnchorPoint is set to edge, not center
++    if (!this.lastAnchorPoint) {
++      // If no anchor point set yet, use current position
++      this.lastAnchorPoint = this.pos.copy()
++    }
      // Record jump time for touch debounce
      if (typeof window !== 'undefined') {
        window.lastJumpTime = millis()
      // Only land if we're actually airborne
      if (!this.isAirborne) return
++    // Calculate angle from obstacle center to spider
      let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x)
++
++    // Place spider on the edge of the circular collision boundary
      this.pos.x = obstacle.x + cos(angle) * (obstacle.radius + this.radius)
      this.pos.y = obstacle.y + sin(angle) * (obstacle.radius + this.radius)
--    this.attachedObstacle = obstacle // Track which obstacle we're on
++
++    // FIX: Set anchor point at the edge, not center
++    this.lastAnchorPoint = createVector(
++      obstacle.x + cos(angle) * obstacle.radius,
++      obstacle.y + sin(angle) * obstacle.radius
++    )
++
++    this.attachedObstacle = obstacle
      this.land()
+   }
      // FIX: Check if we're actually landing on something valid
      let landedOnSomething = false
++    let landingPoint = null // Store where we're landing for anchor
      // Check if on ground
      if (this.pos.y >= height - this.radius - 5) {
        landedOnSomething = true
++      landingPoint = createVector(this.pos.x, height)
+     }
      // Check if on an obstacle
--    for (let obstacle of obstacles) {
++    if (!landedOnSomething) {
--      if (this.checkObstacleCollision(obstacle)) {
++      for (let obstacle of obstacles) {
--        landedOnSomething = true
++        if (this.checkObstacleCollision(obstacle)) {
--        break
++          landedOnSomething = true
++          // Calculate edge point for anchor
++          let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x)
++          landingPoint = createVector(
++            obstacle.x + cos(angle) * obstacle.radius,
++            obstacle.y + sin(angle) * obstacle.radius
++          )
++          break
++        }
+       }
+     }
      // Check if on a web strand
--    for (let strand of webStrands) {
++    if (!landedOnSomething) {
--      if (
++      for (let strand of webStrands) {
--        strand !== currentStrand &&
++        if (
--        !strand.broken &&
++          strand !== currentStrand &&
--        this.checkStrandCollision(strand)
++          !strand.broken &&
--      ) {
++          this.checkStrandCollision(strand)
--        landedOnSomething = true
++        ) {
--        break
++          landedOnSomething = true
++          // For web strands, use spider position as anchor
++          landingPoint = this.pos.copy()
++          break
++        }
+       }
+     }
      // Check if on home branch
--    if (window.homeBranch) {
++    if (!landedOnSomething && window.homeBranch) {
        let branch = window.homeBranch
        let branchStart = Math.min(branch.startX, branch.endX)
        let branchEnd = Math.max(branch.startX, branch.endX)
          if (abs(this.pos.y - branchSurfaceY) < this.radius + 10) {
            landedOnSomething = true
++          landingPoint = createVector(this.pos.x, branchSurfaceY)
+         }
+       }
+     }
      // FIX: If we're deploying web but didn't land on anything valid, destroy the web
      if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
--      if (landedOnSomething) {
++      if (landedOnSomething && landingPoint) {
--        // Valid landing - finalize the web
++        // Valid landing - finalize the web at the landing point
--        currentStrand.end = this.pos.copy()
++        currentStrand.end = landingPoint.copy() // Use edge point, not spider center
          if (!currentStrand.path || currentStrand.path.length === 0) {
--          currentStrand.path = [this.pos.copy()]
++          currentStrand.path = [landingPoint.copy()]
          } else {
--          currentStrand.path.push(this.pos.copy())
++          currentStrand.path.push(landingPoint.copy())
+         }
--        webNodes.push(new WebNode(this.pos.x, this.pos.y))
++        webNodes.push(new WebNode(landingPoint.x, landingPoint.y))
++
++        // Update last anchor for next web
++        this.lastAnchorPoint = landingPoint.copy()
        } else {
          // Invalid landing in mid-air - destroy the web!
          if (
+           }
+         }
+       }
++    } else if (landedOnSomething && landingPoint) {
++      // Update last anchor point even when not deploying web
++      this.lastAnchorPoint = landingPoint.copy()
+     }
      currentStrand = null
    updateAttachedStrands () {
      // Update web strands that are connected to this obstacle
      for (let strand of webStrands) {
--      // Check if strand starts at this obstacle
++      // Check if strand starts near this obstacle's edge
--      if (
++      let startDist = dist(strand.start.x, strand.start.y, this.x, this.y)
--        dist(strand.start.x, strand.start.y, this.x, this.y) <
++      if (startDist >= this.radius - 5 && startDist <= this.radius + 15) {
--        this.radius + 10
++        // Strand is attached to edge - update to maintain edge connection
--      ) {
++        let angle = atan2(strand.start.y - this.y, strand.start.x - this.x)
--        strand.start.x = this.x
++        strand.start.x = this.x + cos(angle) * this.radius
--        strand.start.y = this.y
++        strand.start.y = this.y + sin(angle) * this.radius
          if (strand.path && strand.path.length > 0) {
--          strand.path[0].x = this.x
++          strand.path[0].x = strand.start.x
--          strand.path[0].y = this.y
++          strand.path[0].y = strand.start.y
+         }
+       }
--      // Check if strand ends at this obstacle
++      // Check if strand ends near this obstacle's edge
--      if (
++      if (strand.end) {
--        strand.end &&
++        let endDist = dist(strand.end.x, strand.end.y, this.x, this.y)
--        dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10
++        if (endDist >= this.radius - 5 && endDist <= this.radius + 15) {
--      ) {
++          // Strand is attached to edge - update to maintain edge connection
--        strand.end.x = this.x
++          let angle = atan2(strand.end.y - this.y, strand.end.x - this.x)
--        strand.end.y = this.y
++          strand.end.x = this.x + cos(angle) * this.radius
--        if (strand.path && strand.path.length > 0) {
++          strand.end.y = this.y + sin(angle) * this.radius
--          strand.path[strand.path.length - 1].x = this.x
++          if (strand.path && strand.path.length > 0) {
--          strand.path[strand.path.length - 1].y = this.y
++            strand.path[strand.path.length - 1].x = strand.end.x
++            strand.path[strand.path.length - 1].y = strand.end.y
++          }
+         }
+       }
+     }
+   }
    breakAttachedStrands () {
--    // Break any strands attached to this beetle that has drifted too far
++    // Check for strands attached to this obstacle's edge
      for (let strand of webStrands) {
++      // Check if attached to edge (not center)
++      let startDist = dist(strand.start.x, strand.start.y, this.x, this.y)
        let attachedToStart =
--        dist(strand.start.x, strand.start.y, this.x, this.y) < this.radius + 10
++        startDist >= this.radius - 5 && startDist <= this.radius + 15
--      let attachedToEnd =
++
--        strand.end &&
++      let attachedToEnd = false
--        dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10
++      if (strand.end) {
++        let endDist = dist(strand.end.x, strand.end.y, this.x, this.y)
++        attachedToEnd =
++          endDist >= this.radius - 5 && endDist <= this.radius + 15
++      }
        if (attachedToStart || attachedToEnd) {
          // Mark strand as broken
        // Matte fabric shading (subtle, non-glossy)
        noStroke()
        // Soft radial shading toward top-left to imply ambient light without specular shine
--      for (let r = this.radius * 1.2; r > this.radius * 0.2; r -= this.radius * 0.15) {
++      for (
++        let r = this.radius * 1.2;
++        r > this.radius * 0.2;
++        r -= this.radius * 0.15
++      ) {
          fill(255, 255, 255, 8) // very low alpha
          ellipse(-this.radius * 0.25, -this.radius * 0.35, r * 0.25, r * 0.18)
+       }
        // Update target position while diving
        if (frameCount % 8 === 0) {
          this.targetX = spider.pos.x
--        this.targetY = spider.pos.y
++        // Keep steering intent downward; don't let target sit above our per-dive floor
++        this.targetY =
++          typeof this.pullUpY === 'number'
++            ? Math.min(spider.pos.y, this.pullUpY - 4)
++            : spider.pos.y
+       }
        // Only consider bailing out after a minimum number of dive frames
--      let canBailOut = this.diveFrames > 15
++      let canBailOut = this.diveFrames > 22
        // Use pullUpY for stable bailout check
--      let reachedPullUpY = (typeof this.pullUpY === 'number') ? (this.y > this.pullUpY) : false
++      let reachedPullUpY =
++        typeof this.pullUpY === 'number' ? this.y > this.pullUpY : false
        let reachedBottom = this.y > height - 20 // Go almost to canvas bottom
--      let closeToSpider = dist(this.x, this.y, spider.pos.x, spider.pos.y) < 50
++      const hitCollision =
--
++        dist(this.x, this.y, spider.pos.x, spider.pos.y) <=
--      if (canBailOut && (reachedPullUpY || reachedBottom || closeToSpider)) {
++        this.size * 0.5 + spider.radius
++      const nearButNotHit =
++        !hitCollision &&
++        abs(this.x - spider.pos.x) < 30 &&
++        abs(this.y - spider.pos.y) < 24
++
++      if (canBailOut && (hitCollision || reachedPullUpY || reachedBottom)) {
++        // Convert near-miss near the floor into a sweep instead of an early bail
++        if (
++          !hitCollision &&
++          reachedPullUpY &&
++          spider.pos.y > height - 30 &&
++          !this.sweeping
++        ) {
++          this.sweeping = true
++          this.y = spider.pos.y // lock to spider height
++          this.vy = 0
++          const sweepDirection = spider.pos.x > this.x ? 1 : -1
++          this.vx = sweepDirection * 8
++          setTimeout(() => {
++            this.sweeping = false
++            this.state = 'retreating'
++            this.attacking = false
++            this.diveFrames = 0
++            this.pullUpY = null
++          }, 500)
++          return // skip normal bailout path
++        }
          // If spider is at bottom and we haven't hit it yet, do a horizontal sweep
--        if (spider.pos.y > height - 30 && !closeToSpider && !this.sweeping) {
++        if (spider.pos.y > height - 30 && !hitCollision && !this.sweeping) {
            this.sweeping = true
            this.y = spider.pos.y // Match spider height
            this.vy = 0 // Stop vertical movement

js/game.jsmodified

  let isExhausted = false
  let fliesMunchedLastNight = 0
  let birds = []
++let staminaRegenCooldown = 0
  // PHASE 4B: Wind System
  let windActive = false
      pop()
+   }
++  // Threat cue when regen is fully suppressed
++  if (gamePhase === 'DAWN') {
++    let showThreatCue = false
++    for (let b of birds) {
++      if (
++        b &&
++        b.state === 'diving' &&
++        dist(b.x, b.y, spider.pos.x, spider.pos.y) < 180
++      ) {
++        showThreatCue = true
++        break
++      }
++    }
++    if (showThreatCue) {
++      push()
++      textAlign(CENTER)
++      textSize(14)
++      fill(255, 80, 80, 210)
++      stroke(0)
++      strokeWeight(2)
++      text(
++        'UNDER ATTACK! stamina regen halted',
++        spider.pos.x,
++        spider.pos.y - 48
++      )
++      pop()
++    }
++  }
++
    // PHASE 4: Update and display birds during dawn
    if (gamePhase === 'DAWN') {
--    // Update stamina
++    // Update stamina (suppressed during bird attack sequences)
--    if (!spider.isAirborne && spider.vel.mag() < 0.1) {
++    // Threat scan (expose flags for cooldown logic)
--      // Resting - faster regen
++    let anyBirdActive = false
--      jumpStamina += staminaRegenRate * 2.5
++    let nearDivingBird = false
--    } else {
++    for (let b of birds) {
--      // Moving - normal regen
++      if (!b) continue
--      jumpStamina += staminaRegenRate
++      // any bird on screen during DAWN counts as pressure
++      if (b.state !== 'retreating') anyBirdActive = true
++      // hard suppression if a diving bird is close
++      if (b.state === 'diving') {
++        const d = dist(b.x, b.y, spider.pos.x, spider.pos.y)
++        if (d < 180) nearDivingBird = true
++      }
++    }
++    const birdThreatMultiplier = nearDivingBird
++      ? 0.0
++      : anyBirdActive
++      ? 0.4
++      : 1.0
++
++    // Cooldown: delay regen start after jumps and while threats persist
++    if (staminaRegenCooldown > 0) {
++      staminaRegenCooldown--
++    }
++    if (nearDivingBird) {
++      staminaRegenCooldown = Math.max(staminaRegenCooldown, 90) // +1.5s after a near dive
++    } else if (anyBirdActive) {
++      staminaRegenCooldown = Math.max(staminaRegenCooldown, 45) // +0.75s while birds hunt
++    }
++    // Light movement also nudges the cooldown so regen only starts when resting
++    if (spider.vel.mag() >= 0.3) {
++      staminaRegenCooldown = Math.max(staminaRegenCooldown, 15)
+     }
++
++    // Base regen depends on motion
++    let regen =
++      staminaRegenRate *
++      (spider.isAirborne || spider.vel.mag() >= 0.1 ? 1.0 : 2.0)
++    // Apply threat suppression
++    regen *= birdThreatMultiplier
++    // Apply cooldown suppression
++    if (staminaRegenCooldown > 0) {
++      regen = 0
++    }
++
++    jumpStamina += regen
      jumpStamina = min(jumpStamina, maxJumpStamina)
      isExhausted = jumpStamina < jumpCost