`6237a51`

fixes, cleanup

Authored by

espadonne 8 months ago

SHA: 6237a51a44013f993f3d0de5b1ea02df81a80afe
Parents: 827e77f
Tree: d2b83b9

4 changed files

Status	File	+	-
M	`deploy.sh`	0	1
M	`index.html`	1	1
M	`js/entities.js`	331	173
M	`js/game.js`	179	129

deploy.shmodified


 sudo find "$RELEASES/$STAMP" -type d -exec chmod 0755 {} +
 sudo find "$RELEASES/$STAMP" -type f -exec chmod 0644 {} +
 

 NGINX_USER="nginx"
 if id "$NGINX_USER" >/dev/null 2>&1; then
   sudo -u "$NGINX_USER" test -r "$RELEASES/$STAMP/index.html" || { echo "✗ nginx user cannot read index.html"; exit 1; }

index.htmlmodified


             Click to jump • Space to spin web • Shift to munch!<br>
             Web Strands: <span id="strand-count">0</span><br>
             Flies Caught: <span id="flies-caught">0</span> | Munched: <span id="flies-munched">0</span><br>
+            Points: <span id="player-points">0</span> | Total Score: <span id="total-score">0</span>
         </div>
         <div id="phase-indicator">
             <span id="phase">DUSK</span><br>

js/entities.jsmodified

      // DAWN PHASE: Check and consume stamina
      if (gamePhase === 'DAWN') {
++      // FIX: Only check if we ACTUALLY don't have enough stamina
        if (jumpStamina < jumpCost) {
          isExhausted = true
++        // Only show notification if we're truly out
++        if (jumpStamina < 5 && notifications.length < 3) {
++          notifications.push(
++            new Notification('NO STAMINA!', color(255, 50, 50))
++          )
++        }
          return
+       }
        jumpStamina -= jumpCost
        stats.totalJumps++
        // Delay stamina regen after each jump during DAWN
--      if (gamePhase === 'DAWN') {
++      staminaRegenCooldown = 60 // 1s at 60fps
--        staminaRegenCooldown = 60 // 1s at 60fps
--      }
+     }
      // PHASE 4B: Track wind jumps
      if (this.munchCooldown > 0) return
      isMunching = true
--    this.munchCooldown = 30
++    this.munchCooldown = this.munchCooldownMax || 30 // Use upgrade value if available
      for (let i = flies.length - 1; i >= 0; i--) {
        let fly = flies[i]
        let d = dist(this.pos.x, this.pos.y, fly.pos.x, fly.pos.y)
        if (d < this.munchRadius) {
          fliesMunched++
++        stats.fliesMunchedInCurrentNight++ // Track for achievements
++
++        // POINTS: Award points for munching
++        let munchPoints = 4 // Base points for munch
++        if (fly.type === 'golden') munchPoints = 8
++        if (fly.type === 'queen') munchPoints = 10
++        if (fly.type === 'moth') munchPoints = 6
++        playerPoints += munchPoints
++        totalFliesCaught++ // Add to lifetime counter
++
          webSilk = min(webSilk + 15, maxWebSilk)
++        // PHASE 3: Metabolize upgrade effect
++        if (upgrades.metabolize && upgrades.metabolize.level > 0) {
++          // Heal nearby broken strands
++          for (let strand of webStrands) {
++            if (strand.broken) {
++              let distToStrand = Infinity
++              if (strand.path && strand.path.length > 0) {
++                for (let point of strand.path) {
++                  let d = dist(this.pos.x, this.pos.y, point.x, point.y)
++                  if (d < distToStrand) distToStrand = d
++                }
++              }
++
++              if (distToStrand < 100) {
++                strand.broken = false
++                strand.strength = 0.5 // Heal to half strength
++
++                // Green healing particles
++                for (let j = 0; j < 5; j++) {
++                  let p = new Particle(this.pos.x, this.pos.y)
++                  p.color = color(100, 255, 100)
++                  p.vel = createVector(random(-2, 2), random(-2, 2))
++                  p.size = 3
++                  particles.push(p)
++                }
++
++                break // Only heal one strand per munch
++              }
++            }
++          }
++        }
++
          for (let j = 0; j < 12; j++) {
            let p = new Particle(fly.pos.x, fly.pos.y)
            p.color = color(255, random(100, 255), 0)
        let branchStart = Math.min(branch.startX, branch.endX)
        let branchEnd = Math.max(branch.startX, branch.endX)
--      // Since the branch angle is very small (0.05 radians ≈ 3 degrees),
++      // FIX: Extend collision detection beyond visual tip
--      // we can use a simpler approximation
++      // The visual branch ends at branchEnd, but we need collision slightly beyond
--      if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
++      let collisionPadding = 15 // Extra collision at the tip
++
++      if (
++        this.pos.x >= branchStart - 10 &&
++        this.pos.x <= branchEnd + collisionPadding
++      ) {
          // Calculate position along branch (0 to 1)
++        // FIX: Clamp t to ensure we handle tip properly
          let t = (this.pos.x - branchStart) / (branchEnd - branchStart)
--        t = constrain(t, 0, 1)
++
++        // Allow t to go slightly beyond 1.0 for tip collision
++        if (this.pos.x > branchEnd) {
++          t = 1.0 // At the tip, use tip thickness
++        } else {
++          t = constrain(t, 0, 1)
++        }
          // Branch visual thickness tapers from full at start to 35% at end
--        // This matches exactly how it's drawn in the bezier curves
++        let branchTopThickness
--        let branchTopThickness = lerp(
++        if (t >= 1.0) {
--          branch.thickness * 0.9,
++          // At the very tip, maintain minimum collision thickness
--          branch.thickness * 0.35,
++          branchTopThickness = branch.thickness * 0.35
--          t
++        } else {
--        )
++          branchTopThickness = lerp(
++            branch.thickness * 0.9,
++            branch.thickness * 0.35,
++            t
++          )
++        }
          // The branch is drawn centered at branch.y
--        // With small angle approximation: the top of the branch is at
          let branchSurfaceY = branch.y - branchTopThickness
--        // Add slight angle correction (for small angles, tan ≈ sin ≈ angle in radians)
++        // FIX: Correct angle calculation based on branch side
--        let angleCorrection = (this.pos.x - branchStart) * branch.angle
++        let angleCorrection
++        if (branch.side === 'right') {
++          // Right branch slopes down to the left (negative angle)
++          // Use distance from the end point (which is on the left for right branches)
++          angleCorrection = -(this.pos.x - branchEnd) * abs(branch.angle)
++        } else {
++          // Left branch slopes down to the right (positive angle)
++          // Use distance from the start point
++          angleCorrection = (this.pos.x - branchStart) * abs(branch.angle)
++        }
          branchSurfaceY += angleCorrection
          // Check if spider is crossing the branch from above
          let prevY = this.pos.y - this.vel.y
++        // FIX: More generous collision detection at the tip
++        let collisionBuffer = t >= 0.9 ? 5 : 0 // Extra buffer near tip
++
          if (
--          prevY <= branchSurfaceY && // Was above
++          prevY <= branchSurfaceY + collisionBuffer && // Was above (with buffer)
            this.pos.y + this.radius >= branchSurfaceY && // Now at or below
            this.pos.y < branch.y + branch.thickness
          ) {
      this.land()
+   }
--land() {
++  land () {
--  this.vel.mult(0);
++    this.vel.mult(0)
--  this.isAirborne = false;
++    this.isAirborne = false
--  this.canJump = true;
++    this.canJump = true
--
--  // FIX: Check if we're actually landing on something valid
--  let landedOnSomething = false;
--  let landingPoint = null; // Store where we're landing for anchor
--  let landingObstacle = null; // NEW: Track which obstacle we're landing on
--
--  // 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
++    // FIX: Check if we're actually landing on something valid
--  if (!landedOnSomething) {
++    let landedOnSomething = false
--    for (let obstacle of obstacles) {
++    let landingPoint = null // Store where we're landing for anchor
--      if (this.checkObstacleCollision(obstacle)) {
++    let landingObstacle = null // NEW: Track which obstacle we're landing on
--        landedOnSomething = true;
++
--        landingObstacle = obstacle; // NEW: Store the obstacle
++    // Check if on ground
--        // Calculate edge point for anchor
++    if (this.pos.y >= height - this.radius - 5) {
--        let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x);
++      landedOnSomething = true
--        landingPoint = createVector(
++      landingPoint = createVector(this.pos.x, height)
--          obstacle.x + cos(angle) * obstacle.radius,
++    }
--          obstacle.y + sin(angle) * obstacle.radius
++
--        );
++    // Check if on an obstacle
--        break;
++    if (!landedOnSomething) {
++      for (let obstacle of obstacles) {
++        if (this.checkObstacleCollision(obstacle)) {
++          landedOnSomething = true
++          landingObstacle = obstacle // NEW: Store the obstacle
++          // 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
++    // Check if on a web strand
--  if (!landedOnSomething) {
++    if (!landedOnSomething) {
--    for (let strand of webStrands) {
++      for (let strand of webStrands) {
--      if (strand !== currentStrand && !strand.broken && this.checkStrandCollision(strand)) {
++        if (
--        landedOnSomething = true;
++          strand !== currentStrand &&
--        // For web strands, use spider position as anchor
++          !strand.broken &&
--        landingPoint = this.pos.copy();
++          this.checkStrandCollision(strand)
--        break;
++        ) {
++          landedOnSomething = true
++          // For web strands, use spider position as anchor
++          landingPoint = this.pos.copy()
++          break
++        }
+       }
+     }
--  }
--  // Check if on home branch
++    // Check if on home branch
--  if (!landedOnSomething && window.homeBranch) {
++    if (!landedOnSomething && window.homeBranch) {
--    let branch = window.homeBranch;
++      let branch = window.homeBranch
--    let branchStart = Math.min(branch.startX, branch.endX);
++      let branchStart = Math.min(branch.startX, branch.endX)
--    let branchEnd = Math.max(branch.startX, branch.endX);
++      let branchEnd = Math.max(branch.startX, branch.endX)
--
++
--    if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
++      if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
--      let t = (this.pos.x - branchStart) / (branchEnd - branchStart);
++        let t = (this.pos.x - branchStart) / (branchEnd - branchStart)
--      t = constrain(t, 0, 1);
++        t = constrain(t, 0, 1)
--      let branchTopThickness = lerp(branch.thickness * 0.9, branch.thickness * 0.35, t);
++        let branchTopThickness = lerp(
--      let branchSurfaceY = branch.y - branchTopThickness;
++          branch.thickness * 0.9,
--      let angleCorrection = (this.pos.x - branchStart) * branch.angle;
++          branch.thickness * 0.35,
--      branchSurfaceY += angleCorrection;
++          t
--
++        )
--      if (abs(this.pos.y - branchSurfaceY) < this.radius + 10) {
++        let branchSurfaceY = branch.y - branchTopThickness
--        landedOnSomething = true;
++        let angleCorrection = (this.pos.x - branchStart) * branch.angle
--        landingPoint = createVector(this.pos.x, branchSurfaceY);
++        branchSurfaceY += angleCorrection
++
++        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
++    // FIX: If we're deploying web but didn't land on anything valid, destroy the web
--  if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
++    if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
--    if (landedOnSomething && landingPoint) {
++      if (landedOnSomething && landingPoint) {
--      // Valid landing - finalize the web at the landing point
++        // Valid landing - finalize the web at the landing point
--      currentStrand.end = landingPoint.copy(); // Use edge point, not spider center
++        currentStrand.end = landingPoint.copy() // Use edge point, not spider center
--
--      // NEW: Track obstacle attachment for the end point
--      if (landingObstacle) {
--        currentStrand.endObstacle = landingObstacle;
--        currentStrand.endAngle = atan2(
--          landingPoint.y - landingObstacle.y,
--          landingPoint.x - landingObstacle.x
--        );
--      }
--
--      if (!currentStrand.path || currentStrand.path.length === 0) {
--        currentStrand.path = [landingPoint.copy()];
--      } else {
--        currentStrand.path.push(landingPoint.copy());
--      }
--
--      let newNode = new WebNode(landingPoint.x, landingPoint.y);
--      // NEW: Track node attachment
--      if (landingObstacle) {
--        newNode.attachedObstacle = landingObstacle;
--        newNode.attachmentAngle = currentStrand.endAngle;
--      }
--      webNodes.push(newNode);
--      // Update last anchor for next web
++        // POINTS: Award 1 point for successful web strand
--      this.lastAnchorPoint = landingPoint.copy();
++        playerPoints += 1
--    } else {
++        stats.strandsCreated++ // Track for stats
--      // Invalid landing in mid-air - destroy the web!
--      if (webStrands.length > 0 && webStrands[webStrands.length - 1] === currentStrand) {
--        webStrands.pop(); // Remove the invalid strand
--        // Create poof particles
++        // NEW: Track obstacle attachment for the end point
--        for (let i = 0; i < 8; i++) {
++        if (landingObstacle) {
--          let p = new Particle(this.pos.x, this.pos.y);
++          currentStrand.endObstacle = landingObstacle
--          p.color = color(255, 255, 255, 150);
++          currentStrand.endAngle = atan2(
--          p.vel = createVector(random(-3, 3), random(-3, 3));
++            landingPoint.y - landingObstacle.y,
--          p.size = 4;
++            landingPoint.x - landingObstacle.x
--          particles.push(p);
++          )
+         }
--        // Notification
++        if (!currentStrand.path || currentStrand.path.length === 0) {
--        if (notifications.length < 3) {
++          currentStrand.path = [landingPoint.copy()]
--          notifications.push(new Notification("Web needs anchor point!", color(255, 150, 150)));
++        } else {
++          currentStrand.path.push(landingPoint.copy())
++        }
++
++        let newNode = new WebNode(landingPoint.x, landingPoint.y)
++        // NEW: Track node attachment
++        if (landingObstacle) {
++          newNode.attachedObstacle = landingObstacle
++          newNode.attachmentAngle = currentStrand.endAngle
++        }
++        webNodes.push(newNode)
++
++        // Update last anchor for next web
++        this.lastAnchorPoint = landingPoint.copy()
++      } else {
++        // Invalid landing in mid-air - destroy the web!
++        if (
++          webStrands.length > 0 &&
++          webStrands[webStrands.length - 1] === currentStrand
++        ) {
++          webStrands.pop() // Remove the invalid strand
++
++          // Create poof particles
++          for (let i = 0; i < 8; i++) {
++            let p = new Particle(this.pos.x, this.pos.y)
++            p.color = color(255, 255, 255, 150)
++            p.vel = createVector(random(-3, 3), random(-3, 3))
++            p.size = 4
++            particles.push(p)
++          }
++
++          // Notification
++          if (notifications.length < 3) {
++            notifications.push(
++              new Notification('Web needs anchor point!', color(255, 150, 150))
++            )
++          }
+         }
+       }
++    } else if (landedOnSomething && landingPoint) {
++      // Update last anchor point even when not deploying web
++      this.lastAnchorPoint = landingPoint.copy()
+     }
--  } else if (landedOnSomething && landingPoint) {
--    // Update last anchor point even when not deploying web
--    this.lastAnchorPoint = landingPoint.copy();
--  }
--
--  currentStrand = null;
--  isDeployingWeb = false;
--}
++    currentStrand = null
++    isDeployingWeb = false
++  }
    display () {
      push()
    update () {
      if (this.stuck) {
--      // If stuck, check if we need to move with a drifting web
        this.updatePositionOnWeb()
        return
+     }
        if (this.vel.mag() < 0.1) {
          this.stuck = true
          fliesCaught++
++        totalFliesCaught++ // Add to lifetime counter
++
++        // POINTS: Award points for catching fly
++        let catchPoints = 2 // Base points for catch
++        if (this.type === 'golden') catchPoints = 4
++        if (this.type === 'queen') catchPoints = 5
++        if (this.type === 'moth') catchPoints = 3
++        playerPoints += catchPoints
++
          webSilk = min(webSilk + 5, maxWebSilk)
+       }
--      // While caught but not yet stuck, also follow the web
        this.updatePositionOnWeb()
        return
+     }
        ellipse(0, 0, 20)
+     }
--    if (gamePhase === 'NIGHT') {
++    // ENHANCED: Special golden fly glow
++    if (this.type === 'golden') {
++      // Multiple layers of golden glow for visibility
++      noStroke()
++      // Outermost glow - very faint but wide
++      fill(255, 215, 0, 15)
++      ellipse(0, 0, 80)
++      // Mid glow
++      fill(255, 200, 0, 25)
++      ellipse(0, 0, 60)
++      // Inner glow
++      fill(255, 185, 0, 40)
++      ellipse(0, 0, 40)
++      // Core glow
++      fill(255, 170, 0, 60)
++      ellipse(0, 0, 25)
++
++      // Pulsing effect
++      let pulse = sin(frameCount * 0.1) * 0.3 + 0.7
++      fill(255, 215, 0, 80 * pulse)
++      ellipse(0, 0, 20)
++    } else if (gamePhase === 'NIGHT') {
++      // Regular firefly glow
        noStroke()
        fill(255, 255, 150, this.glowIntensity * 0.3)
        ellipse(0, 0, 30)
        ellipse(0, 0, 20)
+     }
--    fill(30)
++    // Body color based on type
--    stroke(0)
++    if (this.type === 'golden') {
++      fill(255, 215, 0) // Gold body
++      stroke(200, 150, 0)
++    } else if (this.type === 'moth') {
++      fill(60, 40, 30) // Brown moth
++      stroke(40, 20, 10)
++    } else if (this.type === 'queen') {
++      fill(150, 50, 200) // Purple queen
++      stroke(100, 0, 150)
++    } else {
++      fill(30) // Regular black
++      stroke(0)
++    }
++
      strokeWeight(0.5)
      ellipse(0, 0, this.radius * 2)
        this.wingPhase += wingSpeed
        let wingSpread = sin(this.wingPhase) * 5
--      fill(255, 255, 255, 150)
++      // Wing color based on type
++      if (this.type === 'golden') {
++        fill(255, 240, 150, 200) // Golden translucent wings
++      } else if (this.type === 'moth') {
++        fill(120, 100, 80, 150) // Brown moth wings
++      } else if (this.type === 'queen') {
++        fill(200, 150, 255, 180) // Purple queen wings
++      } else {
++        fill(255, 255, 255, 150) // Regular white wings
++      }
++
        noStroke()
        ellipse(-wingSpread, 0, 6, 4)
        ellipse(wingSpread, 0, 6, 4)
+     }
--    if (gamePhase === 'NIGHT') {
++    // Special markings for special types
++    if (this.type === 'golden') {
++      // Golden sparkle on body
++      fill(255, 255, 200)
++      noStroke()
++      ellipse(0, 0, 2)
++    } else if (this.type === 'queen') {
++      // Crown marking
++      stroke(255, 215, 0)
++      strokeWeight(1)
++      line(-2, -3, -1, -5)
++      line(0, -3, 0, -5)
++      line(2, -3, 1, -5)
++    } else if (gamePhase === 'NIGHT') {
++      // Regular glow abdomen
        fill(255, 255, 100, this.glowIntensity)
        noStroke()
        ellipse(0, 2, 3)
+     }
+   }
--updateAttachedStrands() {
++  updateAttachedStrands () {
--  // Update web strands that are connected to this obstacle
++    // Update web strands that are connected to this obstacle
--  for (let strand of webStrands) {
++    for (let strand of webStrands) {
--    if (!strand || strand.broken) continue;
++      if (!strand || strand.broken) continue
--
++
--    // Check if strand starts at this obstacle
++      // Check if strand starts at this obstacle
--    if (strand.startObstacle === this) {
++      if (strand.startObstacle === this) {
--      // Update the start position to maintain the attachment
++        // Update the start position to maintain the attachment
--      let angle = strand.startAngle; // Use stored angle
++        let angle = strand.startAngle // Use stored angle
--      strand.start.x = this.x + cos(angle) * this.radius;
++        strand.start.x = this.x + cos(angle) * this.radius
--      strand.start.y = this.y + sin(angle) * this.radius;
++        strand.start.y = this.y + sin(angle) * this.radius
--
++
--      // Update path if it exists
++        // Update path if it exists
--      if (strand.path && strand.path.length > 0) {
++        if (strand.path && strand.path.length > 0) {
--        strand.path[0].x = strand.start.x;
++          strand.path[0].x = strand.start.x
--        strand.path[0].y = strand.start.y;
++          strand.path[0].y = strand.start.y
++        }
+       }
--    }
++
--
++      // Check if strand ends at this obstacle
--    // Check if strand ends at this obstacle
++      if (strand.endObstacle === this) {
--    if (strand.endObstacle === this) {
++        // Update the end position to maintain the attachment
--      // Update the end position to maintain the attachment
++        let angle = strand.endAngle // Use stored angle
--      let angle = strand.endAngle; // Use stored angle
++        strand.end.x = this.x + cos(angle) * this.radius
--      strand.end.x = this.x + cos(angle) * this.radius;
++        strand.end.y = this.y + sin(angle) * this.radius
--      strand.end.y = this.y + sin(angle) * this.radius;
++
--
++        // Update path if it exists
--      // Update path if it exists
++        if (strand.path && strand.path.length > 0) {
--      if (strand.path && strand.path.length > 0) {
++          strand.path[strand.path.length - 1].x = strand.end.x
--        strand.path[strand.path.length - 1].x = strand.end.x;
++          strand.path[strand.path.length - 1].y = strand.end.y
--        strand.path[strand.path.length - 1].y = strand.end.y;
++        }
+       }
+     }
--  }
++
--
++    // Also update web nodes attached to this obstacle
--  // Also update web nodes attached to this obstacle
++    for (let node of webNodes) {
--  for (let node of webNodes) {
++      if (node.attachedObstacle === this) {
--    if (node.attachedObstacle === this) {
++        let angle = node.attachmentAngle
--      let angle = node.attachmentAngle;
++        node.x = this.x + cos(angle) * this.radius
--      node.x = this.x + cos(angle) * this.radius;
++        node.y = this.y + sin(angle) * this.radius
--      node.y = this.y + sin(angle) * this.radius;
++      }
+     }
+   }
--}
--
    breakAttachedStrands () {
      // Check for strands attached to this obstacle's edge
          // Warning notifications - but limited to prevent spam
          if (notifications.length < 3) {
--          // Limit notifications
            if (jumpStamina <= 20) {
              notifications.push(
                new Notification('CRITICAL STAMINA!', color(255, 50, 50))
+             )
+           }
+         }
++
++        // POINTS: Award 2 points for surviving a bird attack
++        playerPoints += 2
+       }
        // Bird bounces off

js/game.jsmodified

  let deathReason = ''
  let finalScore = 0
  let screenShake = 0
++let fliesSpawnedThisNight = 0
  // Resources
  let webSilk = 100
  let fliesMunchedLastNight = 0
  let birds = []
  let staminaRegenCooldown = 0
++let staminaBonus = 0;
  // PHASE 4B: Wind System
  let windActive = false
      gamePhase = 'DAWN'
      phaseTimer = 0
--    // Calculate dawn stamina with CLEAR BONUS DISPLAY
++    // NEW STAMINA CALCULATION:
--    let baseStamina = 30
++    // Fixed 100 max stamina, but starting amount depends on performance
--    let flyBonus = fliesMunchedLastNight * 10
++    maxJumpStamina = 100 // Always 100 max
--    staminaBonus = flyBonus
--    maxJumpStamina = baseStamina + flyBonus
++    // Calculate percentage of flies munched
--    maxJumpStamina = min(maxJumpStamina, 200)
++    let totalFliesInNight = fliesSpawnedThisNight + flies.length // Spawned + any remaining
--    jumpStamina = maxJumpStamina
++    let munchPercentage = fliesMunchedLastNight / totalFliesInNight
--    // IMPROVED: Combine notifications to reduce overlap
++    // Base stamina: 20 minimum, up to 100 for 50% or more flies munched
--    let staminaMessage = `Dawn: ${maxJumpStamina} stamina (${baseStamina} + ${flyBonus} from ${fliesMunchedLastNight} flies)`
++    if (munchPercentage >= 0.5) {
--    let warningMessage = ''
++      jumpStamina = 100 // Full stamina for eating 50%+ of flies
++    } else {
++      // Scale from 20 to 100 based on 0% to 50% munched
++      jumpStamina = Math.floor(20 + munchPercentage * 2 * 80)
++    }
++
++    // Create informative notification
++    let percentEaten = Math.floor(munchPercentage * 100)
++    let staminaMessage = `Dawn: ${jumpStamina}/100 stamina (${percentEaten}% of ${totalFliesInNight} flies eaten)`
--    if (maxJumpStamina <= 50) {
++    if (jumpStamina <= 30) {
--      warningMessage = ' ⚠️ DANGER!'
        notifications.push(
--        new Notification(staminaMessage + warningMessage, color(255, 50, 50))
++        new Notification(staminaMessage + ' ⚠️ DANGER!', color(255, 50, 50))
+       )
--    } else if (maxJumpStamina <= 80) {
++    } else if (jumpStamina <= 60) {
--      warningMessage = ' - Low stamina!'
        notifications.push(
--        new Notification(staminaMessage + warningMessage, color(255, 150, 50))
++        new Notification(
++          staminaMessage + ' - Low stamina!',
++          color(255, 150, 50)
++        )
+       )
--    } else if (maxJumpStamina >= 150) {
++    } else if (jumpStamina >= 90) {
--      warningMessage = ' - Well fed!'
        notifications.push(
--        new Notification(staminaMessage + warningMessage, color(100, 255, 100))
++        new Notification(staminaMessage + ' - Well fed!', color(100, 255, 100))
+       )
      } else {
        notifications.push(new Notification(staminaMessage, color(255, 200, 100)))
      jumpStamina += regen
      jumpStamina = min(jumpStamina, maxJumpStamina)
++
++    // FIX: Only set exhausted when truly out of stamina
      isExhausted = jumpStamina < jumpCost
      // Update and display birds
        if (flyType === 'queen') fly.baseSpeed *= 0.5
        fly.currentSpeed = fly.baseSpeed
        flies.push(fly)
++      fliesSpawnedThisNight++ // Track dynamic spawn
+     }
      if (phaseTimer % 300 === 0 && foodBoxes.length < 6) {
        spawnFoodBox()
+ }
  function spawnNightFlies () {
++  // Reset counter for new night
++  fliesSpawnedThisNight = 0
++
    // Base flies + more per night
    let numFlies = 5 + currentNight
      if (flyType === 'queen') fly.baseSpeed *= 0.5 // Queens are much slower
      fly.currentSpeed = fly.baseSpeed
      flies.push(fly)
++    fliesSpawnedThisNight++ // Track spawn
+   }
    // PHASE 2: Guarantee at least 1 golden fly per night
      goldenFly.baseSpeed = baseFlySpeed * flySpeedMultiplier * 1.3
      goldenFly.currentSpeed = goldenFly.baseSpeed
      flies.push(goldenFly)
++    fliesSpawnedThisNight++ // Track spawn
      // Add notification
      notifications.push(
        new Notification('Golden Firefly Appeared! ✨', color(255, 215, 0))
      queenFly.baseSpeed = baseFlySpeed * flySpeedMultiplier * 0.5
      queenFly.currentSpeed = queenFly.baseSpeed
      flies.push(queenFly)
++    fliesSpawnedThisNight++ // Track spawn
      // Add notification
      notifications.push(
        new Notification('Queen Firefly Arrived! 👑', color(200, 100, 255))
+   }
+ }
--function handleWebDeployment() {
++function handleWebDeployment () {
    // Handle keyboard-based web deployment
    if (spacePressed && spider.isAirborne && !isDeployingWeb && webSilk > 10) {
--    isDeployingWeb = true;
++    isDeployingWeb = true
--    currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null);
++    currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
--    currentStrand.path = [spider.lastAnchorPoint.copy()];
++    currentStrand.path = [spider.lastAnchorPoint.copy()]
--
++
      // NEW: Check if starting from an obstacle
      for (let obstacle of obstacles) {
--      let d = dist(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y, obstacle.x, obstacle.y);
++      let d = dist(
++        spider.lastAnchorPoint.x,
++        spider.lastAnchorPoint.y,
++        obstacle.x,
++        obstacle.y
++      )
        // Check if anchor is on obstacle edge (within tolerance)
        if (abs(d - obstacle.radius) < 10) {
--        currentStrand.startObstacle = obstacle;
++        currentStrand.startObstacle = obstacle
          currentStrand.startAngle = atan2(
            spider.lastAnchorPoint.y - obstacle.y,
            spider.lastAnchorPoint.x - obstacle.x
--        );
++        )
--        break;
++        break
+       }
+     }
--
++
--    webStrands.push(currentStrand);
++    webStrands.push(currentStrand)
--
++
--    let newNode = new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y);
++    let newNode = new WebNode(
++      spider.lastAnchorPoint.x,
++      spider.lastAnchorPoint.y
++    )
      // NEW: Track node attachment if on obstacle
      if (currentStrand.startObstacle) {
--      newNode.attachedObstacle = currentStrand.startObstacle;
++      newNode.attachedObstacle = currentStrand.startObstacle
--      newNode.attachmentAngle = currentStrand.startAngle;
++      newNode.attachmentAngle = currentStrand.startAngle
+     }
--    webNodes.push(newNode);
++    webNodes.push(newNode)
+   }
    // Update web for keyboard controls
    if (currentStrand && isDeployingWeb && spider.isAirborne && spacePressed) {
--    currentStrand.end = spider.pos.copy();
++    currentStrand.end = spider.pos.copy()
      if (frameCount % 2 === 0) {
--      currentStrand.path.push(spider.pos.copy());
++      currentStrand.path.push(spider.pos.copy())
+     }
+   }
    // Touch-based web deployment is handled in touchMoved()
+ }
--
  function updateUI () {
    // Update control instructions based on device
    let isMobile =
      '<br>' +
      'Web Strands: <span id="strand-count">0</span><br>' +
      'Flies Caught: <span id="flies-caught">0</span> | Munched: <span id="flies-munched">0</span><br>' +
--    'Total Score: <span id="total-score">0</span>'
++    'Points: <span id="player-points">0</span> | Total Score: <span id="total-score">0</span>'
--  // PHASE 1 UPDATES
++  // Update all the displays
    document.getElementById('strand-count').textContent = webStrands.filter(
      s => !s.broken
    ).length
    document.getElementById('flies-caught').textContent = fliesCaught
    document.getElementById('flies-munched').textContent = fliesMunched
++  document.getElementById('player-points').textContent = playerPoints // NEW
    document.getElementById('total-score').textContent = totalFliesCaught
    // Update phase display
      timerText +
      `<br><small ${staminaColor}>Dawn Stamina: ${potentialStamina}</small>`
--  if (gamePhase === 'DUSK') {
++  if (gamePhase === 'NIGHT') {
--    let timeLeft = Math.ceil((DUSK_DURATION - phaseTimer) / 60)
++  let timeLeft = Math.ceil((NIGHT_DURATION - phaseTimer) / 60);
--    timerText = `${timeLeft}s to prepare!`
++
--  } else if (gamePhase === 'NIGHT') {
++  // Calculate current munch percentage
--    let timeLeft = Math.ceil((NIGHT_DURATION - phaseTimer) / 60)
++  let totalFliesInNight = fliesSpawnedThisNight + flies.length;
--    // PHASE 2: Count different fly types
++  let currentMunchPercent = totalFliesInNight > 0 ?
--    let regularCount = flies.filter(f => f.type === 'regular').length
++    Math.floor((fliesMunched / totalFliesInNight) * 100) : 0;
--    let goldenCount = flies.filter(f => f.type === 'golden').length
++
--    let mothCount = flies.filter(f => f.type === 'moth').length
++  // Calculate predicted dawn stamina
--    let queenCount = flies.filter(f => f.type === 'queen').length
++  let predictedStamina;
--
++  if (currentMunchPercent >= 50) {
--    timerText = `${timeLeft}s • ${flies.length} flies`
++    predictedStamina = 100;
--
++  } else {
--    // Show special fly counts if any
++    predictedStamina = Math.floor(20 + (currentMunchPercent * 2) * 0.8);
--    if (goldenCount > 0 || mothCount > 0 || queenCount > 0) {
++  }
--      let specialCounts = []
++
--      if (queenCount > 0) specialCounts.push(`${queenCount}👑`)
++  timerText = `${timeLeft}s • ${flies.length} flies`;
--      if (goldenCount > 0) specialCounts.push(`${goldenCount}✨`)
++
--      if (mothCount > 0) specialCounts.push(`${mothCount}🦋`)
++  // Show special fly counts if any
--      timerText += ` (${specialCounts.join(' ')})`
++  let goldenCount = flies.filter(f => f.type === 'golden').length;
--    }
++  let mothCount = flies.filter(f => f.type === 'moth').length;
++  let queenCount = flies.filter(f => f.type === 'queen').length;
++
++  if (goldenCount > 0 || mothCount > 0 || queenCount > 0) {
++    let specialCounts = [];
++    if (queenCount > 0) specialCounts.push(`${queenCount}👑`);
++    if (goldenCount > 0) specialCounts.push(`${goldenCount}✨`);
++    if (mothCount > 0) specialCounts.push(`${mothCount}🦋`);
++    timerText += ` (${specialCounts.join(' ')})`;
++  }
++   // Show munch progress
++  document.getElementById('timer').innerHTML = timerText +
++    `<br><small style="color: ${predictedStamina < 40 ? '#ff4444' : predictedStamina < 70 ? '#ffaa44' : '#44ff44'}">` +
++    `Munched: ${currentMunchPercent}% → ${predictedStamina} dawn stamina</small>`;
    } else if (gamePhase === 'DAWN') {
      let timeLeft = Math.ceil((DAWN_DURATION - phaseTimer) / 60)
      // PHASE 4: Show birds and exhaustion status
+   }
    // PHASE 4: Update meter based on phase
--  if (gamePhase === 'DAWN') {
++if (gamePhase === 'DAWN') {
--    // Show stamina instead of silk during dawn
++  // Show stamina instead of silk during dawn
--    document.getElementById('web-meter-label').textContent = 'STAMINA'
++  document.getElementById('web-meter-label').textContent = 'STAMINA';
--    let staminaPercent = (jumpStamina / maxJumpStamina) * 100
++
--    document.getElementById('web-meter-fill').style.width = staminaPercent + '%'
++  // FIX: Always show percentage out of 100, not out of variable max
--
++  let staminaPercent = (jumpStamina / 100) * 100; // Always out of 100
--    // Color based on stamina level
++  document.getElementById('web-meter-fill').style.width = staminaPercent + '%';
--    if (jumpStamina < jumpCost) {
++
--      // Exhausted - red flash
++  // Color based on stamina level
--      let flash = sin(frameCount * 0.3) * 0.5 + 0.5
++  if (jumpStamina < 20) {
--      document.getElementById(
++    // Exhausted - red flash
--        'web-meter-fill'
++    let flash = sin(frameCount * 0.3) * 0.5 + 0.5;
--      ).style.background = `linear-gradient(90deg, rgb(255, ${
++    document.getElementById('web-meter-fill').style.background =
--        50 + flash * 50
++      `linear-gradient(90deg, rgb(255, ${50 + flash * 50}, ${50 + flash * 50}), rgb(200, ${30 + flash * 30}, ${30 + flash * 30}))`;
--      }, ${50 + flash * 50}), rgb(200, ${30 + flash * 30}, ${30 + flash * 30}))`
++  } else if (jumpStamina < 40) {
--    } else if (jumpStamina < maxJumpStamina * 0.3) {
++    // Very tired - orange-red
--      // Very tired - orange-red
++    document.getElementById('web-meter-fill').style.background = 'linear-gradient(90deg, #FF6B35, #FF4444)';
--      document.getElementById('web-meter-fill').style.background =
++  } else if (jumpStamina < 60) {
--        'linear-gradient(90deg, #FF6B35, #FF4444)'
++    // Tired - orange
--    } else if (jumpStamina < maxJumpStamina * 0.5) {
++    document.getElementById('web-meter-fill').style.background = 'linear-gradient(90deg, #FFA500, #FF8C00)';
--      // Tired - orange
++  } else if (jumpStamina < 80) {
--      document.getElementById('web-meter-fill').style.background =
++    // OK - yellow-orange
--        'linear-gradient(90deg, #FFA500, #FF8C00)'
++    document.getElementById('web-meter-fill').style.background = 'linear-gradient(90deg, #FFD700, #FFA500)';
--    } else {
--      // Good stamina - yellow-orange
--      document.getElementById('web-meter-fill').style.background =
--        'linear-gradient(90deg, #FFD700, #FFA500)'
--    }
--    if (jumpStamina <= 0 && !gameOver) {
--      push()
--      fill(255, 0, 0, 50 + sin(frameCount * 0.3) * 50)
--      rect(0, 0, width, height)
--
--      textAlign(CENTER)
--      textSize(32)
--      fill(255, 50, 50)
--      stroke(0)
--      strokeWeight(3)
--      text('NO STAMINA - AVOID BIRDS!', width / 2, height / 2)
--      pop()
--    }
    } else {
++    // Good stamina - green-yellow
++    document.getElementById('web-meter-fill').style.background = 'linear-gradient(90deg, #90EE90, #FFD700)';
++  }
++
++  // Show critical warning overlay
++  if (jumpStamina <= 0 && !gameOver) {
++    push();
++    fill(255, 0, 0, 50 + sin(frameCount * 0.3) * 50);
++    rect(0, 0, width, height);
++
++    textAlign(CENTER);
++    textSize(32);
++    fill(255, 50, 50);
++    stroke(0);
++    strokeWeight(3);
++    text('NO STAMINA - AVOID BIRDS!', width / 2, height / 2);
++    pop();
++  }
++} else {
      // Normal silk meter
      document.getElementById('web-meter-label').textContent = 'SILK'
      let meterPercent = (webSilk / maxWebSilk) * 100
    currentNight = 1
    fliesCaught = 0
    fliesMunched = 0
++  playerPoints = 0
    totalFliesCaught = 0
    jumpStamina = 100
    maxJumpStamina = 100
+   }
+ }
--function touchStarted() {
++function touchStarted () {
    if (touches.length > 0) {
--    touchStartTime = millis();
++    touchStartTime = millis()
--    touchStartX = touches[0].x;
++    touchStartX = touches[0].x
--    touchStartY = touches[0].y;
++    touchStartY = touches[0].y
      // Check for double tap on spider to munch
--    let touchOnSpider = dist(touches[0].x, touches[0].y, spider.pos.x, spider.pos.y) < 30;
++    let touchOnSpider =
++      dist(touches[0].x, touches[0].y, spider.pos.x, spider.pos.y) < 30
      if (touchOnSpider && millis() - lastTapTime < 300) {
        // Double tap detected on spider - MUNCH!
--      spider.munch();
++      spider.munch()
--      lastTapTime = 0; // Reset to prevent triple tap
++      lastTapTime = 0 // Reset to prevent triple tap
      } else if (!spider.isAirborne) {
        // Single tap while on ground - jump
--      spider.jump(touches[0].x, touches[0].y);
++      spider.jump(touches[0].x, touches[0].y)
--      lastTapTime = millis();
++      lastTapTime = millis()
      } else if (spider.isAirborne && webSilk > 10 && !isDeployingWeb) {
        // Start web deployment if airborne (only if not already deploying)
--      touchHolding = true;
++      touchHolding = true
--      isDeployingWeb = true;
++      isDeployingWeb = true
--      currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null);
++      currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
--      currentStrand.path = [spider.lastAnchorPoint.copy()];
++      currentStrand.path = [spider.lastAnchorPoint.copy()]
--
++
        for (let obstacle of obstacles) {
--        let d = dist(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y, obstacle.x, obstacle.y);
++        let d = dist(
++          spider.lastAnchorPoint.x,
++          spider.lastAnchorPoint.y,
++          obstacle.x,
++          obstacle.y
++        )
          // Check if anchor is on obstacle edge (within tolerance)
          if (abs(d - obstacle.radius) < 10) {
--          currentStrand.startObstacle = obstacle;
++          currentStrand.startObstacle = obstacle
            currentStrand.startAngle = atan2(
              spider.lastAnchorPoint.y - obstacle.y,
              spider.lastAnchorPoint.x - obstacle.x
--          );
++          )
--          break;
++          break
+         }
+       }
--
++
--      webStrands.push(currentStrand);
++      webStrands.push(currentStrand)
--
++
--      let newNode = new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y);
++      let newNode = new WebNode(
++        spider.lastAnchorPoint.x,
++        spider.lastAnchorPoint.y
++      )
        // NEW: Track node attachment if on obstacle
        if (currentStrand.startObstacle) {
--        newNode.attachedObstacle = currentStrand.startObstacle;
++        newNode.attachedObstacle = currentStrand.startObstacle
--        newNode.attachmentAngle = currentStrand.startAngle;
++        newNode.attachmentAngle = currentStrand.startAngle
+       }
--      webNodes.push(newNode);
++      webNodes.push(newNode)
      } else if (spider.isAirborne && isDeployingWeb) {
        // If already deploying and user taps again, just continue (don't create new strand)
--      touchHolding = true;
++      touchHolding = true
+     }
+   }
--  return false; // Prevent default
++  return false // Prevent default
+ }
  function touchMoved () {

`@@ -54,7 +54,6 @@` sudo chown -R root:root "$RELEASES/$STAMP"
54	sudo find "$RELEASES/$STAMP" -type d -exec chmod 0755 {} +	54	sudo find "$RELEASES/$STAMP" -type d -exec chmod 0755 {} +
55	sudo find "$RELEASES/$STAMP" -type f -exec chmod 0644 {} +	55	sudo find "$RELEASES/$STAMP" -type f -exec chmod 0644 {} +
56		56
57	-# If the nginx user is different on your system, adjust here
58	NGINX_USER="nginx"	57	NGINX_USER="nginx"
59	if id "$NGINX_USER" >/dev/null 2>&1; then	58	if id "$NGINX_USER" >/dev/null 2>&1; then
60	sudo -u "$NGINX_USER" test -r "$RELEASES/$STAMP/index.html" \|\| { echo "✗ nginx user cannot read index.html"; exit 1; }	59	sudo -u "$NGINX_USER" test -r "$RELEASES/$STAMP/index.html" \|\| { echo "✗ nginx user cannot read index.html"; exit 1; }

`@@ -13,7 +13,7 @@`
13	Click to jump • Space to spin web • Shift to munch!<br>	13	Click to jump • Space to spin web • Shift to munch!<br>
14	Web Strands: <span id="strand-count">0</span><br>	14	Web Strands: <span id="strand-count">0</span><br>
15	Flies Caught: <span id="flies-caught">0</span> \| Munched: <span id="flies-munched">0</span><br>	15	Flies Caught: <span id="flies-caught">0</span> \| Munched: <span id="flies-munched">0</span><br>
16	- Total Score: <span id="total-score">0</span>	16	+ Points: <span id="player-points">0</span> \| Total Score: <span id="total-score">0</span>
17	</div>	17	</div>
18	<div id="phase-indicator">	18	<div id="phase-indicator">
19	<span id="phase">DUSK</span><br>	19	<span id="phase">DUSK</span><br>