`9a2a133`

endgame

Authored by

espadonne 8 months ago

SHA: 9a2a1339a7ab4199cfeeda4c95a548f8cbf21ce8
Parents: 7a7d1c9
Tree: 42077be

2 changed files

Status	File	+	-
M	`js/entities.js`	1177	1000
M	`js/game.js`	2779	976

js/entities.jsmodified

2811 lines changed — click to load

  // entities.js - All game entity classes
  class Spider {
 -  constructor(x, y) {
 -    this.pos = createVector(x, y);
 -    this.vel = createVector(0, 0);
 -    this.acc = createVector(0, 0);
 -    this.radius = 8;
 -    this.isAirborne = false;
 -    this.canJump = true;
 -    this.lastAnchorPoint = null;
 -    this.gravity = createVector(0, 0.3);
 -    this.jumpPower = 12;
 -    this.maxSpeed = 15;
 -    this.munchRadius = 20;
 -    this.munchCooldown = 0;
 -    this.attachedObstacle = null; // Track which obstacle spider is on
 +  constructor (x, y) {
 +    this.pos = createVector(x, y)
 +    this.vel = createVector(0, 0)
 +    this.acc = createVector(0, 0)
 +    this.radius = 8
 +    this.isAirborne = false
 +    this.canJump = true
 +    this.lastAnchorPoint = null
 +    this.gravity = createVector(0, 0.3)
 +    this.jumpPower = 12
 +    this.maxSpeed = 15
 +    this.munchRadius = 20
 +    this.munchCooldown = 0
 +    this.attachedObstacle = null // Track which obstacle spider is on
+   }
 -  jump(targetX, targetY) {
 -    if (!this.canJump || this.isAirborne) return; // Don't jump if already airborne
+-
 -    let direction = createVector(targetX - this.pos.x, targetY - this.pos.y);
 -    let clickDistance = direction.mag();
 -    direction.normalize();
+-
 -    // Scale jump power based on click distance (closer clicks = smaller jumps)
 -    let actualJumpPower = map(clickDistance, 0, 200, 3, this.jumpPower);
 -    actualJumpPower = constrain(actualJumpPower, 3, this.jumpPower);
 -    direction.mult(actualJumpPower);
+-
 -    this.vel = direction;
 -    this.isAirborne = true;
 -    this.canJump = false;
 -    this.lastAnchorPoint = this.pos.copy();
 +  jump (targetX, targetY, chargeMultiplier = 1) {
 +    if (!this.canJump || this.isAirborne) return
++
 +    // DAWN PHASE: Check and consume stamina
 +    if (gamePhase === 'DAWN') {
 +      if (jumpStamina < jumpCost) {
 +        // Not enough stamina to jump
 +        isExhausted = true
 +        return // Can't jump
 +      }
 +      // Consume stamina for jump
 +      jumpStamina -= jumpCost
 +      stats.totalJumps++
 +    }
++
 +    // PHASE 4B: Track wind jumps
 +    if (windActive) {
 +      stats.windJumps++
 +      achievements.windRider.progress++
 +    }
++
 +    let direction = createVector(targetX - this.pos.x, targetY - this.pos.y)
 +    let clickDistance = direction.mag()
 +    direction.normalize()
++
 +    // Apply charge multiplier if provided
 +    let actualJumpPower = map(
 +      clickDistance,
 +      0,
 +      200,
 +      3,
 +      this.jumpPower * chargeMultiplier
 +    )
 +    actualJumpPower = constrain(
 +      actualJumpPower,
 +      3,
 +      this.jumpPower * chargeMultiplier
 +    )
 +    direction.mult(actualJumpPower)
++
 +    this.vel = direction
 +    this.isAirborne = true
 +    this.canJump = false
 +    this.lastAnchorPoint = this.pos.copy()
      // Record jump time for touch debounce
      if (typeof window !== 'undefined') {
 -      window.lastJumpTime = millis();
 +      window.lastJumpTime = millis()
+     }
+-
++
      // Check if we're jumping off a web strand
      for (let strand of webStrands) {
 -      if (strand === currentStrand) continue;
+-
 +      if (strand === currentStrand) continue
++
        if (this.checkStrandCollision(strand)) {
          // Much simpler shimmy detection based on actual jump power used
 -        let isShimmy = actualJumpPower < 6; // If we used less than half power, it's a shimmy
+-
 +        let isShimmy = actualJumpPower < 6 // If we used less than half power, it's a shimmy
++
          // Apply appropriate recoil based on movement type
          if (isShimmy) {
            // Trigger shimmy visual effect
 -          this.shimmyEffect = 20;
+-
 +          this.shimmyEffect = 20
++
            // NO recoil at all for shimmying - just tiny vibration
 -          strand.vibrate(0.3);
+-
 +          strand.vibrate(0.3)
++
            // Tiny yellow particles
 -          let p = new Particle(this.pos.x, this.pos.y);
 -          p.color = color(255, 255, 100, 80);
 -          p.vel = createVector(random(-0.3, 0.3), random(-0.3, 0.3));
 -          p.size = 2;
 -          particles.push(p);
 +          let p = new Particle(this.pos.x, this.pos.y)
 +          p.color = color(255, 255, 100, 80)
 +          p.vel = createVector(random(-0.3, 0.3), random(-0.3, 0.3))
 +          p.size = 2
 +          particles.push(p)
          } else {
            // Scale recoil based on actual jump power
 -          let recoilForce = -(actualJumpPower / this.jumpPower) * 0.08; // Scale by power ratio
 -          strand.applyRecoil(recoilForce);
+-
 +          let recoilForce = -(actualJumpPower / this.jumpPower) * 0.08 // Scale by power ratio
 +          strand.applyRecoil(recoilForce)
++
            // Create particles only for real jumps
            for (let i = 0; i < 2; i++) {
 -            let p = new Particle(this.pos.x, this.pos.y);
 -            p.color = color(255, 255, 255, 120);
 -            p.vel = createVector(random(-0.8, 0.8), random(1, 2));
 -            p.size = 3;
 -            particles.push(p);
 +            let p = new Particle(this.pos.x, this.pos.y)
 +            p.color = color(255, 255, 255, 120)
 +            p.vel = createVector(random(-0.8, 0.8), random(1, 2))
 +            p.size = 3
 +            particles.push(p)
+           }
+         }
+-
 -        break;
++
 +        break
+       }
+     }
+   }
+-
 -  munch() {
 -    if (this.munchCooldown > 0) return;
 -    isMunching = true;
 -    this.munchCooldown = 30;
 +  munch () {
 +    if (this.munchCooldown > 0) return
++
 +    isMunching = true
 +    this.munchCooldown = 30
      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);
 +      let fly = flies[i]
 +      let d = dist(this.pos.x, this.pos.y, fly.pos.x, fly.pos.y)
        if (d < this.munchRadius) {
 -        fliesMunched++;
 -        webSilk = min(webSilk + 15, maxWebSilk);
 +        fliesMunched++
 +        webSilk = min(webSilk + 15, maxWebSilk)
          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);
 -          particles.push(p);
 +          let p = new Particle(fly.pos.x, fly.pos.y)
 +          p.color = color(255, random(100, 255), 0)
 +          particles.push(p)
+         }
 -        flies.splice(i, 1);
 -        break;
 +        flies.splice(i, 1)
 +        break
+       }
+     }
+   }
 -  update() {
 +  update () {
      // If attached to a moving obstacle, move with it
      if (this.attachedObstacle && !this.isAirborne) {
        // Calculate angle from obstacle center to spider
 -      let angle = atan2(this.pos.y - this.attachedObstacle.y, this.pos.x - this.attachedObstacle.x);
 +      let angle = atan2(
 +        this.pos.y - this.attachedObstacle.y,
 +        this.pos.x - this.attachedObstacle.x
 +      )
        // Keep spider on the surface of the obstacle
 -      this.pos.x = this.attachedObstacle.x + cos(angle) * (this.attachedObstacle.radius + this.radius);
 -      this.pos.y = this.attachedObstacle.y + sin(angle) * (this.attachedObstacle.radius + this.radius);
 +      this.pos.x =
 +        this.attachedObstacle.x +
 +        cos(angle) * (this.attachedObstacle.radius + this.radius)
 +      this.pos.y =
 +        this.attachedObstacle.y +
 +        sin(angle) * (this.attachedObstacle.radius + this.radius)
+     }
+-
++
      if (this.isAirborne) {
 -      this.acc.add(this.gravity);
 -      this.attachedObstacle = null; // Clear attachment when jumping
 +      this.acc.add(this.gravity)
 +      this.attachedObstacle = null // Clear attachment when jumping
+     }
 -    this.vel.add(this.acc);
 -    this.vel.limit(this.maxSpeed);
 -    this.pos.add(this.vel);
 -    this.acc.mult(0);
 +    this.vel.add(this.acc)
 +    this.vel.limit(this.maxSpeed)
 +    this.pos.add(this.vel)
 +    this.acc.mult(0)
      if (this.munchCooldown > 0) {
 -      this.munchCooldown--;
 +      this.munchCooldown--
        if (this.munchCooldown === 0) {
 -        isMunching = false;
 +        isMunching = false
+       }
+     }
      // Check ground collision
      if (this.pos.y >= height - this.radius) {
 -      this.pos.y = height - this.radius;
 -      this.land();
 -      this.attachedObstacle = null;
 +      this.pos.y = height - this.radius
 +      this.land()
 +      this.attachedObstacle = null
+     }
      // Check wall collisions
      if (this.pos.x <= this.radius || this.pos.x >= width - this.radius) {
 -      this.pos.x = constrain(this.pos.x, this.radius, width - this.radius);
 -      this.vel.x *= -0.5;
 +      this.pos.x = constrain(this.pos.x, this.radius, width - this.radius)
 +      this.vel.x *= -0.5
+     }
      // Check ceiling
      if (this.pos.y <= this.radius) {
 -      this.pos.y = this.radius;
 -      this.vel.y *= -0.5; // Bounce off ceiling, don't land
 +      this.pos.y = this.radius
 +      this.vel.y *= -0.5 // Bounce off ceiling, don't land
+     }
      // Check home branch collision (one-way platform)
      if (window.homeBranch && this.isAirborne && this.vel.y > 0.1) {
        // Only when actually falling
 -      let branch = window.homeBranch;
 +      let branch = window.homeBranch
        // Check if spider is within branch X range
 -      let branchStart = Math.min(branch.startX, branch.endX);
 -      let branchEnd = Math.max(branch.startX, branch.endX);
 +      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),
        // we can use a simpler approximation
        if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
          // Calculate position along branch (0 to 1)
 -        let t = (this.pos.x - branchStart) / (branchEnd - branchStart);
 -        t = constrain(t, 0, 1);
 +        let t = (this.pos.x - branchStart) / (branchEnd - branchStart)
 +        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
            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;
 +        let branchSurfaceY = branch.y - branchTopThickness
          // Add slight angle correction (for small angles, tan ≈ sin ≈ angle in radians)
 -        let angleCorrection = (this.pos.x - branchStart) * branch.angle;
 -        branchSurfaceY += angleCorrection;
 +        let angleCorrection = (this.pos.x - branchStart) * branch.angle
 +        branchSurfaceY += angleCorrection
          // Check if spider is crossing the branch from above
 -        let prevY = this.pos.y - this.vel.y;
 +        let prevY = this.pos.y - this.vel.y
          if (
            prevY <= branchSurfaceY && // Was above
            // Not too far below
            // Place spider on the branch surface
 -          this.pos.y = branchSurfaceY - this.radius;
 -          this.land();
 -          this.attachedObstacle = null;
 +          this.pos.y = branchSurfaceY - this.radius
 +          this.land()
 +          this.attachedObstacle = null
+         }
+       }
+     }
      // Check obstacle collisions
      for (let obstacle of obstacles) {
        if (this.checkObstacleCollision(obstacle)) {
 -        this.landOnObstacle(obstacle);
 +        this.landOnObstacle(obstacle)
+       }
+     }
      // Check web strand collisions
      for (let strand of webStrands) {
 -      if (strand === currentStrand) continue;
 +      if (strand === currentStrand) continue
        if (this.isAirborne && this.checkStrandCollision(strand)) {
 -        this.landOnStrand(strand);
 +        this.landOnStrand(strand)
+       }
+     }
      // Check food box collisions
      for (let i = foodBoxes.length - 1; i >= 0; i--) {
 -      let box = foodBoxes[i];
 +      let box = foodBoxes[i]
        if (
          dist(this.pos.x, this.pos.y, box.pos.x, box.pos.y) <
          this.radius + box.radius
        ) {
 -        box.collect();
 -        foodBoxes.splice(i, 1);
 +        box.collect()
 +        foodBoxes.splice(i, 1)
+       }
+     }
+   }
 -  checkObstacleCollision(obstacle) {
 -    let d = dist(this.pos.x, this.pos.y, obstacle.x, obstacle.y);
 -    return d < this.radius + obstacle.radius;
 +  checkObstacleCollision (obstacle) {
 +    let d = dist(this.pos.x, this.pos.y, obstacle.x, obstacle.y)
 +    return d < this.radius + obstacle.radius
+   }
 -  checkStrandCollision(strand) {
 -    if (!strand || !strand.start || !strand.end) return false;
 -    let d = this.pointToLineDistance(this.pos, strand.start, strand.end);
 -    return d < this.radius + 2;
 +  checkStrandCollision (strand) {
 +    if (!strand || !strand.start || !strand.end) return false
 +    let d = this.pointToLineDistance(this.pos, strand.start, strand.end)
 +    return d < this.radius + 2
+   }
 -  pointToLineDistance(point, lineStart, lineEnd) {
 +  pointToLineDistance (point, lineStart, lineEnd) {
      // Guard nulls
      if (!lineStart || !lineEnd) {
 -      return Infinity;
 +      return Infinity
+     }
 -    let line = p5.Vector.sub(lineEnd, lineStart);
 -    let lineLength = line.mag();
 +    let line = p5.Vector.sub(lineEnd, lineStart)
 +    let lineLength = line.mag()
      // If start and end coincide, distance is to the single point
      if (lineLength === 0) {
 -      return p5.Vector.dist(point, lineStart);
 +      return p5.Vector.dist(point, lineStart)
+     }
 -    line.normalize();
 -    let pointToStart = p5.Vector.sub(point, lineStart);
 -    let projLength = constrain(pointToStart.dot(line), 0, lineLength);
 -    let closestPoint = p5.Vector.add(lineStart, p5.Vector.mult(line, projLength));
 -    return p5.Vector.dist(point, closestPoint);
 +    line.normalize()
 +    let pointToStart = p5.Vector.sub(point, lineStart)
 +    let projLength = constrain(pointToStart.dot(line), 0, lineLength)
 +    let closestPoint = p5.Vector.add(
 +      lineStart,
 +      p5.Vector.mult(line, projLength)
 +    )
 +    return p5.Vector.dist(point, closestPoint)
+   }
 -  landOnObstacle(obstacle) {
 +  landOnObstacle (obstacle) {
      // Only land if we're actually airborne
 -    if (!this.isAirborne) return;
+-
 -    let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x);
 -    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
 -    this.land();
 +    if (!this.isAirborne) return
++
 +    let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x)
 +    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
 +    this.land()
+   }
 -  landOnStrand(strand) {
 +  landOnStrand (strand) {
      // Only land if we're actually airborne
 -    if (!this.isAirborne) return;
 -    if (!strand || !strand.start || !strand.end) return;
 -    let line = p5.Vector.sub(strand.end, strand.start);
 -    let lineLength = line.mag();
 +    if (!this.isAirborne) return
 +    if (!strand || !strand.start || !strand.end) return
 +    let line = p5.Vector.sub(strand.end, strand.start)
 +    let lineLength = line.mag()
      if (lineLength === 0) {
        // Degenerate strand; snap to start
 -      this.pos = strand.start.copy ? strand.start.copy() : createVector(strand.start.x, strand.start.y);
 +      this.pos = strand.start.copy
 +        ? strand.start.copy()
 +        : createVector(strand.start.x, strand.start.y)
      } else {
 -      line.normalize();
 -      let pointToStart = p5.Vector.sub(this.pos, strand.start);
 -      let projLength = constrain(pointToStart.dot(line), 0, lineLength);
 -      let closestPoint = p5.Vector.add(strand.start, p5.Vector.mult(line, projLength));
 -      this.pos = closestPoint;
 +      line.normalize()
 +      let pointToStart = p5.Vector.sub(this.pos, strand.start)
 +      let projLength = constrain(pointToStart.dot(line), 0, lineLength)
 +      let closestPoint = p5.Vector.add(
 +        strand.start,
 +        p5.Vector.mult(line, projLength)
 +      )
 +      this.pos = closestPoint
+     }
 -    this.attachedObstacle = null; // Not on an obstacle
 -    this.land();
 +    this.attachedObstacle = null // Not on an obstacle
 +    this.land()
+   }
 -  land() {
 -    this.vel.mult(0);
 -    this.isAirborne = false;
 -    this.canJump = true;
 +  land () {
 +    this.vel.mult(0)
 +    this.isAirborne = false
 +    this.canJump = true
      if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
        // Ensure the strand has a valid end and a final node on landing
 -      currentStrand.end = this.pos.copy();
 +      currentStrand.end = this.pos.copy()
        if (!currentStrand.path || currentStrand.path.length === 0) {
 -          currentStrand.path = [this.pos.copy()];
 +        currentStrand.path = [this.pos.copy()]
        } else {
 -          currentStrand.path.push(this.pos.copy());
 +        currentStrand.path.push(this.pos.copy())
+       }
 -      webNodes.push(new WebNode(this.pos.x, this.pos.y));
 +      webNodes.push(new WebNode(this.pos.x, this.pos.y))
+     }
 -    currentStrand = null;
 -    isDeployingWeb = false;
 +    currentStrand = null
 +    isDeployingWeb = false
+   }
 -  display() {
 -    push();
 -    translate(this.pos.x, this.pos.y);
 +  display () {
 +    push()
 +    translate(this.pos.x, this.pos.y)
      if (isMunching && this.munchCooldown > 15) {
 -      push();
 -      fill(255, 100, 100, 150);
 -      noStroke();
 -      let munchSize = 15 + sin(frameCount * 0.5) * 5;
 -      arc(0, 0, munchSize, munchSize, 0, PI + HALF_PI, PIE);
 -      pop();
 +      push()
 +      fill(255, 100, 100, 150)
 +      noStroke()
 +      let munchSize = 15 + sin(frameCount * 0.5) * 5
 +      arc(0, 0, munchSize, munchSize, 0, PI + HALF_PI, PIE)
 +      pop()
+     }
 -    fill(20);
 -    stroke(0);
 -    strokeWeight(1);
 -    ellipse(0, 0, this.radius * 2);
 +    fill(20)
 +    stroke(0)
 +    strokeWeight(1)
 +    ellipse(0, 0, this.radius * 2)
 -    fill(40);
 -    noStroke();
 -    ellipse(0, -2, this.radius * 1.2, this.radius * 1.5);
 +    fill(40)
 +    noStroke()
 +    ellipse(0, -2, this.radius * 1.2, this.radius * 1.5)
      if (gamePhase === 'NIGHT') {
 -      fill(255, 100, 100);
 +      fill(255, 100, 100)
      } else {
 -      fill(255, 0, 0);
 +      fill(255, 0, 0)
+     }
 -    ellipse(-3, -3, 3);
 -    ellipse(3, -3, 3);
 +    ellipse(-3, -3, 3)
 +    ellipse(3, -3, 3)
 -    stroke(0);
 -    strokeWeight(1.5);
 +    stroke(0)
 +    strokeWeight(1.5)
      for (let i = 0; i < 4; i++) {
 -      let angle = PI / 6 + (i * PI) / 8;
 -      line(0, 0, cos(angle) * 12, sin(angle) * 8);
 -      line(0, 0, -cos(angle) * 12, sin(angle) * 8);
 +      let angle = PI / 6 + (i * PI) / 8
 +      line(0, 0, cos(angle) * 12, sin(angle) * 8)
 +      line(0, 0, -cos(angle) * 12, sin(angle) * 8)
+     }
      if (webSilk < 20) {
 -      fill(255, 100, 100, 150 + sin(frameCount * 0.2) * 50);
 -      noStroke();
 -      ellipse(0, -15, 8);
 +      fill(255, 100, 100, 150 + sin(frameCount * 0.2) * 50)
 +      noStroke()
 +      ellipse(0, -15, 8)
+     }
 -    pop();
 +    pop()
+   }
+ }
  class Fly {
 -  constructor() {
 +  constructor () {
      if (random() < 0.5) {
        this.pos = createVector(
          random() < 0.5 ? -20 : width + 20,
          random(50, height - 100)
 -      );
 +      )
      } else {
 -      this.pos = createVector(random(width), random() < 0.5 ? -20 : height + 20);
 +      this.pos = createVector(random(width), random() < 0.5 ? -20 : height + 20)
+     }
 -    this.vel = createVector(random(-2, 2), random(-1, 1));
 -    this.acc = createVector(0, 0);
 -    this.radius = 4;
 -    this.caught = false;
 -    this.stuck = false;
 -    this.wingPhase = random(TWO_PI);
 -    this.wanderAngle = random(TWO_PI);
 -    this.glowIntensity = random(150, 255);
 -    this.touchedStrands = new Set();
 -    this.slowedBy = new Set(); // Track which strands are slowing us
 -    this.baseSpeed = 3;
 -    this.currentSpeed = this.baseSpeed;
 +    this.vel = createVector(random(-2, 2), random(-1, 1))
 +    this.acc = createVector(0, 0)
 +    this.radius = 4
 +    this.caught = false
 +    this.stuck = false
 +    this.wingPhase = random(TWO_PI)
 +    this.wanderAngle = random(TWO_PI)
 +    this.glowIntensity = random(150, 255)
 +    this.touchedStrands = new Set()
 +    this.slowedBy = new Set() // Track which strands are slowing us
 +    this.baseSpeed = 3
 +    this.currentSpeed = this.baseSpeed
+   }
 -  update() {
 +  update () {
      if (this.stuck) {
        // If stuck, check if we need to move with a drifting web
 -      this.updatePositionOnWeb();
 -      return;
 +      this.updatePositionOnWeb()
 +      return
+     }
      if (this.caught) {
 -      this.vel.mult(0.95);
 +      this.vel.mult(0.95)
        if (this.vel.mag() < 0.1) {
 -        this.stuck = true;
 -        fliesCaught++;
 -        webSilk = min(webSilk + 5, maxWebSilk);
 +        this.stuck = true
 +        fliesCaught++
 +        webSilk = min(webSilk + 5, maxWebSilk)
+       }
        // While caught but not yet stuck, also follow the web
 -      this.updatePositionOnWeb();
 -      return;
 +      this.updatePositionOnWeb()
 +      return
+     }
 -    this.wanderAngle += random(-0.3, 0.3);
 -    let wanderForce = createVector(cos(this.wanderAngle), sin(this.wanderAngle));
 -    wanderForce.mult(0.1);
 -    this.acc.add(wanderForce);
 +    this.wanderAngle += random(-0.3, 0.3)
 +    let wanderForce = createVector(cos(this.wanderAngle), sin(this.wanderAngle))
 +    wanderForce.mult(0.1)
 +    this.acc.add(wanderForce)
      // Apply current speed (which may be slowed)
 -    this.vel.add(this.acc);
 -    this.vel.limit(this.currentSpeed);
 -    this.pos.add(this.vel);
 -    this.acc.mult(0);
 +    this.vel.add(this.acc)
 +    this.vel.limit(this.currentSpeed)
 +    this.pos.add(this.vel)
 +    this.acc.mult(0)
 -    if (this.pos.x < -30) this.pos.x = width + 30;
 -    if (this.pos.x > width + 30) this.pos.x = -30;
 -    if (this.pos.y < -30) this.pos.y = height + 30;
 -    if (this.pos.y > height + 30) this.pos.y = -30;
 +    if (this.pos.x < -30) this.pos.x = width + 30
 +    if (this.pos.x > width + 30) this.pos.x = -30
 +    if (this.pos.y < -30) this.pos.y = height + 30
 +    if (this.pos.y > height + 30) this.pos.y = -30
      // Check web collisions
 -    this.checkWebCollisions();
 +    this.checkWebCollisions()
+   }
+-
 -  updatePositionOnWeb() {
++
 +  updatePositionOnWeb () {
      // Find the web strand(s) this fly is attached to
      for (let strand of webStrands) {
 -      if (strand.broken) continue;
+-
 +      if (strand.broken) continue
++
        // Check if fly is on this strand
 -      let closestPoint = null;
 -      let closestDistance = Infinity;
+-
 +      let closestPoint = null
 +      let closestDistance = Infinity
++
        if (strand.path && strand.path.length > 1) {
          for (let i = 0; i < strand.path.length - 1; i++) {
 -          let p1 = strand.path[i];
 -          let p2 = strand.path[i + 1];
+-
 +          let p1 = strand.path[i]
 +          let p2 = strand.path[i + 1]
++
            // Find closest point on this segment
 -          let line = p5.Vector.sub(p2, p1);
 -          let lineLength = line.mag();
 -          if (lineLength === 0) continue;
 -          line.normalize();
+-
 -          let pointToStart = p5.Vector.sub(this.pos, p1);
 -          let projLength = constrain(pointToStart.dot(line), 0, lineLength);
+-
 -          let projPoint = p5.Vector.add(p1, p5.Vector.mult(line, projLength));
 -          let d = p5.Vector.dist(this.pos, projPoint);
+-
 +          let line = p5.Vector.sub(p2, p1)
 +          let lineLength = line.mag()
 +          if (lineLength === 0) continue
 +          line.normalize()
++
 +          let pointToStart = p5.Vector.sub(this.pos, p1)
 +          let projLength = constrain(pointToStart.dot(line), 0, lineLength)
++
 +          let projPoint = p5.Vector.add(p1, p5.Vector.mult(line, projLength))
 +          let d = p5.Vector.dist(this.pos, projPoint)
++
            if (d < closestDistance && d < this.radius + 5) {
 -            closestDistance = d;
 -            closestPoint = projPoint;
 +            closestDistance = d
 +            closestPoint = projPoint
+           }
+         }
+       }
+-
++
        // If we found a close point on this strand, stick to it
        if (closestPoint) {
          // Move fly to follow the strand's movement
 -        this.pos.x = closestPoint.x;
 -        this.pos.y = closestPoint.y;
+-
 +        this.pos.x = closestPoint.x
 +        this.pos.y = closestPoint.y
++
          // Add small vibration when on a moving web
          if (strand.vibration > 0) {
 -          this.pos.x += random(-1, 1) * strand.vibration * 0.1;
 -          this.pos.y += random(-1, 1) * strand.vibration * 0.1;
 +          this.pos.x += random(-1, 1) * strand.vibration * 0.1
 +          this.pos.y += random(-1, 1) * strand.vibration * 0.1
+         }
+       }
+     }
+   }
 -  checkWebCollisions() {
 +    checkWebCollisions() {
      let currentlyTouching = new Set();
      for (let strand of webStrands) {
        // Check collision with strand path
        if (strand.path && strand.path.length > 1) {
 -        for (let i = 0; i < strand.path.length - 1; i++) {
 +        // OPTIMIZATION: Skip every other point for collision detection
 +        for (let i = 0; i < strand.path.length - 1; i += 2) {
            let p1 = strand.path[i];
 -          let p2 = strand.path[i + 1];
 +          let p2 = strand.path[Math.min(i + 1, strand.path.length - 1)];
            let d = this.pointToLineDistance(this.pos, p1, p2);
            if (d < this.radius + 3) {
              touching = true;
              this.slowedBy.add(strand);
              // Visual feedback - yellow particles for slowing
 -            for (let j = 0; j < 3; j++) {
 +            // LIMIT PARTICLES TO PREVENT FREEZE
 +            let particleCount = Math.min(3, 100 - particles.length);
 +            for (let j = 0; j < particleCount; j++) {
                let p = new Particle(this.pos.x, this.pos.y);
                p.color = color(255, 255, 0, 150);
                p.vel = createVector(random(-1, 1), random(-1, 1));
              // Stronger vibration when caught
              strand.vibrate(8);
 -            // Also vibrate nearby strands
 -            for (let otherStrand of webStrands) {
 -              if (otherStrand !== strand) {
 -                for (let touchedStrand of this.touchedStrands) {
 -                  let d1 = dist(
 -                    otherStrand.start.x,
 -                    otherStrand.start.y,
 -                    touchedStrand.start.x,
 -                    touchedStrand.start.y
 -                  );
 -                  let d2 = dist(
 -                    otherStrand.start.x,
 -                    otherStrand.start.y,
 -                    touchedStrand.end.x,
 -                    touchedStrand.end.y
 -                  );
 -                  let d3 = dist(
 -                    otherStrand.end.x,
 -                    otherStrand.end.y,
 -                    touchedStrand.start.x,
 -                    touchedStrand.start.y
 -                  );
 -                  let d4 = dist(
 -                    otherStrand.end.x,
 -                    otherStrand.end.y,
 -                    touchedStrand.end.x,
 -                    touchedStrand.end.y
 -                  );
 -                  if (min(d1, d2, d3, d4) < 50) {
 -                    otherStrand.vibrate(2);
 -                    break;
 -                  }
 -                }
 -              }
 -            }
 +            // FIX: OPTIMIZE NEARBY STRAND VIBRATION
 +            // This is likely the main cause of the freeze - checking distances between all strands
 +            // Use a more efficient method
 +            propagateVibration(strand, 2);
 -            // Create caught particles
 -            for (let j = 0; j < 6; j++) {
 +            // Create caught particles - LIMIT TO PREVENT FREEZE
 +            let particleCount = Math.min(6, 100 - particles.length);
 +            for (let j = 0; j < particleCount; j++) {
                let p = new Particle(this.pos.x, this.pos.y);
                p.color = color(255, 200, 0, 200);
                p.vel = createVector(random(-2, 2), random(-2, 2));
+   }
    pointToLineDistance(point, lineStart, lineEnd) {
 -    let line = p5.Vector.sub(lineEnd, lineStart);
 -    let lineLength = line.mag();
 -    line.normalize();
+-
 -    let pointToStart = p5.Vector.sub(point, lineStart);
 -    let projLength = constrain(pointToStart.dot(line), 0, lineLength);
+-
 -    let closestPoint = p5.Vector.add(
 -      lineStart,
 -      p5.Vector.mult(line, projLength)
 -    );
 -    return p5.Vector.dist(point, closestPoint);
 +    // Add null checks
 +    if (!point || !lineStart || !lineEnd) return Infinity;
++
 +    let dx = lineEnd.x - lineStart.x;
 +    let dy = lineEnd.y - lineStart.y;
 +    let lineLength = sqrt(dx * dx + dy * dy);
++
 +    // If line has no length, return distance to point
 +    if (lineLength < 0.01) {
 +      return dist(point.x, point.y, lineStart.x, lineStart.y);
 +    }
++
 +    // Use optimized calculation without creating new vectors
 +    let t = ((point.x - lineStart.x) * dx + (point.y - lineStart.y) * dy) / (lineLength * lineLength);
 +    t = constrain(t, 0, 1);
++
 +    let closestX = lineStart.x + t * dx;
 +    let closestY = lineStart.y + t * dy;
++
 +    return dist(point.x, point.y, closestX, closestY);
+   }
 -  display() {
 -    push();
 -    translate(this.pos.x, this.pos.y);
 +  display () {
 +    push()
 +    translate(this.pos.x, this.pos.y)
      // Show slowdown effect
      if (this.slowedBy.size > 0 && !this.caught) {
 -      stroke(255, 255, 0, 100);
 -      strokeWeight(1);
 -      noFill();
 -      ellipse(0, 0, 20);
 +      stroke(255, 255, 0, 100)
 +      strokeWeight(1)
 +      noFill()
 +      ellipse(0, 0, 20)
+     }
      if (gamePhase === 'NIGHT') {
 -      noStroke();
 -      fill(255, 255, 150, this.glowIntensity * 0.3);
 -      ellipse(0, 0, 30);
 -      fill(255, 255, 100, this.glowIntensity * 0.5);
 -      ellipse(0, 0, 20);
 +      noStroke()
 +      fill(255, 255, 150, this.glowIntensity * 0.3)
 +      ellipse(0, 0, 30)
 +      fill(255, 255, 100, this.glowIntensity * 0.5)
 +      ellipse(0, 0, 20)
+     }
 -    fill(30);
 -    stroke(0);
 -    strokeWeight(0.5);
 -    ellipse(0, 0, this.radius * 2);
 +    fill(30)
 +    stroke(0)
 +    strokeWeight(0.5)
 +    ellipse(0, 0, this.radius * 2)
      if (!this.stuck) {
        // Wing animation slows down when slowed
 -      let wingSpeed = this.slowedBy.size > 0 ? 0.25 : 0.5;
 -      this.wingPhase += wingSpeed;
 -      let wingSpread = sin(this.wingPhase) * 5;
+-
 -      fill(255, 255, 255, 150);
 -      noStroke();
 -      ellipse(-wingSpread, 0, 6, 4);
 -      ellipse(wingSpread, 0, 6, 4);
 +      let wingSpeed = this.slowedBy.size > 0 ? 0.25 : 0.5
 +      this.wingPhase += wingSpeed
 +      let wingSpread = sin(this.wingPhase) * 5
++
 +      fill(255, 255, 255, 150)
 +      noStroke()
 +      ellipse(-wingSpread, 0, 6, 4)
 +      ellipse(wingSpread, 0, 6, 4)
+     }
      if (gamePhase === 'NIGHT') {
 -      fill(255, 255, 100, this.glowIntensity);
 -      noStroke();
 -      ellipse(0, 2, 3);
 +      fill(255, 255, 100, this.glowIntensity)
 +      noStroke()
 +      ellipse(0, 2, 3)
+     }
 -    pop();
 +    pop()
+   }
+ }
  class Obstacle {
 -  constructor(x, y, radius, type) {
 +  constructor (x, y, radius, type) {
      // Store original position for drift tracking
 -    this.originalX = x;
 -    this.originalY = y;
 -    this.x = x;
 -    this.y = y;
 -    this.radius = radius;
 -    this.type = type || 'leaf';
 -    this.rotation = random(TWO_PI);
 -    this.leafPoints = [];
+-
 +    this.originalX = x
 +    this.originalY = y
 +    this.x = x
 +    this.y = y
 +    this.radius = radius
 +    this.type = type || 'leaf'
 +    this.rotation = random(TWO_PI)
 +    this.leafPoints = []
++
      // Movement properties for all types
 -    this.bobOffset = random(TWO_PI);
 -    this.bobSpeed = random(0.02, 0.04);
 -    this.bobAmount = 0;
+-
 +    this.bobOffset = random(TWO_PI)
 +    this.bobSpeed = random(0.02, 0.04)
 +    this.bobAmount = 0
++
      // Type-specific initialization
      if (this.type === 'balloon') {
 -      this.bobAmount = 8; // Balloons bob more
 +      this.bobAmount = 8 // Balloons bob more
        this.balloonColors = [
          color(255, 100, 100), // Red
 -        color(100, 200, 255), // Blue
 -        color(255, 200, 100)  // Yellow
 -      ];
 -      this.balloonColor = random(this.balloonColors);
 -      this.stringWave = 0;
 -      this.antLegPhase = random(TWO_PI);
+-
 +        color(100, 200, 255), // Blue
 +        color(255, 200, 100) // Yellow
 +      ]
 +      this.balloonColor = random(this.balloonColors)
 +      this.stringWave = 0
 +      this.antLegPhase = random(TWO_PI)
      } else if (this.type === 'beetle') {
 -      this.bobAmount = 4;
 -      this.driftSpeed = random(0.15, 0.35);
 -      this.driftAngle = random(TWO_PI);
 -      this.driftChangeRate = random(0.005, 0.015);
 -      this.wingPhase = random(TWO_PI);
 -      this.beetleColor = random() < 0.5 ?
 -        color(20, 60, 20) : // Dark green
 -        color(40, 20, 60);   // Purple
 -      this.driftDistance = 0; // Track total drift
+-
 +      this.bobAmount = 4
 +      this.driftSpeed = random(0.15, 0.35)
 +      this.driftAngle = random(TWO_PI)
 +      this.driftChangeRate = random(0.005, 0.015)
 +      this.wingPhase = random(TWO_PI)
 +      this.beetleColor =
 +        random() < 0.5
 +          ? color(20, 60, 20) // Dark green
 +          : color(40, 20, 60) // Purple
 +      this.driftDistance = 0 // Track total drift
      } else if (this.type === 'leaf') {
 -      this.bobAmount = 2; // Leaves bob slightly
 -      let numPoints = 8;
 +      this.bobAmount = 2 // Leaves bob slightly
 +      let numPoints = 8
        for (let i = 0; i < numPoints; i++) {
 -        let angle = (TWO_PI / numPoints) * i;
 -        let r = radius * random(0.7, 1.2);
 -        if (i === 0 || i === numPoints / 2) r = radius * 1.3;
 -        this.leafPoints.push({ angle: angle, radius: r });
 +        let angle = (TWO_PI / numPoints) * i
 +        let r = radius * random(0.7, 1.2)
 +        if (i === 0 || i === numPoints / 2) r = radius * 1.3
 +        this.leafPoints.push({ angle: angle, radius: r })
+       }
      } else if (this.type === 'branch') {
        // Keep for backwards compatibility
 -      this.bobAmount = 0;
 +      this.bobAmount = 0
+     }
+   }
+-
 -  update() {
++
 +  update () {
      // Bobbing motion for all types
 -    let bob = sin(frameCount * this.bobSpeed + this.bobOffset) * this.bobAmount;
 -    this.y = this.originalY + bob;
+-
 +    let bob = sin(frameCount * this.bobSpeed + this.bobOffset) * this.bobAmount
 +    this.y = this.originalY + bob
++
      // Beetle-specific drift
      if (this.type === 'beetle') {
        // Store initial position if not set
        if (!this.initialX) {
 -        this.initialX = this.x;
 -        this.initialY = this.y;
 +        this.initialX = this.x
 +        this.initialY = this.y
+       }
+-
++
        // Slowly change drift direction using Perlin noise
 -      this.driftAngle += (noise(frameCount * this.driftChangeRate, this.originalX * 0.01) - 0.5) * 0.1;
+-
 +      this.driftAngle +=
 +        (noise(frameCount * this.driftChangeRate, this.originalX * 0.01) -
 +          0.5) *
 +        0.1
++
        // Apply drift to original position
 -      this.originalX += cos(this.driftAngle) * this.driftSpeed;
 -      this.originalY += sin(this.driftAngle) * this.driftSpeed * 0.5;
+-
 +      this.originalX += cos(this.driftAngle) * this.driftSpeed
 +      this.originalY += sin(this.driftAngle) * this.driftSpeed * 0.5
++
        // Calculate total drift distance from initial position
 -      this.driftDistance = dist(this.originalX, this.originalY, this.initialX, this.initialY);
+-
 +      this.driftDistance = dist(
 +        this.originalX,
 +        this.originalY,
 +        this.initialX,
 +        this.initialY
 +      )
++
        // Keep beetles on screen with soft boundaries
        if (this.originalX < 80) {
 -        this.driftAngle = random(-PI/4, PI/4);
 -        this.originalX = 80;
 +        this.driftAngle = random(-PI / 4, PI / 4)
 +        this.originalX = 80
+       }
        if (this.originalX > width - 80) {
 -        this.driftAngle = random(3*PI/4, 5*PI/4);
 -        this.originalX = width - 80;
 +        this.driftAngle = random((3 * PI) / 4, (5 * PI) / 4)
 +        this.originalX = width - 80
+       }
        if (this.originalY < 80) {
 -        this.driftAngle = random(-3*PI/4, -PI/4);
 -        this.originalY = 80;
 +        this.driftAngle = random((-3 * PI) / 4, -PI / 4)
 +        this.originalY = 80
+       }
        if (this.originalY > height - 150) {
 -        this.driftAngle = random(PI/4, 3*PI/4);
 -        this.originalY = height - 150;
 +        this.driftAngle = random(PI / 4, (3 * PI) / 4)
 +        this.originalY = height - 150
+       }
+-
++
        // Update actual position (with bob already applied to y)
 -      this.x = this.originalX;
+-
 +      this.x = this.originalX
++
        // Check if beetle has drifted too far and break attached strands
        if (this.driftDistance > 100) {
 -        this.breakAttachedStrands();
 +        this.breakAttachedStrands()
+       }
+     }
+-
++
      // Update animation phases
      if (this.type === 'balloon') {
 -      this.stringWave = sin(frameCount * 0.05 + this.bobOffset) * 0.1;
 -      this.antLegPhase += 0.1;
 +      this.stringWave = sin(frameCount * 0.05 + this.bobOffset) * 0.1
 +      this.antLegPhase += 0.1
      } else if (this.type === 'beetle') {
 -      this.wingPhase += 0.15;
 +      this.wingPhase += 0.15
+     }
+-
++
      // For all moving obstacles, update any attached web strands
      if (this.bobAmount > 0 || this.type === 'beetle') {
 -      this.updateAttachedStrands();
 +      this.updateAttachedStrands()
+     }
+   }
+-
 -  updateAttachedStrands() {
++
 +  updateAttachedStrands () {
      // Update web strands that are connected to this obstacle
      for (let strand of webStrands) {
        // Check if strand starts at this obstacle
 -      if (dist(strand.start.x, strand.start.y, this.x, this.y) < this.radius + 10) {
 -        strand.start.x = this.x;
 -        strand.start.y = this.y;
 +      if (
 +        dist(strand.start.x, strand.start.y, this.x, this.y) <
 +        this.radius + 10
 +      ) {
 +        strand.start.x = this.x
 +        strand.start.y = this.y
          if (strand.path && strand.path.length > 0) {
 -          strand.path[0].x = this.x;
 -          strand.path[0].y = this.y;
 +          strand.path[0].x = this.x
 +          strand.path[0].y = this.y
+         }
+       }
+-
++
        // Check if strand ends at this obstacle
 -      if (strand.end && dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10) {
 -        strand.end.x = this.x;
 -        strand.end.y = this.y;
 +      if (
 +        strand.end &&
 +        dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10
 +      ) {
 +        strand.end.x = this.x
 +        strand.end.y = this.y
          if (strand.path && strand.path.length > 0) {
 -          strand.path[strand.path.length - 1].x = this.x;
 -          strand.path[strand.path.length - 1].y = this.y;
 +          strand.path[strand.path.length - 1].x = this.x
 +          strand.path[strand.path.length - 1].y = this.y
+         }
+       }
+     }
+   }
+-
 -  breakAttachedStrands() {
++
 +  breakAttachedStrands () {
      // Break any strands attached to this beetle that has drifted too far
      for (let strand of webStrands) {
 -      let attachedToStart = dist(strand.start.x, strand.start.y, this.x, this.y) < this.radius + 10;
 -      let attachedToEnd = strand.end && dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10;
+-
 +      let attachedToStart =
 +        dist(strand.start.x, strand.start.y, this.x, this.y) < this.radius + 10
 +      let attachedToEnd =
 +        strand.end &&
 +        dist(strand.end.x, strand.end.y, this.x, this.y) < this.radius + 10
++
        if (attachedToStart || attachedToEnd) {
          // Mark strand as broken
 -        strand.broken = true;
+-
 +        strand.broken = true
++
          // Release any flies stuck to this strand
          for (let fly of flies) {
            if (fly.stuck || fly.caught) {
              // Check if fly is touching this breaking strand
 -            let touchingStrand = false;
 +            let touchingStrand = false
              if (strand.path && strand.path.length > 1) {
                for (let k = 0; k < strand.path.length - 1; k++) {
 -                let p1 = strand.path[k];
 -                let p2 = strand.path[k + 1];
 -                let d = fly.pointToLineDistance(fly.pos, p1, p2);
 +                let p1 = strand.path[k]
 +                let p2 = strand.path[k + 1]
 +                let d = fly.pointToLineDistance(fly.pos, p1, p2)
                  if (d < fly.radius + 5) {
 -                  touchingStrand = true;
 -                  break;
 +                  touchingStrand = true
 +                  break
+                 }
+               }
+             }
+-
++
              // If fly was on this strand, release it
              if (touchingStrand) {
 -              fly.stuck = false;
 -              fly.caught = false;
 -              fly.currentSpeed = fly.baseSpeed;
 -              fly.touchedStrands.clear();
 -              fly.slowedBy.clear();
 +              fly.stuck = false
 +              fly.caught = false
 +              fly.currentSpeed = fly.baseSpeed
 +              fly.touchedStrands.clear()
 +              fly.slowedBy.clear()
                // Give it a little downward velocity to start falling
 -              fly.vel = createVector(random(-0.5, 0.5), 2);
+-
 +              fly.vel = createVector(random(-0.5, 0.5), 2)
++
                // Create release particles
                for (let j = 0; j < 3; j++) {
 -                let p = new Particle(fly.pos.x, fly.pos.y);
 -                p.color = color(255, 255, 100, 150);
 -                p.vel = createVector(random(-1, 1), random(0, 2));
 -                p.size = 2;
 -                particles.push(p);
 +                let p = new Particle(fly.pos.x, fly.pos.y)
 +                p.color = color(255, 255, 100, 150)
 +                p.vel = createVector(random(-1, 1), random(0, 2))
 +                p.size = 2
 +                particles.push(p)
+               }
+             }
+           }
+         }
+-
++
          // Create dramatic snap particles
 -        let snapX = attachedToStart ? strand.start.x : strand.end.x;
 -        let snapY = attachedToStart ? strand.start.y : strand.end.y;
+-
 +        let snapX = attachedToStart ? strand.start.x : strand.end.x
 +        let snapY = attachedToStart ? strand.start.y : strand.end.y
++
          // Red/pink particles for the snap
          for (let i = 0; i < 8; i++) {
 -          let p = new Particle(snapX, snapY);
 -          p.color = color(255, random(100, 200), random(100, 150));
 -          p.vel = createVector(random(-5, 5), random(-5, 2));
 -          p.size = random(4, 8);
 -          particles.push(p);
 +          let p = new Particle(snapX, snapY)
 +          p.color = color(255, random(100, 200), random(100, 150))
 +          p.vel = createVector(random(-5, 5), random(-5, 2))
 +          p.size = random(4, 8)
 +          particles.push(p)
+         }
+-
++
          // White strand particles
          for (let i = 0; i < 4; i++) {
 -          let p = new Particle(snapX, snapY);
 -          p.color = color(255, 255, 255);
 -          p.vel = createVector(random(-3, 3), random(-3, 0));
 -          p.size = 3;
 -          particles.push(p);
 +          let p = new Particle(snapX, snapY)
 +          p.color = color(255, 255, 255)
 +          p.vel = createVector(random(-3, 3), random(-3, 0))
 +          p.size = 3
 +          particles.push(p)
+         }
+-
++
          // Reset beetle drift after breaking strands
 -        this.initialX = this.x;
 -        this.initialY = this.y;
 -        this.driftDistance = 0;
 +        this.initialX = this.x
 +        this.initialY = this.y
 +        this.driftDistance = 0
+       }
+     }
+   }
 -  display() {
 -    push();
 -    translate(this.x, this.y);
+-
 +  display () {
 +    push()
 +    translate(this.x, this.y)
++
      if (this.type === 'balloon') {
        // Hot air balloon with canvas texture!
 -      push();
+-
 +      push()
++
        // String/rope first (behind balloon)
 -      stroke(80, 60, 40);
 -      strokeWeight(1.5);
 -      noFill();
 -      beginShape();
 +      stroke(80, 60, 40)
 +      strokeWeight(1.5)
 +      noFill()
 +      beginShape()
        for (let i = 0; i <= 10; i++) {
 -        let t = i / 10;
 -        let stringX = sin(t * PI * 2 + this.stringWave) * 3;
 -        let stringY = t * 40 + this.radius;
 -        curveVertex(stringX, stringY);
 +        let t = i / 10
 +        let stringX = sin(t * PI * 2 + this.stringWave) * 3
 +        let stringY = t * 40 + this.radius
 +        curveVertex(stringX, stringY)
+       }
 -      endShape();
+-
 +      endShape()
++
        // Balloon shadow
 -      noStroke();
 -      fill(0, 0, 0, 30);
 -      ellipse(5, 5, this.radius * 2.2, this.radius * 2.5);
+-
 +      noStroke()
 +      fill(0, 0, 0, 30)
 +      ellipse(5, 5, this.radius * 2.2, this.radius * 2.5)
++
        // Main balloon with canvas panels
 -      push();
 +      push()
        // Draw vertical panels for that classic hot air balloon look
 -      let numPanels = 8;
 +      let numPanels = 8
        for (let i = 0; i < numPanels; i++) {
 -        let angle1 = (TWO_PI / numPanels) * i;
 -        let angle2 = (TWO_PI / numPanels) * (i + 1);
+-
 +        let angle1 = (TWO_PI / numPanels) * i
 +        let angle2 = (TWO_PI / numPanels) * (i + 1)
++
          // Alternate panel colors for striped effect
          if (i % 2 === 0) {
 -          fill(red(this.balloonColor), green(this.balloonColor), blue(this.balloonColor), 200);
 +          fill(
 +            red(this.balloonColor),
 +            green(this.balloonColor),
 +            blue(this.balloonColor),
 +            200
 +          )
          } else {
            fill(
 -            red(this.balloonColor) - 30,
 -            green(this.balloonColor) - 30,
 -            blue(this.balloonColor) - 30,
 +            red(this.balloonColor) - 30,
 +            green(this.balloonColor) - 30,
 +            blue(this.balloonColor) - 30,
 -          );
 +          )
+         }
+-
++
          // Draw tapered panel (wider at middle, narrow at top/bottom)
 -        beginShape();
 +        beginShape()
          // Top point
 -        vertex(0, -this.radius * 1.2);
 +        vertex(0, -this.radius * 1.2)
          // Upper curve
          bezierVertex(
 -          cos(angle1) * this.radius * 0.3, -this.radius * 0.9,
 -          cos(angle1) * this.radius * 0.8, -this.radius * 0.3,
 -          cos(angle1) * this.radius * 1.1, 0
 -        );
 +          cos(angle1) * this.radius * 0.3,
 +          -this.radius * 0.9,
 +          cos(angle1) * this.radius * 0.8,
 +          -this.radius * 0.3,
 +          cos(angle1) * this.radius * 1.1,
 +          0
 +        )
          // Lower curve to bottom
          bezierVertex(
 -          cos(angle1) * this.radius * 0.9, this.radius * 0.5,
 -          cos(angle1) * this.radius * 0.4, this.radius * 0.9,
 -          0, this.radius * 1.1
 -        );
 +          cos(angle1) * this.radius * 0.9,
 +          this.radius * 0.5,
 +          cos(angle1) * this.radius * 0.4,
 +          this.radius * 0.9,
 +          0,
 +          this.radius * 1.1
 +        )
          // Back up the other side
          bezierVertex(
 -          cos(angle2) * this.radius * 0.4, this.radius * 0.9,
 -          cos(angle2) * this.radius * 0.9, this.radius * 0.5,
 -          cos(angle2) * this.radius * 1.1, 0
 -        );
 +          cos(angle2) * this.radius * 0.4,
 +          this.radius * 0.9,
 +          cos(angle2) * this.radius * 0.9,
 +          this.radius * 0.5,
 +          cos(angle2) * this.radius * 1.1,
 +          0
 +        )
          bezierVertex(
 -          cos(angle2) * this.radius * 0.8, -this.radius * 0.3,
 -          cos(angle2) * this.radius * 0.3, -this.radius * 0.9,
 -          0, -this.radius * 1.2
 -        );
 -        endShape(CLOSE);
 +          cos(angle2) * this.radius * 0.8,
 +          -this.radius * 0.3,
 +          cos(angle2) * this.radius * 0.3,
 +          -this.radius * 0.9,
 +          0,
 +          -this.radius * 1.2
 +        )
 +        endShape(CLOSE)
+       }
+-
++
        // Panel seams/ropes
 -      stroke(60, 40, 20, 100);
 -      strokeWeight(0.5);
 +      stroke(60, 40, 20, 100)
 +      strokeWeight(0.5)
        for (let i = 0; i < numPanels; i++) {
 -        let angle = (TWO_PI / numPanels) * i;
 +        let angle = (TWO_PI / numPanels) * i
          // Vertical seam lines
 -        beginShape();
 -        noFill();
 -        vertex(0, -this.radius * 1.2);
 +        beginShape()
 +        noFill()
 +        vertex(0, -this.radius * 1.2)
          bezierVertex(
 -          cos(angle) * this.radius * 0.3, -this.radius * 0.9,
 -          cos(angle) * this.radius * 0.8, -this.radius * 0.3,
 -          cos(angle) * this.radius * 1.1, 0
 -        );
 +          cos(angle) * this.radius * 0.3,
 +          -this.radius * 0.9,
 +          cos(angle) * this.radius * 0.8,
 +          -this.radius * 0.3,
 +          cos(angle) * this.radius * 1.1,
 +          0
 +        )
          bezierVertex(
 -          cos(angle) * this.radius * 0.9, this.radius * 0.5,
 -          cos(angle) * this.radius * 0.4, this.radius * 0.9,
 -          0, this.radius * 1.1
 -        );
 -        endShape();
 +          cos(angle) * this.radius * 0.9,
 +          this.radius * 0.5,
 +          cos(angle) * this.radius * 0.4,
 +          this.radius * 0.9,
 +          0,
 +          this.radius * 1.1
 +        )
 +        endShape()
+       }
+-
++
        // Highlight on balloon
 -      noStroke();
 -      fill(255, 255, 255, 80);
 -      ellipse(-this.radius * 0.3, -this.radius * 0.5, this.radius * 0.6, this.radius * 0.7);
 -      pop();
+-
 +      noStroke()
 +      fill(255, 255, 255, 80)
 +      ellipse(
 +        -this.radius * 0.3,
 +        -this.radius * 0.5,
 +        this.radius * 0.6,
 +        this.radius * 0.7
 +      )
 +      pop()
++
        // FLAME EFFECT!
 -      push();
 -      translate(0, this.radius - 5);
 +      push()
 +      translate(0, this.radius - 5)
        // Flame glow
 -      noStroke();
 -      fill(255, 200, 0, 40 + sin(frameCount * 0.3) * 20);
 -      ellipse(0, 0, 25, 25);
 -      fill(255, 150, 0, 60 + sin(frameCount * 0.4) * 30);
 -      ellipse(0, 0, 15, 18);
 +      noStroke()
 +      fill(255, 200, 0, 40 + sin(frameCount * 0.3) * 20)
 +      ellipse(0, 0, 25, 25)
 +      fill(255, 150, 0, 60 + sin(frameCount * 0.4) * 30)
 +      ellipse(0, 0, 15, 18)
        // Flame itself
 -      fill(255, 200, 0);
 -      push();
 -      let flameHeight = 8 + sin(frameCount * 0.5) * 3;
 -      translate(0, -2);
 -      beginShape();
 -      vertex(-3, 0);
 -      bezierVertex(-3, -flameHeight * 0.7, -1, -flameHeight, 0, -flameHeight * 1.2);
 -      bezierVertex(1, -flameHeight, 3, -flameHeight * 0.7, 3, 0);
 -      endShape(CLOSE);
 -      fill(255, 255, 200);
 -      ellipse(0, -flameHeight * 0.5, 3, 4);
 -      pop();
 -      pop();
+-
 +      fill(255, 200, 0)
 +      push()
 +      let flameHeight = 8 + sin(frameCount * 0.5) * 3
 +      translate(0, -2)
 +      beginShape()
 +      vertex(-3, 0)
 +      bezierVertex(
 +        -3,
 +        -flameHeight * 0.7,
 +        -1,
 +        -flameHeight,
 +        0,
 +        -flameHeight * 1.2
 +      )
 +      bezierVertex(1, -flameHeight, 3, -flameHeight * 0.7, 3, 0)
 +      endShape(CLOSE)
 +      fill(255, 255, 200)
 +      ellipse(0, -flameHeight * 0.5, 3, 4)
 +      pop()
 +      pop()
++
        // Basket
 -      push();
 -      translate(0, this.radius + 10);
 -      fill(101, 67, 33);
 -      stroke(80, 50, 20);
 -      strokeWeight(1);
 +      push()
 +      translate(0, this.radius + 10)
 +      fill(101, 67, 33)
 +      stroke(80, 50, 20)
 +      strokeWeight(1)
        // Woven basket shape
 -      beginShape();
 -      vertex(-8, 0);
 -      vertex(8, 0);
 -      vertex(6, 10);
 -      vertex(-6, 10);
 -      endShape(CLOSE);
 +      beginShape()
 +      vertex(-8, 0)
 +      vertex(8, 0)
 +      vertex(6, 10)
 +      vertex(-6, 10)
 +      endShape(CLOSE)
        // Basket weave pattern
 -      stroke(80, 50, 20, 150);
 +      stroke(80, 50, 20, 150)
        for (let i = -6; i < 6; i += 2) {
 -        line(i, 1, i, 9);
 +        line(i, 1, i, 9)
+       }
        for (let i = 2; i < 9; i += 2) {
 -        line(-6, i, 6, i);
 +        line(-6, i, 6, i)
+       }
        // Basket rim
 -      stroke(60, 40, 20);
 -      strokeWeight(1.5);
 -      line(-8, 0, 8, 0);
 -      pop();
+-
 +      stroke(60, 40, 20)
 +      strokeWeight(1.5)
 +      line(-8, 0, 8, 0)
 +      pop()
++
        // Ant in basket (peeking over edge)
 -      push();
 -      translate(0, this.radius + 12);
 -      fill(20);
 -      noStroke();
 +      push()
 +      translate(0, this.radius + 12)
 +      fill(20)
 +      noStroke()
        // Just ant head and antennae visible
 -      ellipse(0, -2, 6, 4); // Head peeking up
 +      ellipse(0, -2, 6, 4) // Head peeking up
        // Antennae
 -      stroke(20);
 -      strokeWeight(0.5);
 -      line(-1, -3, -3, -6);
 -      line(1, -3, 3, -6);
 +      stroke(20)
 +      strokeWeight(0.5)
 +      line(-1, -3, -3, -6)
 +      line(1, -3, 3, -6)
        // Tiny ant arms gripping basket edge
 -      strokeWeight(1);
 -      line(-3, 0, -4, 2);
 -      line(3, 0, 4, 2);
 -      pop();
+-
 -      pop();
+-
 +      strokeWeight(1)
 +      line(-3, 0, -4, 2)
 +      line(3, 0, 4, 2)
 +      pop()
++
 +      pop()
      } else if (this.type === 'beetle') {
        // Big floating beetle!
 -      push();
 -      rotate(this.rotation);
+-
 +      push()
 +      rotate(this.rotation)
++
        // Shadow
 -      noStroke();
 -      fill(0, 0, 0, 40);
 -      ellipse(3, 3, this.radius * 1.8, this.radius * 2.2);
+-
 +      noStroke()
 +      fill(0, 0, 0, 40)
 +      ellipse(3, 3, this.radius * 1.8, this.radius * 2.2)
++
        // Wings - always visible and flapping since they're floating
 -      push();
 +      push()
        // Wing flap animation
 -      let wingAngle = sin(this.wingPhase) * 0.3;
 -      let wingSpread = 15 + sin(this.wingPhase) * 10;
+-
 +      let wingAngle = sin(this.wingPhase) * 0.3
 +      let wingSpread = 15 + sin(this.wingPhase) * 10
++
        // Left wing
 -      push();
 -      translate(-this.radius * 0.4, 0);
 -      rotate(-wingAngle);
 -      fill(255, 255, 255, 120);
 -      stroke(0, 0, 0, 100);
 -      strokeWeight(0.5);
 -      ellipse(-wingSpread * 0.7, 0, wingSpread * 1.2, 15);
 +      push()
 +      translate(-this.radius * 0.4, 0)
 +      rotate(-wingAngle)
 +      fill(255, 255, 255, 120)
 +      stroke(0, 0, 0, 100)
 +      strokeWeight(0.5)
 +      ellipse(-wingSpread * 0.7, 0, wingSpread * 1.2, 15)
        // Wing details
 -      noStroke();
 -      fill(200, 200, 200, 80);
 -      ellipse(-wingSpread * 0.6, 0, wingSpread * 0.8, 10);
 -      pop();
+-
 +      noStroke()
 +      fill(200, 200, 200, 80)
 +      ellipse(-wingSpread * 0.6, 0, wingSpread * 0.8, 10)
 +      pop()
++
        // Right wing
 -      push();
 -      translate(this.radius * 0.4, 0);
 -      rotate(wingAngle);
 -      fill(255, 255, 255, 120);
 -      stroke(0, 0, 0, 100);
 -      strokeWeight(0.5);
 -      ellipse(wingSpread * 0.7, 0, wingSpread * 1.2, 15);
 +      push()
 +      translate(this.radius * 0.4, 0)
 +      rotate(wingAngle)
 +      fill(255, 255, 255, 120)
 +      stroke(0, 0, 0, 100)
 +      strokeWeight(0.5)
 +      ellipse(wingSpread * 0.7, 0, wingSpread * 1.2, 15)
        // Wing details
 -      noStroke();
 -      fill(200, 200, 200, 80);
 -      ellipse(wingSpread * 0.6, 0, wingSpread * 0.8, 10);
 -      pop();
+-
 +      noStroke()
 +      fill(200, 200, 200, 80)
 +      ellipse(wingSpread * 0.6, 0, wingSpread * 0.8, 10)
 +      pop()
++
        // Extra glow at night
        if (gamePhase === 'NIGHT') {
 -        noStroke();
 -        fill(255, 255, 200, 30 + sin(this.wingPhase * 2) * 20);
 -        ellipse(0, 0, this.radius * 3, this.radius * 2);
 +        noStroke()
 +        fill(255, 255, 200, 30 + sin(this.wingPhase * 2) * 20)
 +        ellipse(0, 0, this.radius * 3, this.radius * 2)
+       }
 -      pop();
+-
 +      pop()
++
        // Main beetle body (on top of wings)
 -      fill(red(this.beetleColor), green(this.beetleColor), blue(this.beetleColor));
 -      stroke(0);
 -      strokeWeight(2);
 -      ellipse(0, 0, this.radius * 1.6, this.radius * 2);
+-
 +      fill(
 +        red(this.beetleColor),
 +        green(this.beetleColor),
 +        blue(this.beetleColor)
 +      )
 +      stroke(0)
 +      strokeWeight(2)
 +      ellipse(0, 0, this.radius * 1.6, this.radius * 2)
++
        // Shell split line
 -      stroke(0);
 -      strokeWeight(1);
 -      line(0, -this.radius, 0, this.radius);
+-
 +      stroke(0)
 +      strokeWeight(1)
 +      line(0, -this.radius, 0, this.radius)
++
        // Head
 -      fill(10);
 -      ellipse(0, -this.radius * 0.8, this.radius * 0.8, this.radius * 0.6);
+-
 +      fill(10)
 +      ellipse(0, -this.radius * 0.8, this.radius * 0.8, this.radius * 0.6)
++
        // Spots/pattern
 -      noStroke();
 -      fill(0, 0, 0, 80);
 -      ellipse(-this.radius * 0.3, 0, this.radius * 0.4);
 -      ellipse(this.radius * 0.3, -this.radius * 0.2, this.radius * 0.3);
 -      ellipse(this.radius * 0.2, this.radius * 0.4, this.radius * 0.35);
 -      ellipse(-this.radius * 0.25, this.radius * 0.3, this.radius * 0.25);
+-
 +      noStroke()
 +      fill(0, 0, 0, 80)
 +      ellipse(-this.radius * 0.3, 0, this.radius * 0.4)
 +      ellipse(this.radius * 0.3, -this.radius * 0.2, this.radius * 0.3)
 +      ellipse(this.radius * 0.2, this.radius * 0.4, this.radius * 0.35)
 +      ellipse(-this.radius * 0.25, this.radius * 0.3, this.radius * 0.25)
++
        // No legs - they're flying!
        // Just small leg stubs tucked under the body
 -      stroke(0);
 -      strokeWeight(1);
 +      stroke(0)
 +      strokeWeight(1)
        // Tiny tucked legs
 -      line(-this.radius * 0.5, -this.radius * 0.2, -this.radius * 0.6, -this.radius * 0.1);
 -      line(this.radius * 0.5, -this.radius * 0.2, this.radius * 0.6, -this.radius * 0.1);
 -      line(-this.radius * 0.5, this.radius * 0.2, -this.radius * 0.6, this.radius * 0.1);
 -      line(this.radius * 0.5, this.radius * 0.2, this.radius * 0.6, this.radius * 0.1);
+-
 +      line(
 +        -this.radius * 0.5,
 +        -this.radius * 0.2,
 +        -this.radius * 0.6,
 +        -this.radius * 0.1
 +      )
 +      line(
 +        this.radius * 0.5,
 +        -this.radius * 0.2,
 +        this.radius * 0.6,
 +        -this.radius * 0.1
 +      )
 +      line(
 +        -this.radius * 0.5,
 +        this.radius * 0.2,
 +        -this.radius * 0.6,
 +        this.radius * 0.1
 +      )
 +      line(
 +        this.radius * 0.5,
 +        this.radius * 0.2,
 +        this.radius * 0.6,
 +        this.radius * 0.1
 +      )
++
        // Antennae
 -      strokeWeight(1);
 -      line(-3, -this.radius * 1.1, -8, -this.radius * 1.4);
 -      line(3, -this.radius * 1.1, 8, -this.radius * 1.4);
+-
 +      strokeWeight(1)
 +      line(-3, -this.radius * 1.1, -8, -this.radius * 1.4)
 +      line(3, -this.radius * 1.1, 8, -this.radius * 1.4)
++
        // Eyes (bigger and more prominent)
 -      fill(255, 0, 0);
 -      noStroke();
 -      ellipse(-5, -this.radius * 0.7, 5);
 -      ellipse(5, -this.radius * 0.7, 5);
 +      fill(255, 0, 0)
 +      noStroke()
 +      ellipse(-5, -this.radius * 0.7, 5)
 +      ellipse(5, -this.radius * 0.7, 5)
        // Eye shine
 -      fill(255, 150, 150);
 -      ellipse(-4, -this.radius * 0.72, 2);
 -      ellipse(6, -this.radius * 0.72, 2);
+-
 -      pop();
+-
 +      fill(255, 150, 150)
 +      ellipse(-4, -this.radius * 0.72, 2)
 +      ellipse(6, -this.radius * 0.72, 2)
++
 +      pop()
      } else if (this.type === 'leaf') {
        // Original leaf code
 -      rotate(this.rotation);
+-
 +      rotate(this.rotation)
++
        if (gamePhase === 'NIGHT') {
 -        fill(20, 40, 20);
 -        stroke(10, 20, 10);
 +        fill(20, 40, 20)
 +        stroke(10, 20, 10)
        } else {
 -        fill(34, 139, 34);
 -        stroke(25, 100, 25);
 +        fill(34, 139, 34)
 +        stroke(25, 100, 25)
+       }
 -      strokeWeight(2);
 +      strokeWeight(2)
 -      beginShape();
 +      beginShape()
        for (let point of this.leafPoints) {
 -        let x = cos(point.angle) * point.radius;
 -        let y = sin(point.angle) * point.radius;
 -        curveVertex(x, y);
 +        let x = cos(point.angle) * point.radius
 +        let y = sin(point.angle) * point.radius
 +        curveVertex(x, y)
+       }
 -      let firstPoint = this.leafPoints[0];
 +      let firstPoint = this.leafPoints[0]
        curveVertex(
          cos(firstPoint.angle) * firstPoint.radius,
          sin(firstPoint.angle) * firstPoint.radius
 -      );
 -      let secondPoint = this.leafPoints[1];
 +      )
 +      let secondPoint = this.leafPoints[1]
        curveVertex(
          cos(secondPoint.angle) * secondPoint.radius,
          sin(secondPoint.angle) * secondPoint.radius
 -      );
 -      endShape();
+-
 -      stroke(25, 100, 25, 100);
 -      strokeWeight(1);
 -      line(0, -this.radius, 0, this.radius);
 -      line(0, 0, -this.radius / 2, -this.radius / 2);
 -      line(0, 0, this.radius / 2, -this.radius / 2);
 -      line(0, 0, -this.radius / 2, this.radius / 2);
 -      line(0, 0, this.radius / 2, this.radius / 2);
+-
 +      )
 +      endShape()
++
 +      stroke(25, 100, 25, 100)
 +      strokeWeight(1)
 +      line(0, -this.radius, 0, this.radius)
 +      line(0, 0, -this.radius / 2, -this.radius / 2)
 +      line(0, 0, this.radius / 2, -this.radius / 2)
 +      line(0, 0, -this.radius / 2, this.radius / 2)
 +      line(0, 0, this.radius / 2, this.radius / 2)
      } else if (this.type === 'branch') {
        // Keep old branch code for backwards compatibility
 -      rotate(this.rotation);
+-
 +      rotate(this.rotation)
++
        if (gamePhase === 'NIGHT') {
 -        stroke(40, 20, 0);
 -        fill(50, 25, 5);
 +        stroke(40, 20, 0)
 +        fill(50, 25, 5)
        } else {
 -        stroke(101, 67, 33);
 -        fill(139, 90, 43);
 +        stroke(101, 67, 33)
 +        fill(139, 90, 43)
+       }
 -      strokeWeight(3);
 +      strokeWeight(3)
 -      push();
 -      strokeWeight(this.radius / 3);
 -      line(-this.radius, 0, this.radius, 0);
 +      push()
 +      strokeWeight(this.radius / 3)
 +      line(-this.radius, 0, this.radius, 0)
 -      strokeWeight(2);
 -      line(-this.radius / 2, 0, -this.radius / 2 - 10, -10);
 -      line(this.radius / 3, 0, this.radius / 3 + 8, -8);
 -      line(0, 0, 5, -15);
 +      strokeWeight(2)
 +      line(-this.radius / 2, 0, -this.radius / 2 - 10, -10)
 +      line(this.radius / 3, 0, this.radius / 3 + 8, -8)
 +      line(0, 0, 5, -15)
 -      stroke(80, 50, 20, 100);
 -      strokeWeight(1);
 +      stroke(80, 50, 20, 100)
 +      strokeWeight(1)
        for (let i = -this.radius; i < this.radius; i += 5) {
 -        line(i, -2, i + 2, 2);
 +        line(i, -2, i + 2, 2)
+       }
 -      pop();
 +      pop()
 -      noStroke();
 -      fill(255, 255, 255, 30);
 -      ellipse(0, 0, this.radius * 2);
 +      noStroke()
 +      fill(255, 255, 255, 30)
 +      ellipse(0, 0, this.radius * 2)
+     }
 -    pop();
 +    pop()
+   }
+ }
  class FoodBox {
 -  constructor(x, y) {
 -    this.pos = createVector(x, y);
 -    this.radius = 10;
 -    this.collected = false;
 -    this.floatOffset = random(TWO_PI);
 -    this.silkValue = random(20, 35);
 -    this.glowPhase = random(TWO_PI);
 +  constructor (x, y) {
 +    this.pos = createVector(x, y)
 +    this.radius = 10
 +    this.collected = false
 +    this.floatOffset = random(TWO_PI)
 +    this.silkValue = random(20, 35)
 +    this.glowPhase = random(TWO_PI)
+   }
 -  collect() {
 -    webSilk = min(webSilk + this.silkValue, maxWebSilk);
 +  collect () {
 +    webSilk = min(webSilk + this.silkValue, maxWebSilk)
      for (let i = 0; i < 8; i++) {
 -      particles.push(new Particle(this.pos.x, this.pos.y));
 +      particles.push(new Particle(this.pos.x, this.pos.y))
+     }
+   }
 -  display() {
 -    push();
 -    let floatY = sin(frameCount * 0.05 + this.floatOffset) * 3;
 -    translate(this.pos.x, this.pos.y + floatY);
+-
 -    let glowIntensity = 100 + sin(frameCount * 0.1 + this.glowPhase) * 50;
 -    noStroke();
 -    fill(255, 200, 100, glowIntensity * 0.3);
 -    ellipse(0, 0, 40);
 -    fill(255, 220, 150, glowIntensity * 0.5);
 -    ellipse(0, 0, 25);
+-
 -    rectMode(CENTER);
+-
 -    fill(0, 0, 0, 50);
 -    rect(2, 2, this.radius * 2, this.radius * 1.8, 3);
+-
 -    fill(139, 69, 19);
 -    stroke(100, 50, 0);
 -    strokeWeight(1);
 -    rect(0, 0, this.radius * 2, this.radius * 1.8, 3);
+-
 -    stroke(100, 50, 0);
 -    strokeWeight(1);
 -    line(-this.radius, 0, this.radius, 0);
 -    line(0, -this.radius * 0.9, 0, this.radius * 0.9);
+-
 -    noStroke();
 -    fill(255, 200, 100);
 -    ellipse(-5, -4, 4);
 -    ellipse(5, -4, 3);
 -    ellipse(-4, 5, 3);
 -    ellipse(4, 4, 4);
+-
 -    pop();
 +  display () {
 +    push()
 +    let floatY = sin(frameCount * 0.05 + this.floatOffset) * 3
 +    translate(this.pos.x, this.pos.y + floatY)
++
 +    let glowIntensity = 100 + sin(frameCount * 0.1 + this.glowPhase) * 50
 +    noStroke()
 +    fill(255, 200, 100, glowIntensity * 0.3)
 +    ellipse(0, 0, 40)
 +    fill(255, 220, 150, glowIntensity * 0.5)
 +    ellipse(0, 0, 25)
++
 +    rectMode(CENTER)
++
 +    fill(0, 0, 0, 50)
 +    rect(2, 2, this.radius * 2, this.radius * 1.8, 3)
++
 +    fill(139, 69, 19)
 +    stroke(100, 50, 0)
 +    strokeWeight(1)
 +    rect(0, 0, this.radius * 2, this.radius * 1.8, 3)
++
 +    stroke(100, 50, 0)
 +    strokeWeight(1)
 +    line(-this.radius, 0, this.radius, 0)
 +    line(0, -this.radius * 0.9, 0, this.radius * 0.9)
++
 +    noStroke()
 +    fill(255, 200, 100)
 +    ellipse(-5, -4, 4)
 +    ellipse(5, -4, 3)
 +    ellipse(-4, 5, 3)
 +    ellipse(4, 4, 4)
++
 +    pop()
+   }
+ }
          this.isThief = isThief;
          this.active = false;
          this.attacking = false;
 -        this.attackDelay = 120; // Frames before first attack
 +        this.attackDelay = isThief ? 120 : random(30, 90); // MUCH shorter initial delay
          // Position and movement
          this.x = random(width);
          this.vy = 0;
          this.targetX = 0;
          this.targetY = 0;
 -        this.speed = 3;
 +        this.speed = 5; // Increased from 3
          this.angle = 0;
          this.wingPhase = random(TWO_PI);
              this.circleCenter = createVector(width/2, height/2);
+         }
 -        // Attack properties
 -        this.diveSpeed = 8;
 -        this.retreatSpeed = 4;
 +        // Attack properties - MUCH MORE AGGRESSIVE
 +        this.diveSpeed = 12; // Increased from 8
 +        this.retreatSpeed = 6; // Increased from 4
          this.state = 'waiting'; // 'waiting', 'approaching', 'attacking', 'retreating'
 +        this.consecutiveAttacks = 0; // Track multiple attacks
 +        this.maxConsecutiveAttacks = random(2, 4); // Each bird does 2-4 attacks before retreating
+     }
      update() {
          // Update wing animation
 -        this.wingPhase += 0.2;
 +        this.wingPhase += 0.3; // Faster wing flapping
 -        // Countdown to attack
 +        // Countdown to attack - MUCH FASTER
          if (this.attackDelay > 0) {
              this.attackDelay--;
 -            // Hover while waiting
 -            this.y = -30 + sin(frameCount * 0.05) * 10;
 -            this.x += sin(frameCount * 0.03) * 2;
 +            // Hover while waiting - more aggressive hovering
 +            this.y = -30 + sin(frameCount * 0.08) * 15;
 +            this.x += sin(frameCount * 0.05) * 3;
++
 +            // Show warning when about to attack
 +            if (this.attackDelay < 30) {
 +                this.y = lerp(this.y, 50, 0.1); // Start moving into view
 +            }
              return;
+         }
          if (!this.active) {
              this.active = true;
              this.state = 'approaching';
 -            // Set initial target
 -            if (this.isThief) {
 -                // Target caught flies
 -                let caughtFlies = flies.filter(f => f.stuck || f.caught);
 -                if (caughtFlies.length > 0) {
 -                    let target = random(caughtFlies);
 -                    this.targetX = target.pos.x;
 -                    this.targetY = target.pos.y;
 -                } else {
 -                    this.active = false; // No targets, deactivate
 -                    return;
 -                }
 -            } else {
 -                // Target spider or web strands
 -                if (random() < 0.7) {
 -                    // Target spider
 -                    this.targetX = spider.pos.x;
 -                    this.targetY = spider.pos.y;
 -                } else {
 -                    // Target a web strand
 -                    if (webStrands.length > 0) {
 -                        let strand = random(webStrands.filter(s => !s.broken));
 -                        if (strand && strand.path && strand.path.length > 0) {
 -                            let point = random(strand.path);
 -                            this.targetX = point.x;
 -                            this.targetY = point.y;
 -                        }
 -                    }
 -                }
 -            }
 +            this.updateTarget(); // Set initial target
+         }
          // Execute movement pattern
+         }
+     }
 +    updateTarget() {
 +        if (this.isThief) {
 +            // Target caught flies
 +            let caughtFlies = flies.filter(f => f.stuck || f.caught);
 +            if (caughtFlies.length > 0) {
 +                let target = random(caughtFlies);
 +                this.targetX = target.pos.x;
 +                this.targetY = target.pos.y;
 +            } else {
 +                this.active = false; // No targets, deactivate
 +                return;
 +            }
 +        } else {
 +            // Heavily favor targeting spider (90% chance)
 +            if (random() < 0.9) {
 +                // Target spider with prediction
 +                this.targetX = spider.pos.x + spider.vel.x * 10; // Predict where spider will be
 +                this.targetY = spider.pos.y + spider.vel.y * 10;
 +            } else {
 +                // Occasionally target a web strand
 +                if (webStrands.length > 0) {
 +                    let strand = random(webStrands.filter(s => !s.broken));
 +                    if (strand && strand.path && strand.path.length > 0) {
 +                        let point = random(strand.path);
 +                        this.targetX = point.x;
 +                        this.targetY = point.y;
 +                    }
 +                }
 +            }
 +        }
 +    }
++
      executeDivePattern() {
          if (this.state === 'approaching') {
 -            // Move into position above target
 +            // Move into position above target MUCH FASTER
              let dx = this.targetX - this.x;
 -            let dy = 100 - this.y; // Position above screen
 +            let dy = 50 - this.y; // Lower starting position for faster attack
 -            this.x += dx * 0.05;
 -            this.y += dy * 0.05;
 +            this.x += dx * 0.15; // Much faster positioning
 +            this.y += dy * 0.15;
 -            // When in position, start diving
 -            if (abs(dx) < 30 && abs(dy) < 20) {
 +            // When in position, start diving immediately
 +            if (abs(dx) < 50 && abs(dy) < 30) {
                  this.state = 'attacking';
                  this.attacking = true;
 +                this.updateTarget(); // Update target position for more accurate dive
+             }
          } else if (this.state === 'attacking') {
 -            // Dive straight down
 +            // FAST dive toward target
 +            let dx = this.targetX - this.x;
              this.vy = this.diveSpeed;
 +            this.vx = dx * 0.05; // Track horizontally too
 +            this.x += this.vx;
              this.y += this.vy;
 -            // Hit ground or target
 -            if (this.y > height - 50) {
 -                this.state = 'retreating';
 -                this.attacking = false;
 +            // Hit ground or passed target
 +            if (this.y > this.targetY + 20 || this.y > height - 50) {
 +                this.consecutiveAttacks++;
++
 +                // Do multiple attacks before retreating
 +                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
 +                    // Quick pull up and attack again
 +                    this.state = 'approaching';
 +                    this.attacking = false;
 +                    this.y = min(this.y, height - 100); // Don't go too low
 +                    this.updateTarget(); // Get new target position
 +                } else {
 +                    // Finally retreat after multiple attacks
 +                    this.state = 'retreating';
 +                    this.attacking = false;
 +                }
+             }
          } else if (this.state === 'retreating') {
 -            // Fly back up
 +            // Fly back up faster
              this.vy = -this.retreatSpeed;
              this.y += this.vy;
 +            this.x += sin(frameCount * 0.1) * 2; // Weave while retreating
              // Reset when off screen
              if (this.y < -50) {
                  this.state = 'approaching';
 -                this.attackDelay = random(180, 300);
 +                this.attackDelay = random(60, 120); // Shorter delay between attack runs
                  this.x = random(width);
 +                this.consecutiveAttacks = 0; // Reset attack counter
 +                this.maxConsecutiveAttacks = random(2, 4); // Randomize next attack count
+             }
+         }
+     }
      executeSwoopPattern() {
          if (this.state === 'approaching') {
 -            // Come from the side
 +            // Come from the side FAST
              if (this.x < 0) {
 -                this.x += 5;
 -                this.y = height * 0.3 + sin(this.x * 0.02) * 50;
 +                this.x += 8; // Faster approach
 +                this.y = height * 0.3 + sin(this.x * 0.03) * 50;
              } else {
                  this.state = 'attacking';
                  this.attacking = true;
 +                this.updateTarget();
+             }
          } else if (this.state === 'attacking') {
 -            // Swoop across screen following sine wave
 -            this.x += 6;
 -            this.y = height * 0.3 + sin(this.x * 0.02) * 100;
 +            // Swoop across screen following sine wave but faster
 +            this.x += 9; // Faster swoop
 +            this.y = height * 0.3 + sin(this.x * 0.03) * 120;
 -            // Check if passed target
 -            if (abs(this.x - this.targetX) < 50) {
 -                // Attempt to grab/hit
 -                let swoopY = height * 0.3 + sin(this.targetX * 0.02) * 100;
 -                this.y = lerp(this.y, swoopY, 0.3);
 +            // Track toward target when close
 +            if (abs(this.x - this.targetX) < 100) {
 +                // Aggressively dive toward target
 +                let dy = this.targetY - this.y;
 +                this.y += dy * 0.2;
+             }
              // Exit screen
              if (this.x > width + 50) {
 -                this.state = 'retreating';
 -                this.attacking = false;
 +                this.consecutiveAttacks++;
++
 +                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
 +                    // Come back from other side
 +                    this.x = -50;
 +                    this.state = 'approaching';
 +                    this.updateTarget();
 +                } else {
 +                    this.state = 'retreating';
 +                    this.attacking = false;
 +                }
+             }
          } else if (this.state === 'retreating') {
              // Reset
              this.state = 'approaching';
 -            this.attackDelay = random(240, 360);
 +            this.attackDelay = random(90, 150);
              this.x = -50;
 +            this.consecutiveAttacks = 0;
 +            this.maxConsecutiveAttacks = random(2, 4);
+         }
+     }
      executeGlidePattern() {
          if (this.state === 'approaching') {
 -            // Glide in from top corner
 -            this.x += 3;
 -            this.y += 1.5;
 +            // Glide in from top corner faster
 +            this.x += 5;
 +            this.y += 2.5;
 -            if (this.y > height * 0.2) {
 +            if (this.y > height * 0.15) {
                  this.state = 'attacking';
                  this.attacking = true;
 +                this.updateTarget();
+             }
          } else if (this.state === 'attacking') {
 -            // Glide toward target
 +            // Glide toward target aggressively
              let dx = this.targetX - this.x;
              let dy = this.targetY - this.y;
              let dist = sqrt(dx * dx + dy * dy);
              if (dist > 10) {
 -                this.x += (dx / dist) * 4;
 -                this.y += (dy / dist) * 4;
 +                this.x += (dx / dist) * 7; // Much faster glide
 +                this.y += (dy / dist) * 7;
+             }
 -            // Pass through and continue
 +            // Pass through and maybe attack again
              if (this.y > height - 100 || this.x < -50 || this.x > width + 50) {
 -                this.state = 'retreating';
 -                this.attacking = false;
 +                this.consecutiveAttacks++;
++
 +                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
 +                    // Reset for another pass
 +                    this.state = 'approaching';
 +                    this.x = random() < 0.5 ? -50 : width + 50;
 +                    this.y = random(50, 150);
 +                    this.updateTarget();
 +                } else {
 +                    this.state = 'retreating';
 +                    this.attacking = false;
 +                }
+             }
          } else if (this.state === 'retreating') {
              // Continue off screen
              // Reset
              if (this.y > height + 50 || this.x < -100 || this.x > width + 100) {
                  this.state = 'approaching';
 -                this.attackDelay = random(300, 420);
 +                this.attackDelay = random(120, 180);
                  this.x = random() < 0.5 ? -50 : width + 50;
                  this.y = random(50, 150);
 -                this.vx = this.x < width/2 ? 3 : -3;
 -                this.vy = 1.5;
 +                this.vx = this.x < width/2 ? 5 : -5;
 +                this.vy = 2.5;
 +                this.consecutiveAttacks = 0;
 +                this.maxConsecutiveAttacks = random(2, 4);
+             }
+         }
+     }
              let dx = startX - this.x;
              let dy = startY - this.y;
 -            this.x += dx * 0.05;
 -            this.y += dy * 0.05;
 +            this.x += dx * 0.1;
 +            this.y += dy * 0.1;
              if (abs(dx) < 20 && abs(dy) < 20) {
                  this.state = 'attacking';
                  this.circleAngle = 0;
+             }
          } else if (this.state === 'attacking') {
 -            // Circle around center
 -            this.circleAngle += 0.05;
 +            // Circle around center FASTER
 +            this.circleAngle += 0.08; // Faster circling
              this.x = this.circleCenter.x + cos(this.circleAngle) * this.circleRadius;
              this.y = this.circleCenter.y + sin(this.circleAngle) * this.circleRadius;
 -            // Occasionally dive toward center
 -            if (frameCount % 120 === 0) {
 -                this.circleRadius = max(50, this.circleRadius - 30);
 +            // More frequent dives toward center
 +            if (frameCount % 60 === 0) { // Every second instead of every 2 seconds
 +                this.circleRadius = max(30, this.circleRadius - 50);
              } else {
 -                this.circleRadius = min(150, this.circleRadius + 1);
 +                this.circleRadius = min(150, this.circleRadius + 2);
+             }
 -            // Complete circle
 -            if (this.circleAngle > TWO_PI * 2) {
 +            // Complete circle faster
 +            if (this.circleAngle > TWO_PI * 1.5) { // 1.5 circles instead of 2
                  this.state = 'retreating';
                  this.attacking = false;
+             }
          } else if (this.state === 'retreating') {
              // Fly away
 -            this.y -= 5;
 +            this.y -= 7;
              if (this.y < -50) {
                  this.state = 'approaching';
 -                this.attackDelay = random(300, 480);
 +                this.attackDelay = random(150, 240);
                  this.x = random(width);
+             }
+         }
+     }
+-
++
      checkCollisions() {
          // Check collision with spider
          if (this.attacking && dist(this.x, this.y, spider.pos.x, spider.pos.y) < this.size + spider.radius) {
              // Hit spider!
              if (gamePhase === 'DAWN') {
 -                // During dawn, hitting spider costs stamina
 -                jumpStamina = max(0, jumpStamina - 15);
 +                // Calculate damage based on remaining stamina
 +                let damage = 20; // Base damage
++
 +                // If spider has no stamina, GAME OVER!
 +                if (jumpStamina <= 0) {
 +                    triggerGameOver('Exhausted spider caught by bird!');
 +                    return;
 +                }
++
 +                // Otherwise, reduce stamina
 +                jumpStamina = max(0, jumpStamina - damage);
                  stats.birdHitsTaken++;
 -                // Knockback
 +                // Knockback effect
                  spider.vel.x = (spider.pos.x - this.x) * 0.3;
                  spider.vel.y = -3;
 +                spider.isAirborne = true;
 -                // Particles
 -                for (let i = 0; i < 8; i++) {
 +                // Red damage particles
 +                for (let i = 0; i < 12; i++) {
                      let p = new Particle(spider.pos.x, spider.pos.y);
 -                    p.color = color(255, 100, 100);
 -                    p.vel = createVector(random(-3, 3), random(-3, 1));
 +                    p.color = color(255, 50, 50);
 +                    p.vel = createVector(random(-4, 4), random(-4, 1));
 +                    p.size = random(4, 8);
                      particles.push(p);
+                 }
++
 +                // Screen shake effect
 +                screenShake = 10;
++
 +                // Warning notification if stamina is low
 +                if (jumpStamina <= 20) {
 +                    notifications.push(new Notification("CRITICAL STAMINA!", color(255, 50, 50)));
 +                } else if (jumpStamina <= 40) {
 +                    notifications.push(new Notification("Low stamina - find cover!", color(255, 150, 50)));
 +                }
+             }
              // Bird bounces off
              this.state = 'retreating';
              this.attacking = false;
+         }
+-
 -        // Check collision with web strands
 -        if (this.attacking) {
 -            for (let strand of webStrands) {
 -                if (!strand.broken && strand.path) {
 -                    for (let point of strand.path) {
 -                        if (dist(this.x, this.y, point.x, point.y) < this.size) {
 -                            // Bird breaks the strand!
 -                            strand.broken = true;
 -                            stats.strandsLostInNight++;
+-
 -                            // Particles
 -                            for (let i = 0; i < 5; i++) {
 -                                let p = new Particle(point.x, point.y);
 -                                p.color = color(255, 255, 255);
 -                                p.vel = createVector(random(-2, 2), random(-2, 2));
 -                                particles.push(p);
 -                            }
 -                            break;
 -                        }
 -                    }
 -                }
 -            }
 -        }
+-
 -        // Thief bird steals flies
 -        if (this.isThief && this.attacking) {
 -            for (let i = flies.length - 1; i >= 0; i--) {
 -                let fly = flies[i];
 -                if ((fly.stuck || fly.caught) && dist(this.x, this.y, fly.pos.x, fly.pos.y) < this.size + 10) {
 -                    // Steal the fly!
 -                    flies.splice(i, 1);
+-
 -                    // Purple particles for theft
 -                    for (let j = 0; j < 6; j++) {
 -                        let p = new Particle(fly.pos.x, fly.pos.y);
 -                        p.color = color(200, 100, 255);
 -                        p.vel = createVector(random(-2, 2), random(-2, 2));
 -                        particles.push(p);
 -                    }
+-
 -                    // Thief escapes after stealing
 -                    this.state = 'retreating';
 -                    this.attacking = false;
 -                    this.active = false; // Deactivate thief after successful theft
 -                    break;
 -                }
++
 +    // Check collision with web strands
 +    if (this.attacking) {
 +      for (let strand of webStrands) {
 +        if (!strand.broken && strand.path) {
 +          for (let point of strand.path) {
 +            if (dist(this.x, this.y, point.x, point.y) < this.size) {
 +              // Bird breaks the strand!
 +              strand.broken = true
 +              stats.strandsLostInNight++
++
 +              // Particles
 +              for (let i = 0; i < 5; i++) {
 +                let p = new Particle(point.x, point.y)
 +                p.color = color(255, 255, 255)
 +                p.vel = createVector(random(-2, 2), random(-2, 2))
 +                particles.push(p)
 +              }
 +              break
+             }
 +          }
+         }
 +      }
+     }
+-
 -    display() {
 -        push();
 -        translate(this.x, this.y);
+-
 -        // Rotate based on movement
 -        if (this.state === 'attacking' && this.pattern === 'dive') {
 -            rotate(PI/2); // Point down when diving
 -        } else if (this.vx !== 0) {
 -            rotate(atan2(this.vy, this.vx));
 -        }
+-
 -        // Shadow
 -        push();
 -        noStroke();
 -        fill(0, 0, 0, 30);
 -        ellipse(5, 5, this.size * 2);
 -        pop();
+-
 -        // Wings
 -        let wingSpread = sin(this.wingPhase) * this.size * 0.8;
+-
 -        // Wing shadows
 -        noStroke();
 -        fill(0, 0, 0, 40);
 -        ellipse(-wingSpread + 2, 2, this.size * 1.5, this.size * 0.5);
 -        ellipse(wingSpread + 2, 2, this.size * 1.5, this.size * 0.5);
+-
 -        // Wings
 -        fill(this.isThief ? color(120, 70, 180) : color(80, 80, 80));
 -        ellipse(-wingSpread, 0, this.size * 1.5, this.size * 0.5);
 -        ellipse(wingSpread, 0, this.size * 1.5, this.size * 0.5);
+-
 -        // Body
 -        fill(this.isThief ? color(100, 50, 150) : color(50, 50, 50));
 -        ellipse(0, 0, this.size * 0.8, this.size);
+-
 -        // Head
 -        fill(this.isThief ? color(80, 40, 120) : color(30, 30, 30));
 -        ellipse(0, -this.size * 0.4, this.size * 0.5);
+-
 -        // Eye
 -        fill(this.isThief ? color(255, 100, 255) : color(255, 100, 100));
 -        noStroke();
 -        ellipse(3, -this.size * 0.4, 4);
+-
 -        // Beak
 -        fill(this.isThief ? color(200, 150, 50) : color(200, 150, 0));
 -        triangle(
 -            this.size * 0.25, -this.size * 0.4,
 -            this.size * 0.45, -this.size * 0.35,
 -            this.size * 0.25, -this.size * 0.3
 -        );
+-
 -        // Tail feathers
 -        fill(this.isThief ? color(120, 70, 180) : color(80, 80, 80));
 -        for (let i = -1; i <= 1; i++) {
 -            push();
 -            translate(-this.size * 0.3, this.size * 0.3);
 -            rotate(i * 0.2);
 -            ellipse(0, 0, this.size * 0.3, this.size * 0.8);
 -            pop();
 -        }
+-
 -        // Warning indicator if attacking
 -        if (this.attacking && frameCount % 20 < 10) {
 -            noFill();
 -            stroke(255, 100, 100, 150);
 -            strokeWeight(2);
 -            ellipse(0, 0, this.size * 2.5);
++
 +    // Thief bird steals flies
 +    if (this.isThief && this.attacking) {
 +      for (let i = flies.length - 1; i >= 0; i--) {
 +        let fly = flies[i]
 +        if (
 +          (fly.stuck || fly.caught) &&
 +          dist(this.x, this.y, fly.pos.x, fly.pos.y) < this.size + 10
 +        ) {
 +          // Steal the fly!
 +          flies.splice(i, 1)
++
 +          // Purple particles for theft
 +          for (let j = 0; j < 6; j++) {
 +            let p = new Particle(fly.pos.x, fly.pos.y)
 +            p.color = color(200, 100, 255)
 +            p.vel = createVector(random(-2, 2), random(-2, 2))
 +            particles.push(p)
 +          }
++
 +          // Thief escapes after stealing
 +          this.state = 'retreating'
 +          this.attacking = false
 +          this.active = false // Deactivate thief after successful theft
 +          break
+         }
+-
 -        pop();
 +      }
 +    }
 +  }
++
 +  display () {
 +    push()
 +    translate(this.x, this.y)
++
 +    // Rotate based on movement
 +    if (this.state === 'attacking' && this.pattern === 'dive') {
 +      rotate(PI / 2) // Point down when diving
 +    } else if (this.vx !== 0) {
 +      rotate(atan2(this.vy, this.vx))
+     }
++
 +    // Shadow
 +    push()
 +    noStroke()
 +    fill(0, 0, 0, 30)
 +    ellipse(5, 5, this.size * 2)
 +    pop()
++
 +    // Wings
 +    let wingSpread = sin(this.wingPhase) * this.size * 0.8
++
 +    // Wing shadows
 +    noStroke()
 +    fill(0, 0, 0, 40)
 +    ellipse(-wingSpread + 2, 2, this.size * 1.5, this.size * 0.5)
 +    ellipse(wingSpread + 2, 2, this.size * 1.5, this.size * 0.5)
++
 +    // Wings
 +    fill(this.isThief ? color(120, 70, 180) : color(80, 80, 80))
 +    ellipse(-wingSpread, 0, this.size * 1.5, this.size * 0.5)
 +    ellipse(wingSpread, 0, this.size * 1.5, this.size * 0.5)
++
 +    // Body
 +    fill(this.isThief ? color(100, 50, 150) : color(50, 50, 50))
 +    ellipse(0, 0, this.size * 0.8, this.size)
++
 +    // Head
 +    fill(this.isThief ? color(80, 40, 120) : color(30, 30, 30))
 +    ellipse(0, -this.size * 0.4, this.size * 0.5)
++
 +    // Eye
 +    fill(this.isThief ? color(255, 100, 255) : color(255, 100, 100))
 +    noStroke()
 +    ellipse(3, -this.size * 0.4, 4)
++
 +    // Beak
 +    fill(this.isThief ? color(200, 150, 50) : color(200, 150, 0))
 +    triangle(
 +      this.size * 0.25,
 +      -this.size * 0.4,
 +      this.size * 0.45,
 +      -this.size * 0.35,
 +      this.size * 0.25,
 +      -this.size * 0.3
 +    )
++
 +    // Tail feathers
 +    fill(this.isThief ? color(120, 70, 180) : color(80, 80, 80))
 +    for (let i = -1; i <= 1; i++) {
 +      push()
 +      translate(-this.size * 0.3, this.size * 0.3)
 +      rotate(i * 0.2)
 +      ellipse(0, 0, this.size * 0.3, this.size * 0.8)
 +      pop()
 +    }
++
 +    // Warning indicator if attacking
 +    if (this.attacking && frameCount % 20 < 10) {
 +      noFill()
 +      stroke(255, 100, 100, 150)
 +      strokeWeight(2)
 +      ellipse(0, 0, this.size * 2.5)
 +    }
++
 +    pop()
 +  }
+ }
  class Particle {
 -  constructor(x, y) {
 -    this.pos = createVector(x, y);
 -    this.vel = createVector(random(-3, 3), random(-5, -2));
 -    this.lifetime = 255;
 -    this.color = color(255, random(200, 255), random(100, 200));
 -    this.size = 6; // Default size
 +  constructor (x, y) {
 +    this.pos = createVector(x, y)
 +    this.vel = createVector(random(-3, 3), random(-5, -2))
 +    this.lifetime = 255
 +    this.color = color(255, random(200, 255), random(100, 200))
 +    this.size = 6 // Default size
+   }
 -  update() {
 -    this.vel.y += 0.2;
 -    this.pos.add(this.vel);
 -    this.lifetime -= 8;
 +  update () {
 +    this.vel.y += 0.2
 +    this.pos.add(this.vel)
 +    this.lifetime -= 8
+   }
 -  display() {
 -    push();
 -    noStroke();
 -    fill(red(this.color), green(this.color), blue(this.color), this.lifetime);
 -    ellipse(this.pos.x, this.pos.y, this.size);
 -    pop();
 +  display () {
 +    push()
 +    noStroke()
 +    fill(red(this.color), green(this.color), blue(this.color), this.lifetime)
 +    ellipse(this.pos.x, this.pos.y, this.size)
 +    pop()
+   }
 -  isDead() {
 -    return this.lifetime <= 0;
 +  isDead () {
 +    return this.lifetime <= 0
+   }
 -}
 +}

js/game.jsmodified

3896 lines changed — click to load

  // game.js - Main game loop and state management
  // Game objects
 -let spider;
 -let obstacles = [];
 -let webStrands = [];
 -let flies = [];
 -let foodBoxes = [];
 -let particles = [];
 -let webNodes = [];
 +let spider
 +let obstacles = []
 +let webStrands = []
 +let flies = []
 +let foodBoxes = []
 +let particles = []
 +let webNodes = []
  // Game state
 -let isDeployingWeb = false;
 -let currentStrand = null;
 -let spacePressed = false;
 -let isMunching = false;
 +let isDeployingWeb = false
 +let currentStrand = null
 +let spacePressed = false
 +let isMunching = false
 +let gameOver = false
 +let gameOverTimer = 0
 +let deathReason = ''
 +let finalScore = 0
  // Resources
 -let webSilk = 100;
 -let maxWebSilk = 100;
 -let silkRechargeRate = 0.05;
 -let silkDrainRate = 2;
 +let webSilk = 100
 +let maxWebSilk = 100
 +let silkRechargeRate = 0.05
 +let silkDrainRate = 2
  // Game phases - PHASE 1 UPDATES
 -let gamePhase = 'DUSK';
 -let phaseTimer = 0;
 +let gamePhase = 'DUSK'
 +let phaseTimer = 0
  // Phase durations (in frames, 60fps) - PHASE 1 NEW
 -let DAWN_DURATION = 1800; // 30 seconds
 -let DAY_DURATION = 2700; // 45 seconds
 -let DUSK_DURATION = 1800; // 30 seconds (was 1500)
 -let NIGHT_DURATION = 3600; // 60 seconds
 -let TRANSITION_DURATION = 180; // 3 seconds
+-
 -let skyColor1, skyColor2, currentSkyColor1, currentSkyColor2;
 -let moonY = 100;
 -let moonOpacity = 0;
 -let sunY = -50; // PHASE 1 NEW
 -let sunOpacity = 0; // PHASE 1 NEW
 +let DAWN_DURATION = 1800 // 30 seconds
 +let DAY_DURATION = 2700 // 45 seconds
 +let DUSK_DURATION = 1800 // 30 seconds (was 1500)
 +let NIGHT_DURATION = 3600 // 60 seconds
 +let TRANSITION_DURATION = 180 // 3 seconds
++
 +let skyColor1, skyColor2, currentSkyColor1, currentSkyColor2
 +let moonY = 100
 +let moonOpacity = 0
 +let sunY = -50 // PHASE 1 NEW
 +let sunOpacity = 0 // PHASE 1 NEW
  // Progression tracking - PHASE 1 NEW
 -let fliesCaught = 0;
 -let fliesMunched = 0;
 -let totalFliesCaught = 0; // Lifetime counter
 -let nightsSurvived = 0;
 -let currentNight = 1;
 -let baseFlySpeed = 3;
 -let fliesEscaped = [];
 +let fliesCaught = 0
 +let fliesMunched = 0
 +let totalFliesCaught = 0 // Lifetime counter
 +let nightsSurvived = 0
 +let currentNight = 1
 +let baseFlySpeed = 3
 +let fliesEscaped = []
  // PHASE 2: Special fly notifications
 -let notifications = [];
 +let notifications = []
  // PHASE 3: Upgrade System
 -let playerPoints = 0;
 -let shopOpen = false;
 +let playerPoints = 0
 +let shopOpen = false
  // PHASE 4: Dawn Exhaustion System
 -let jumpStamina = 100;
 -let maxJumpStamina = 100;
 -let jumpCost = 20;
 -let staminaRegenRate = 0.2;
 -let isExhausted = false;
 -let fliesMunchedLastNight = 0;
 -let birds = [];
 +let jumpStamina = 100
 +let maxJumpStamina = 100
 +let jumpCost = 20
 +let staminaRegenRate = 0.2
 +let isExhausted = false
 +let fliesMunchedLastNight = 0
 +let birds = []
  // PHASE 4B: Wind System
 -let windActive = false;
 -let windDirection = 0;
 -let windStrength = 0;
 -let windTimer = 0;
 -let windDuration = 0;
 -let windParticles = [];
 -let nextWindTime = 0;
 +let windActive = false
 +let windDirection = 0
 +let windStrength = 0
 +let windTimer = 0
 +let windDuration = 0
 +let windParticles = []
 +let nextWindTime = 0
  // PHASE 4B: Thief bird timer
 -let thiefBirdTimer = 0;
 -let nextThiefTime = 0;
 +let thiefBirdTimer = 0
 +let nextThiefTime = 0
  // PHASE 5: Achievements & Stats System
  let achievements = {
 -    nightOwl: { name: "Night Owl", desc: "Survive 10 nights", icon: "🦉", unlocked: false, progress: 0, target: 10 },
 -    silkMaster: { name: "Silk Master", desc: "Have 15+ strands at once", icon: "🕸️", unlocked: false, progress: 0, target: 15 },
 -    feast: { name: "Feast", desc: "Munch 20 flies in one night", icon: "🍽️", unlocked: false, progress: 0, target: 20 },
 -    architect: { name: "Architect", desc: "Catch 5 flies without munching", icon: "🏗️", unlocked: false, progress: 0, target: 5 },
 -    untouchable: { name: "Untouchable", desc: "Survive a night without losing a strand", icon: "💎", unlocked: false },
 -    windRider: { name: "Wind Rider", desc: "Jump 10 times during wind", icon: "🌬️", unlocked: false, progress: 0, target: 10 },
 -    thiefDefender: { name: "Thief Defender", desc: "Scare off 10 thief birds", icon: "🛡️", unlocked: false, progress: 0, target: 10 },
 -    exhaustionMaster: { name: "Exhaustion Master", desc: "Survive dawn with < 20 stamina", icon: "😴", unlocked: false },
 -    queenSlayer: { name: "Queen Slayer", desc: "Catch 10 queen flies", icon: "👑", unlocked: false, progress: 0, target: 10 },
 -    perfectDawn: { name: "Perfect Dawn", desc: "No bird hits during dawn", icon: "☀️", unlocked: false },
 -    speedrunner: { name: "Speedrunner", desc: "Catch 30 flies before Night 5", icon: "⚡", unlocked: false },
 -    galaxyUnlock: { name: "Cosmic Spider", desc: "Survive 15 nights", icon: "🌌", unlocked: false, progress: 0, target: 15 },
 -    goldenHunter: { name: "Golden Hunter", desc: "Catch 100 golden flies", icon: "✨", unlocked: false, progress: 0, target: 100 },
 -    shadowPredator: { name: "Shadow Predator", desc: "Catch 50 flies in one night", icon: "🌑", unlocked: false, progress: 0, target: 50 },
 -    webMaster: { name: "Web Master", desc: "500 total flies caught", icon: "🏆", unlocked: false, progress: 0, target: 500 }
 -};
 +  nightOwl: {
 +    name: 'Night Owl',
 +    desc: 'Survive 10 nights',
 +    icon: '🦉',
 +    unlocked: false,
 +    progress: 0,
 +    target: 10
 +  },
 +  silkMaster: {
 +    name: 'Silk Master',
 +    desc: 'Have 15+ strands at once',
 +    icon: '🕸️',
 +    unlocked: false,
 +    progress: 0,
 +    target: 15
 +  },
 +  feast: {
 +    name: 'Feast',
 +    desc: 'Munch 20 flies in one night',
 +    icon: '🍽️',
 +    unlocked: false,
 +    progress: 0,
 +    target: 20
 +  },
 +  architect: {
 +    name: 'Architect',
 +    desc: 'Catch 5 flies without munching',
 +    icon: '🏗️',
 +    unlocked: false,
 +    progress: 0,
 +    target: 5
 +  },
 +  untouchable: {
 +    name: 'Untouchable',
 +    desc: 'Survive a night without losing a strand',
 +    icon: '💎',
 +    unlocked: false
 +  },
 +  windRider: {
 +    name: 'Wind Rider',
 +    desc: 'Jump 10 times during wind',
 +    icon: '🌬️',
 +    unlocked: false,
 +    progress: 0,
 +    target: 10
 +  },
 +  thiefDefender: {
 +    name: 'Thief Defender',
 +    desc: 'Scare off 10 thief birds',
 +    icon: '🛡️',
 +    unlocked: false,
 +    progress: 0,
 +    target: 10
 +  },
 +  exhaustionMaster: {
 +    name: 'Exhaustion Master',
 +    desc: 'Survive dawn with < 20 stamina',
 +    icon: '😴',
 +    unlocked: false
 +  },
 +  queenSlayer: {
 +    name: 'Queen Slayer',
 +    desc: 'Catch 10 queen flies',
 +    icon: '👑',
 +    unlocked: false,
 +    progress: 0,
 +    target: 10
 +  },
 +  perfectDawn: {
 +    name: 'Perfect Dawn',
 +    desc: 'No bird hits during dawn',
 +    icon: '☀️',
 +    unlocked: false
 +  },
 +  speedrunner: {
 +    name: 'Speedrunner',
 +    desc: 'Catch 30 flies before Night 5',
 +    icon: '⚡',
 +    unlocked: false
 +  },
 +  galaxyUnlock: {
 +    name: 'Cosmic Spider',
 +    desc: 'Survive 15 nights',
 +    icon: '🌌',
 +    unlocked: false,
 +    progress: 0,
 +    target: 15
 +  },
 +  goldenHunter: {
 +    name: 'Golden Hunter',
 +    desc: 'Catch 100 golden flies',
 +    icon: '✨',
 +    unlocked: false,
 +    progress: 0,
 +    target: 100
 +  },
 +  shadowPredator: {
 +    name: 'Shadow Predator',
 +    desc: 'Catch 50 flies in one night',
 +    icon: '🌑',
 +    unlocked: false,
 +    progress: 0,
 +    target: 50
 +  },
 +  webMaster: {
 +    name: 'Web Master',
 +    desc: '500 total flies caught',
 +    icon: '🏆',
 +    unlocked: false,
 +    progress: 0,
 +    target: 500
 +  }
 +}
  // Statistics tracking
  let stats = {
 -    totalFliesCaught: 0,
 -    regularCaught: 0,
 -    goldenCaught: 0,
 -    mothsCaught: 0,
 -    queensCaught: 0,
 -    longestNight: 0,
 -    totalSilkSpun: 0,
 -    totalJumps: 0,
 -    windJumps: 0,
 -    thievesScared: 0,
 -    birdHitsTaken: 0,
 -    strandsCreated: 0,
 -    perfectDawns: 0,
 -    fliesMunchedInCurrentNight: 0,
 -    fliesCaughtWithoutMunch: 0,
 -    strandsLostInNight: 0
 -};
 +  totalFliesCaught: 0,
 +  regularCaught: 0,
 +  goldenCaught: 0,
 +  mothsCaught: 0,
 +  queensCaught: 0,
 +  longestNight: 0,
 +  totalSilkSpun: 0,
 +  totalJumps: 0,
 +  windJumps: 0,
 +  thievesScared: 0,
 +  birdHitsTaken: 0,
 +  strandsCreated: 0,
 +  perfectDawns: 0,
 +  fliesMunchedInCurrentNight: 0,
 +  fliesCaughtWithoutMunch: 0,
 +  strandsLostInNight: 0
 +}
  // Cosmetics
  let unlockedSkins = {
 -    default: true,
 -    galaxy: false,
 -    golden: false,
 -    shadow: false,
 -    rainbow: false
 -};
+-
 -let currentSkin = 'default';
 -let achievementQueue = [];
 -let showingAchievement = null;
 -let achievementDisplayTimer = 0;
 +  default: true,
 +  galaxy: false,
 +  golden: false,
 +  shadow: false,
 +  rainbow: false
 +}
++
 +let currentSkin = 'default'
 +let achievementQueue = []
 +let showingAchievement = null
 +let achievementDisplayTimer = 0
  let upgrades = {
 -    // Tier 1 Upgrades
 -    strongLegs: {
 -        level: 0,
 -        maxLevel: 3,
 -        cost: 15,
 -        name: "Strong Legs",
 -        description: "Jump 15% farther",
 -        icon: "🦵",
 -        tier: 1
 -    },
 -    silkGlands: {
 -        level: 0,
 -        maxLevel: 3,
 -        cost: 20,
 -        name: "Silk Glands",
 -        description: "+20 max silk capacity",
 -        icon: "🕸️",
 -        tier: 1
 -    },
 -    efficientSpinning: {
 -        level: 0,
 -        maxLevel: 3,
 -        cost: 15,
 -        name: "Efficient Spinning",
 -        description: "-20% silk consumption",
 -        icon: "♻️",
 -        tier: 1
 -    },
 -    quickMunch: {
 -        level: 0,
 -        maxLevel: 2,
 -        cost: 10,
 -        name: "Quick Munch",
 -        description: "Munch cooldown -30%",
 -        icon: "🦷",
 -        tier: 1
 -    },
+-
 -    // Tier 2 Upgrades (requires at least 2 Tier 1 upgrades)
 -    powerJump: {
 -        level: 0,
 -        maxLevel: 1,
 -        cost: 50,
 -        name: "Power Jump",
 -        description: "Hold to charge jump (2x distance)",
 -        icon: "⚡",
 -        tier: 2,
 -        requires: 2 // Number of tier 1 upgrades needed
 -    },
 -    silkRecycle: {
 -        level: 0,
 -        maxLevel: 1,
 -        cost: 75,
 -        name: "Silk Recycle",
 -        description: "Press R near old web to recover 50% silk",
 -        icon: "🔄",
 -        tier: 2,
 -        requires: 2
 -    },
 -    spiderSense: {
 -        level: 0,
 -        maxLevel: 1,
 -        cost: 100,
 -        name: "Spider Sense",
 -        description: "See faint prediction lines for fly paths",
 -        icon: "👁️",
 -        tier: 2,
 -        requires: 3
 -    },
 -    metabolize: {
 -        level: 0,
 -        maxLevel: 1,
 -        cost: 60,
 -        name: "Metabolize",
 -        description: "Munching heals nearby broken strands",
 -        icon: "💚",
 -        tier: 2,
 -        requires: 2
 -    }
 -};
 +  // Tier 1 Upgrades
 +  strongLegs: {
 +    level: 0,
 +    maxLevel: 3,
 +    cost: 15,
 +    name: 'Strong Legs',
 +    description: 'Jump 15% farther',
 +    icon: '🦵',
 +    tier: 1
 +  },
 +  silkGlands: {
 +    level: 0,
 +    maxLevel: 3,
 +    cost: 20,
 +    name: 'Silk Glands',
 +    description: '+20 max silk capacity',
 +    icon: '🕸️',
 +    tier: 1
 +  },
 +  efficientSpinning: {
 +    level: 0,
 +    maxLevel: 3,
 +    cost: 15,
 +    name: 'Efficient Spinning',
 +    description: '-20% silk consumption',
 +    icon: '♻️',
 +    tier: 1
 +  },
 +  quickMunch: {
 +    level: 0,
 +    maxLevel: 2,
 +    cost: 10,
 +    name: 'Quick Munch',
 +    description: 'Munch cooldown -30%',
 +    icon: '🦷',
 +    tier: 1
 +  },
++
 +  // Tier 2 Upgrades (requires at least 2 Tier 1 upgrades)
 +  powerJump: {
 +    level: 0,
 +    maxLevel: 1,
 +    cost: 50,
 +    name: 'Power Jump',
 +    description: 'Hold to charge jump (2x distance)',
 +    icon: '⚡',
 +    tier: 2,
 +    requires: 2 // Number of tier 1 upgrades needed
 +  },
 +  silkRecycle: {
 +    level: 0,
 +    maxLevel: 1,
 +    cost: 75,
 +    name: 'Silk Recycle',
 +    description: 'Press R near old web to recover 50% silk',
 +    icon: '🔄',
 +    tier: 2,
 +    requires: 2
 +  },
 +  spiderSense: {
 +    level: 0,
 +    maxLevel: 1,
 +    cost: 100,
 +    name: 'Spider Sense',
 +    description: 'See faint prediction lines for fly paths',
 +    icon: '👁️',
 +    tier: 2,
 +    requires: 3
 +  },
 +  metabolize: {
 +    level: 0,
 +    maxLevel: 1,
 +    cost: 60,
 +    name: 'Metabolize',
 +    description: 'Munching heals nearby broken strands',
 +    icon: '💚',
 +    tier: 2,
 +    requires: 2
 +  }
 +}
  // Track if charging jump (Tier 2 upgrade)
 -let chargingJump = false;
 -let jumpChargeTime = 0;
 -let maxJumpCharge = 60; // 1 second at 60fps
 +let chargingJump = false
 +let jumpChargeTime = 0
 +let maxJumpCharge = 60 // 1 second at 60fps
  class Notification {
 -    constructor(text, color) {
 -        this.text = text;
 -        this.color = color;
 -        this.y = height * 0.3;
 -        this.alpha = 255;
 -        this.lifetime = 180; // 3 seconds
 -    }
+-
 -    update() {
 -        this.lifetime--;
 -        if (this.lifetime < 60) {
 -            this.alpha = map(this.lifetime, 0, 60, 0, 255);
 -        }
 -        this.y -= 0.5; // Slowly rise
 -    }
+-
 -    display() {
 -        push();
 -        textAlign(CENTER);
 -        textSize(24);
 -        strokeWeight(4);
 -        stroke(0, 0, 0, this.alpha);
 -        fill(red(this.color), green(this.color), blue(this.color), this.alpha);
 -        text(this.text, width / 2, this.y);
 -        pop();
 -    }
+-
 -    isDead() {
 -        return this.lifetime <= 0;
 +  constructor (text, color) {
 +    this.text = text
 +    this.color = color
 +    this.y = height * 0.3
 +    this.alpha = 255
 +    this.lifetime = 180 // 3 seconds
 +  }
++
 +  update () {
 +    this.lifetime--
 +    if (this.lifetime < 60) {
 +      this.alpha = map(this.lifetime, 0, 60, 0, 255)
+     }
 +    this.y -= 0.5 // Slowly rise
 +  }
++
 +  display () {
 +    push()
 +    textAlign(CENTER)
 +    textSize(24)
 +    strokeWeight(4)
 +    stroke(0, 0, 0, this.alpha)
 +    fill(red(this.color), green(this.color), blue(this.color), this.alpha)
 +    text(this.text, width / 2, this.y)
 +    pop()
 +  }
++
 +  isDead () {
 +    return this.lifetime <= 0
 +  }
+ }
 -function setup() {
 -    let canvas = createCanvas(window.innerWidth, window.innerHeight);
 -    canvas.parent('game-container');
+-
 -    skyColor1 = color(135, 206, 235);
 -    skyColor2 = color(255, 183, 77);
 -    currentSkyColor1 = skyColor1;
 -    currentSkyColor2 = skyColor2;
+-
 -    // Create home branch for spider
 -    let homeBranchSide = random() < 0.5 ? 'left' : 'right';
 -    let homeBranchLength = random(width * 0.33, width * 0.5);
 -    let homeBranchY = random(height * 0.7, height * 0.85);
 -    let homeBranchThickness = 25;
+-
 -    // Calculate start and end positions ONCE
 -    let branchStartX = homeBranchSide === 'left' ? -20 : width + 20;
 -    let branchEndX = homeBranchSide === 'left' ? homeBranchLength : width - homeBranchLength;
+-
 -    // Generate leaves with FIXED positions (simplified)
 -    let leaves = [];
 -    for (let i = 0; i < 3; i++) {
 -        let t = 0.3 + (0.4 * i / 2);
 -        let x = lerp(branchStartX, branchEndX, t);
 -        leaves.push({
 -            t: t, // Store position as percentage for proper rotation
 -            yOffset: -homeBranchThickness - 10,
 -            rotation: random(-PI/8, PI/8),
 -            width: 16,
 -            height: 8
 -        });
 -    }
+-
 -    // Generate bark textures with FIXED positions
 -    let barkTextures = [];
 -    for (let x = Math.min(branchStartX, branchEndX); x < Math.max(branchStartX, branchEndX); x += 16) {
 -        barkTextures.push({
 -            x: x,
 -            yOff: -5 + (x % 10), // Deterministic offset based on position
 -            endYOff: -2 + (x % 5)
 -        });
 -    }
+-
 -    // Store home branch info for rendering (simplified)
 -    window.homeBranch = {
 -        side: homeBranchSide,
 -        startX: branchStartX,
 -        endX: branchEndX,
 -        y: homeBranchY,
 -        thickness: homeBranchThickness,
 -        angle: homeBranchSide === 'left' ? 0.05 : -0.05,
 -        leaves: leaves,
 -        barkTextures: barkTextures
 -    };
+-
 -    // Place spider at the tip of the branch
 -    let spiderStartX = branchEndX; // Place at the end/tip
+-
 -    // The branch is drawn with a taper - at the tip it's 35% thickness
 -    // The branch rendering uses push/translate/rotate, so we need to account for that
 -    let branchTopThickness = homeBranchThickness * 0.35;
+-
 -    // The branch is drawn centered at branch.y after rotation
 -    // Since the rotation is small, we can approximate
 -    let branchSurfaceY = homeBranchY - branchTopThickness;
+-
 -    // The branch rotates around (0, homeBranchY), so points further from origin rotate more
 -    // For small angles: y_rotated ≈ y + x * sin(angle) ≈ y + x * angle
 -    let rotationOffset = spiderStartX * window.homeBranch.angle;
 -    branchSurfaceY += rotationOffset;
+-
 -    // Place spider on top of the visual branch at the tip (8 is spider radius)
 -    spider = new Spider(spiderStartX, branchSurfaceY - 8);
+-
 -    // PHASE 5: Load saved game (AFTER spider is created)
 -    loadGame();
+-
 -    // Add invisible obstacles along the branch for web anchor points
 -    let numBranchAnchors = 3;
 -    for (let i = 0; i < numBranchAnchors; i++) {
 -        let t = (i + 1) / (numBranchAnchors + 1);
 -        let x = homeBranchSide === 'left' ?
 -            homeBranchLength * t :
 -            width - homeBranchLength * t;
 -        let y = homeBranchY + sin(t * PI) * 10; // Slight curve
 -        obstacles.push(new Obstacle(x, y, 20, 'leaf')); // Use leaf as invisible anchor
 -    }
+-
 -    // Create more obstacles for denser coverage
 -    let numObstacles = Math.floor((width * height) / 60000); // More obstacles
 -    numObstacles = constrain(numObstacles, 15, 25);
+-
 -    // Create ant balloons (4-6)
 -    let numBalloons = Math.floor(random(4, 7));
 -    for (let i = 0; i < numBalloons; i++) {
 -        let attempts = 0;
 -        let placed = false;
+-
 -        while (!placed && attempts < 30) {
 -            let x = random(80, width - 80);
 -            let y = random(60, height * 0.55); // Balloons float in upper half
 -            let radius = random(35, 45); // Good size for hopping
+-
 -            let valid = true;
 -            // Check distance from other obstacles
 -            for (let obstacle of obstacles) {
 -                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 50) {
 -                    valid = false;
 -                    break;
 -                }
 -            }
+-
 -            // Check distance from home branch
 -            if (valid && window.homeBranch) {
 -                let branchY = window.homeBranch.y;
 -                if (Math.abs(y - branchY) < radius + 35) {
 -                    valid = false;
 -                }
 -            }
+-
 -            if (valid) {
 -                obstacles.push(new Obstacle(x, y, radius, 'balloon'));
 -                placed = true;
 -            }
 -            attempts++;
 +function setup () {
 +  let canvas = createCanvas(window.innerWidth, window.innerHeight)
 +  canvas.parent('game-container')
++
 +  skyColor1 = color(135, 206, 235)
 +  skyColor2 = color(255, 183, 77)
 +  currentSkyColor1 = skyColor1
 +  currentSkyColor2 = skyColor2
++
 +  // Create home branch for spider
 +  let homeBranchSide = random() < 0.5 ? 'left' : 'right'
 +  let homeBranchLength = random(width * 0.33, width * 0.5)
 +  let homeBranchY = random(height * 0.7, height * 0.85)
 +  let homeBranchThickness = 25
++
 +  // Calculate start and end positions ONCE
 +  let branchStartX = homeBranchSide === 'left' ? -20 : width + 20
 +  let branchEndX =
 +    homeBranchSide === 'left' ? homeBranchLength : width - homeBranchLength
++
 +  // Generate leaves with FIXED positions (simplified)
 +  let leaves = []
 +  for (let i = 0; i < 3; i++) {
 +    let t = 0.3 + (0.4 * i) / 2
 +    let x = lerp(branchStartX, branchEndX, t)
 +    leaves.push({
 +      t: t, // Store position as percentage for proper rotation
 +      yOffset: -homeBranchThickness - 10,
 +      rotation: random(-PI / 8, PI / 8),
 +      width: 16,
 +      height: 8
 +    })
 +  }
++
 +  // Generate bark textures with FIXED positions
 +  let barkTextures = []
 +  for (
 +    let x = Math.min(branchStartX, branchEndX);
 +    x < Math.max(branchStartX, branchEndX);
 +    x += 16
 +  ) {
 +    barkTextures.push({
 +      x: x,
 +      yOff: -5 + (x % 10), // Deterministic offset based on position
 +      endYOff: -2 + (x % 5)
 +    })
 +  }
++
 +  // Store home branch info for rendering (simplified)
 +  window.homeBranch = {
 +    side: homeBranchSide,
 +    startX: branchStartX,
 +    endX: branchEndX,
 +    y: homeBranchY,
 +    thickness: homeBranchThickness,
 +    angle: homeBranchSide === 'left' ? 0.05 : -0.05,
 +    leaves: leaves,
 +    barkTextures: barkTextures
 +  }
++
 +  // Place spider at the tip of the branch
 +  let spiderStartX = branchEndX // Place at the end/tip
++
 +  // The branch is drawn with a taper - at the tip it's 35% thickness
 +  // The branch rendering uses push/translate/rotate, so we need to account for that
 +  let branchTopThickness = homeBranchThickness * 0.35
++
 +  // The branch is drawn centered at branch.y after rotation
 +  // Since the rotation is small, we can approximate
 +  let branchSurfaceY = homeBranchY - branchTopThickness
++
 +  // The branch rotates around (0, homeBranchY), so points further from origin rotate more
 +  // For small angles: y_rotated ≈ y + x * sin(angle) ≈ y + x * angle
 +  let rotationOffset = spiderStartX * window.homeBranch.angle
 +  branchSurfaceY += rotationOffset
++
 +  // Place spider on top of the visual branch at the tip (8 is spider radius)
 +  spider = new Spider(spiderStartX, branchSurfaceY - 8)
++
 +  loadGame()
++
 +  // PHASE 3: Apply any existing upgrades at start
 +  // applyUpgradeEffects();
++
 +  // Add invisible obstacles along the branch for web anchor points
 +  let numBranchAnchors = 3
 +  for (let i = 0; i < numBranchAnchors; i++) {
 +    let t = (i + 1) / (numBranchAnchors + 1)
 +    let x =
 +      homeBranchSide === 'left'
 +        ? homeBranchLength * t
 +        : width - homeBranchLength * t
 +    let y = homeBranchY + sin(t * PI) * 10 // Slight curve
 +    obstacles.push(new Obstacle(x, y, 20, 'leaf')) // Use leaf as invisible anchor
 +  }
++
 +  // Create more obstacles for denser coverage
 +  let numObstacles = Math.floor((width * height) / 60000) // More obstacles
 +  numObstacles = constrain(numObstacles, 15, 25)
++
 +  // Create ant balloons (4-6)
 +  let numBalloons = Math.floor(random(4, 7))
 +  for (let i = 0; i < numBalloons; i++) {
 +    let attempts = 0
 +    let placed = false
++
 +    while (!placed && attempts < 30) {
 +      let x = random(80, width - 80)
 +      let y = random(60, height * 0.55) // Balloons float in upper half
 +      let radius = random(35, 45) // Good size for hopping
++
 +      let valid = true
 +      // Check distance from other obstacles
 +      for (let obstacle of obstacles) {
 +        if (
 +          dist(x, y, obstacle.x, obstacle.y) <
 +          radius + obstacle.radius + 50
 +        ) {
 +          valid = false
 +          break
+         }
 -    }
+-
 -    // Create beetles (3-5)
 -    let numBeetles = Math.floor(random(3, 6));
 -    for (let i = 0; i < numBeetles; i++) {
 -        let attempts = 0;
 -        let placed = false;
+-
 -        while (!placed && attempts < 30) {
 -            let x = random(70, width - 70);
 -            let y = random(height * 0.2, height * 0.8); // Spread throughout middle/lower
 -            let radius = random(30, 40);
+-
 -            let valid = true;
 -            for (let obstacle of obstacles) {
 -                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 45) {
 -                    valid = false;
 -                    break;
 -                }
 -            }
+-
 -            // Check distance from home branch
 -            if (valid && window.homeBranch) {
 -                let branchY = window.homeBranch.y;
 -                if (Math.abs(y - branchY) < radius + 30) {
 -                    valid = false;
 -                }
 -            }
+-
 -            if (valid) {
 -                obstacles.push(new Obstacle(x, y, radius, 'beetle'));
 -                placed = true;
 -            }
 -            attempts++;
 +      }
++
 +      // Check distance from home branch
 +      if (valid && window.homeBranch) {
 +        let branchY = window.homeBranch.y
 +        if (Math.abs(y - branchY) < radius + 35) {
 +          valid = false
+         }
 +      }
++
 +      if (valid) {
 +        obstacles.push(new Obstacle(x, y, radius, 'balloon'))
 +        placed = true
 +      }
 +      attempts++
+     }
+-
 -    // Create LOTS of leaves (8-12) for excellent hopping coverage
 -    let numLeaves = Math.floor(random(8, 13));
 -    for (let i = 0; i < numLeaves; i++) {
 -        let attempts = 0;
 -        let placed = false;
+-
 -        while (!placed && attempts < 30) {
 -            // Distribute leaves more evenly across the screen
 -            let gridX = (i % 4) * (width / 4) + random(50, width/4 - 50);
 -            let gridY = Math.floor(i / 4) * (height / 3) + random(50, height/3 - 50);
 -            let x = constrain(gridX, 50, width - 50);
 -            let y = constrain(gridY, 60, height - 100);
 -            let radius = random(20, 30);
+-
 -            let valid = true;
 -            for (let obstacle of obstacles) {
 -                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 35) {
 -                    valid = false;
 -                    break;
 -                }
 -            }
+-
 -            if (valid) {
 -                obstacles.push(new Obstacle(x, y, radius, 'leaf'));
 -                placed = true;
 -            }
 -            attempts++;
 +  }
++
 +  // Create beetles (3-5)
 +  let numBeetles = Math.floor(random(3, 6))
 +  for (let i = 0; i < numBeetles; i++) {
 +    let attempts = 0
 +    let placed = false
++
 +    while (!placed && attempts < 30) {
 +      let x = random(70, width - 70)
 +      let y = random(height * 0.2, height * 0.8) // Spread throughout middle/lower
 +      let radius = random(30, 40)
++
 +      let valid = true
 +      for (let obstacle of obstacles) {
 +        if (
 +          dist(x, y, obstacle.x, obstacle.y) <
 +          radius + obstacle.radius + 45
 +        ) {
 +          valid = false
 +          break
+         }
 +      }
++
 +      // Check distance from home branch
 +      if (valid && window.homeBranch) {
 +        let branchY = window.homeBranch.y
 +        if (Math.abs(y - branchY) < radius + 30) {
 +          valid = false
 +        }
 +      }
++
 +      if (valid) {
 +        obstacles.push(new Obstacle(x, y, radius, 'beetle'))
 +        placed = true
 +      }
 +      attempts++
+     }
+-
 -    // Add even more guaranteed coverage points (smaller leaves)
 -    // Corners
 -    obstacles.push(new Obstacle(50, 80, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width - 50, 80, 18, 'leaf'));
 -    obstacles.push(new Obstacle(50, height - 100, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width - 50, height - 100, 18, 'leaf'));
+-
 -    // Edge midpoints
 -    obstacles.push(new Obstacle(35, height/3, 18, 'leaf'));
 -    obstacles.push(new Obstacle(35, 2*height/3, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width - 35, height/3, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width - 35, 2*height/3, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width/3, 45, 18, 'leaf'));
 -    obstacles.push(new Obstacle(2*width/3, 45, 18, 'leaf'));
 -    obstacles.push(new Obstacle(width/3, height - 90, 18, 'leaf'));
 -    obstacles.push(new Obstacle(2*width/3, height - 90, 18, 'leaf'));
+-
 -    // Fill any remaining gaps for smooth hopping
 -    if (width > 600) {
 -        // Create a grid of small leaves to ensure no dead zones
 -        for (let x = width/5; x < width; x += width/5) {
 -            for (let y = height/4; y < height - 100; y += height/4) {
 -                // Check if there's already an obstacle nearby
 -                let needsLeaf = true;
 -                for (let obstacle of obstacles) {
 -                    if (dist(x, y, obstacle.x, obstacle.y) < 80) {
 -                        needsLeaf = false;
 -                        break;
 -                    }
 -                }
 -                if (needsLeaf) {
 -                    obstacles.push(new Obstacle(x + random(-20, 20), y + random(-20, 20), 15, 'leaf'));
 -                }
 -            }
 +  }
++
 +  // Create LOTS of leaves (8-12) for excellent hopping coverage
 +  let numLeaves = Math.floor(random(8, 13))
 +  for (let i = 0; i < numLeaves; i++) {
 +    let attempts = 0
 +    let placed = false
++
 +    while (!placed && attempts < 30) {
 +      // Distribute leaves more evenly across the screen
 +      let gridX = (i % 4) * (width / 4) + random(50, width / 4 - 50)
 +      let gridY = Math.floor(i / 4) * (height / 3) + random(50, height / 3 - 50)
 +      let x = constrain(gridX, 50, width - 50)
 +      let y = constrain(gridY, 60, height - 100)
 +      let radius = random(20, 30)
++
 +      let valid = true
 +      for (let obstacle of obstacles) {
 +        if (
 +          dist(x, y, obstacle.x, obstacle.y) <
 +          radius + obstacle.radius + 35
 +        ) {
 +          valid = false
 +          break
+         }
 +      }
++
 +      if (valid) {
 +        obstacles.push(new Obstacle(x, y, radius, 'leaf'))
 +        placed = true
 +      }
 +      attempts++
+     }
+-
 -    // Spawn initial food boxes
 -    let numBoxes = Math.max(3, Math.floor(width / 400));
 -    for (let i = 0; i < numBoxes; i++) {
 -        spawnFoodBox();
 +  }
++
 +  // Add even more guaranteed coverage points (smaller leaves)
 +  // Corners
 +  obstacles.push(new Obstacle(50, 80, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width - 50, 80, 18, 'leaf'))
 +  obstacles.push(new Obstacle(50, height - 100, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width - 50, height - 100, 18, 'leaf'))
++
 +  // Edge midpoints
 +  obstacles.push(new Obstacle(35, height / 3, 18, 'leaf'))
 +  obstacles.push(new Obstacle(35, (2 * height) / 3, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width - 35, height / 3, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width - 35, (2 * height) / 3, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width / 3, 45, 18, 'leaf'))
 +  obstacles.push(new Obstacle((2 * width) / 3, 45, 18, 'leaf'))
 +  obstacles.push(new Obstacle(width / 3, height - 90, 18, 'leaf'))
 +  obstacles.push(new Obstacle((2 * width) / 3, height - 90, 18, 'leaf'))
++
 +  // Fill any remaining gaps for smooth hopping
 +  if (width > 600) {
 +    // Create a grid of small leaves to ensure no dead zones
 +    for (let x = width / 5; x < width; x += width / 5) {
 +      for (let y = height / 4; y < height - 100; y += height / 4) {
 +        // Check if there's already an obstacle nearby
 +        let needsLeaf = true
 +        for (let obstacle of obstacles) {
 +          if (dist(x, y, obstacle.x, obstacle.y) < 80) {
 +            needsLeaf = false
 +            break
 +          }
 +        }
 +        if (needsLeaf) {
 +          obstacles.push(
 +            new Obstacle(x + random(-20, 20), y + random(-20, 20), 15, 'leaf')
 +          )
 +        }
 +      }
+     }
 +  }
++
 +  // Spawn initial food boxes
 +  let numBoxes = Math.max(3, Math.floor(width / 400))
 +  for (let i = 0; i < numBoxes; i++) {
 +    spawnFoodBox()
 +  }
+ }
 -function draw() {
 -    // Update phase timer
 -    phaseTimer++;
+-
 -    // Phase transitions with endless cycle - PHASE 1 UPDATE
 -    if (gamePhase === 'DUSK' && phaseTimer >= DUSK_DURATION) {
 -        gamePhase = 'DUSK_TO_NIGHT';
 -        phaseTimer = 0;
 -    } else if (gamePhase === 'DUSK_TO_NIGHT' && phaseTimer >= TRANSITION_DURATION) {
 -        gamePhase = 'NIGHT';
 -        phaseTimer = 0;
 -        // Spawn flies based on difficulty
 -        spawnNightFlies();
 -    } else if (gamePhase === 'NIGHT' && phaseTimer >= NIGHT_DURATION) {
 -        gamePhase = 'NIGHT_TO_DAWN';
 -        phaseTimer = 0;
 -        nightsSurvived++;
 -        currentNight++;
 -        // PHASE 5: Check night achievements
 -        checkNightAchievements();
 -        // PHASE 4: Track flies munched for dawn stamina
 -        fliesMunchedLastNight = fliesMunched;
 -        fliesMunched = 0; // Reset for next night
 -        // PHASE 4B: Clear any thief birds
 -        birds = birds.filter(b => !b.isThief);
 -        windActive = false; // Stop any active wind
 -    } else if (gamePhase === 'NIGHT_TO_DAWN' && phaseTimer >= TRANSITION_DURATION) {
 -        gamePhase = 'DAWN';
 -        phaseTimer = 0;
 -        // PHASE 4: Calculate dawn stamina and spawn birds
 -        maxJumpStamina = 30 + (fliesMunchedLastNight * 10);
 -        maxJumpStamina = min(maxJumpStamina, 150); // Cap at 150
 -        jumpStamina = maxJumpStamina;
 -        // Spawn birds
 -        spawnDawnBirds();
 -        // Flies escape at dawn
 -        escapeFlies();
 -    } else if (gamePhase === 'DAWN' && phaseTimer >= DAWN_DURATION) {
 -        gamePhase = 'DAWN_TO_DAY';
 -        phaseTimer = 0;
 -        // PHASE 5: Check dawn achievements
 -        checkDawnAchievements();
 -        // PHASE 4: Clear birds when dawn ends
 -        birds = [];
 -        // PHASE 3: Open shop at dawn
 -        if (currentNight > 1) {
 -            openUpgradeShop();
 -        }
 -    } else if (gamePhase === 'DAWN_TO_DAY' && phaseTimer >= TRANSITION_DURATION) {
 -        gamePhase = 'DAY';
 -        phaseTimer = 0;
 -        // Degrade webs by 10%
 -        degradeWebs();
 -        // PHASE 5: Open stats panel during day
 -        openStatsPanel();
 -    } else if (gamePhase === 'DAY' && phaseTimer >= DAY_DURATION) {
 -        gamePhase = 'DAY_TO_DUSK';
 -        phaseTimer = 0;
 -    } else if (gamePhase === 'DAY_TO_DUSK' && phaseTimer >= TRANSITION_DURATION) {
 -        gamePhase = 'DUSK';
 -        phaseTimer = 0;
 -        // Return some flies for next night
 -        prepareDusk();
 -    }
+-
 -    // Update sky colors
 -    updateSkyColors();
+-
 -    // Draw sky gradient
 -    drawSkyGradient();
+-
 -    // Draw moon and stars
 -    if (moonOpacity > 0) {
 -        drawMoon();
 -    }
+-
 -    // Draw sun during day phases - PHASE 1 NEW
 -    if (sunOpacity > 0) {
 -        drawSun();
 -    }
+-
 -    // PHASE 4B: Update wind system
 -    updateWind();
+-
 -    // PHASE 4B: Apply wind to airborne entities
 -    if (windActive) {
 -        // Push spider if airborne
 -        if (spider.isAirborne) {
 -            spider.vel.x += cos(windDirection) * windStrength * 0.1;
 +function draw () {
 +  // apply screen shake if active
 +  if (screenShake > 0) {
 +    translate(
 +      random(-screenShake, screenShake),
 +      random(-screenShake, screenShake)
 +    )
 +    screenShake *= 0.9 // Decay shake
 +  }
++
 +  // Check for game over state
 +  if (gameOver) {
 +    // Draw death animation
 +    push()
 +    fill(255, 0, 0, 100 - gameOverTimer)
 +    rect(0, 0, width, height)
 +    pop()
++
 +    gameOverTimer++
 +    return // Skip normal game updates
 +  }
++
 +  // Update phase timer
 +  phaseTimer++
++
 +  // Phase transitions with endless cycle - PHASE 1 UPDATE
 +  if (gamePhase === 'DUSK' && phaseTimer >= DUSK_DURATION) {
 +    gamePhase = 'DUSK_TO_NIGHT'
 +    phaseTimer = 0
 +  } else if (
 +    gamePhase === 'DUSK_TO_NIGHT' &&
 +    phaseTimer >= TRANSITION_DURATION
 +  ) {
 +    gamePhase = 'NIGHT'
 +    phaseTimer = 0
 +    // Spawn flies based on difficulty
 +    spawnNightFlies()
 +  } else if (gamePhase === 'NIGHT' && phaseTimer >= NIGHT_DURATION) {
 +    gamePhase = 'NIGHT_TO_DAWN'
 +    phaseTimer = 0
 +    nightsSurvived++
 +    currentNight++
 +    // PHASE 5: Check night achievements
 +    checkNightAchievements()
 +    // PHASE 4: Track flies munched for dawn stamina
 +    fliesMunchedLastNight = fliesMunched
 +    fliesMunched = 0 // Reset for next night
 +    // PHASE 4B: Clear any thief birds
 +    birds = birds.filter(b => !b.isThief)
 +    windActive = false // Stop any active wind
 +  } else if (
 +    gamePhase === 'NIGHT_TO_DAWN' &&
 +    phaseTimer >= TRANSITION_DURATION
 +  ) {
 +    gamePhase = 'DAWN'
 +    phaseTimer = 0
++
 +    // ENHANCED: Calculate dawn stamina with CLEAR BONUS DISPLAY
 +    let baseStamina = 30
 +    let flyBonus = fliesMunchedLastNight * 10
 +    staminaBonus = flyBonus // Store for display
++
 +    maxJumpStamina = baseStamina + flyBonus
 +    maxJumpStamina = min(maxJumpStamina, 200) // Cap at 200 instead of 150
 +    jumpStamina = maxJumpStamina
++
 +    // Clear notification showing stamina calculation
 +    notifications.push(
 +      new Notification(
 +        `Dawn Stamina: ${baseStamina} base + ${flyBonus} (${fliesMunchedLastNight} flies × 10) = ${maxJumpStamina}`,
 +        color(255, 200, 100)
 +      )
 +    )
++
 +    // Warning notifications based on stamina level
 +    if (maxJumpStamina <= 50) {
 +      notifications.push(
 +        new Notification(
 +          '⚠️ DANGER: Very low stamina! Eat more flies next night!',
 +          color(255, 50, 50)
 +        )
 +      )
 +    } else if (maxJumpStamina <= 80) {
 +      notifications.push(
 +        new Notification(
 +          'Warning: Low stamina for dawn survival',
 +          color(255, 150, 50)
 +        )
 +      )
 +    } else if (maxJumpStamina >= 150) {
 +      notifications.push(
 +        new Notification(
 +          'Excellent stamina! Well fed spider!',
 +          color(100, 255, 100)
 +        )
 +      )
 +    }
++
 +    // Spawn birds
 +    spawnDawnBirds()
 +    // Flies escape at dawn
 +    escapeFlies()
 +  } else if (gamePhase === 'DAWN' && phaseTimer >= DAWN_DURATION) {
 +    gamePhase = 'DAWN_TO_DAY'
 +    phaseTimer = 0
 +    // PHASE 5: Check dawn achievements
 +    checkDawnAchievements()
 +    // PHASE 4: Clear birds when dawn ends
 +    birds = []
 +    // PHASE 3: Open shop at dawn
 +    if (currentNight > 1) {
 +      openUpgradeShop()
 +    }
 +  } else if (gamePhase === 'DAWN_TO_DAY' && phaseTimer >= TRANSITION_DURATION) {
 +    gamePhase = 'DAY'
 +    phaseTimer = 0
 +    // Degrade webs by 10%
 +    degradeWebs()
 +    // PHASE 5: Open stats panel during day
 +    openStatsPanel()
 +  } else if (gamePhase === 'DAY' && phaseTimer >= DAY_DURATION) {
 +    gamePhase = 'DAY_TO_DUSK'
 +    phaseTimer = 0
 +  } else if (gamePhase === 'DAY_TO_DUSK' && phaseTimer >= TRANSITION_DURATION) {
 +    gamePhase = 'DUSK'
 +    phaseTimer = 0
 +    // Return some flies for next night
 +    prepareDusk()
 +  }
++
 +  // Update sky colors
 +  updateSkyColors()
++
 +  // Draw sky gradient
 +  drawSkyGradient()
++
 +  // Draw moon and stars
 +  if (moonOpacity > 0) {
 +    drawMoon()
 +  }
++
 +  // Draw sun during day phases - PHASE 1 NEW
 +  if (sunOpacity > 0) {
 +    drawSun()
 +  }
++
 +  // PHASE 4B: Update wind system
 +  updateWind()
++
 +  // PHASE 4B: Apply wind to airborne entities
 +  if (windActive) {
 +    // Push spider if airborne
 +    if (spider.isAirborne) {
 +      spider.vel.x += cos(windDirection) * windStrength * 0.1
 +    }
++
 +    // Push flies
 +    for (let fly of flies) {
 +      if (!fly.stuck && !fly.caught) {
 +        fly.vel.x += cos(windDirection) * windStrength * 0.05
 +      }
 +    }
++
 +    // Make webs sway
 +    for (let strand of webStrands) {
 +      if (!strand.broken) {
 +        strand.vibrate(windStrength * 0.5)
 +        // Check if strand is overstretched and should break
 +        if (strand.tension > 1.2 && windStrength > 3) {
 +          if (random() < 0.01) {
 +            // Small chance per frame
 +            strand.broken = true
 +            notifications.push(
 +              new Notification('Wind snapped a web!', color(255, 150, 100))
 +            )
 +          }
+         }
+-
 -        // Push flies
 -        for (let fly of flies) {
 -            if (!fly.stuck && !fly.caught) {
 -                fly.vel.x += cos(windDirection) * windStrength * 0.05;
 -            }
 +      }
 +    }
++
 +    // Update wind particles
 +    for (let i = windParticles.length - 1; i >= 0; i--) {
 +      let p = windParticles[i]
 +      p.x += cos(windDirection) * windStrength * 3
 +      p.life--
 +      if (p.life <= 0 || p.x < -50 || p.x > width + 50) {
 +        windParticles.splice(i, 1)
 +      }
 +    }
++
 +    // Spawn new wind particles
 +    if (frameCount % 5 === 0) {
 +      windParticles.push({
 +        x: windDirection > 0 ? -20 : width + 20,
 +        y: random(height),
 +        life: 120,
 +        size: random(2, 4)
 +      })
 +    }
 +  }
++
 +  // Update and display game objects
 +  for (let obstacle of obstacles) {
 +    obstacle.update() // Update movement and animations
 +    obstacle.display()
 +  }
++
 +  for (let box of foodBoxes) {
 +    box.display()
 +  }
++
 +  // PHASE 4B: Display wind effects
 +  if (windActive) {
 +    push()
 +    noStroke()
 +    for (let p of windParticles) {
 +      fill(255, 255, 255, p.life * 0.5)
 +      ellipse(p.x, p.y, p.size)
 +    }
++
 +    // Wind indicator
 +    push()
 +    translate(width / 2, 50)
 +    stroke(255, 255, 255, 100)
 +    strokeWeight(3)
 +    let arrowLength = windStrength * 10
 +    line(0, 0, cos(windDirection) * arrowLength, 0)
 +    // Arrowhead
 +    push()
 +    translate(cos(windDirection) * arrowLength, 0)
 +    rotate(windDirection)
 +    line(0, 0, -5, -3)
 +    line(0, 0, -5, 3)
 +    pop()
++
 +    // Wind strength text
 +    fill(255, 255, 255, 150)
 +    noStroke()
 +    textAlign(CENTER)
 +    textSize(12)
 +    text('WIND: ' + Math.round(windStrength), 0, 20)
 +    pop()
 +    pop()
 +  }
++
 +  for (let i = particles.length - 1; i >= 0; i--) {
 +    particles[i].update()
 +    particles[i].display()
 +    if (particles[i].isDead()) {
 +      particles.splice(i, 1)
 +    }
 +  }
++
 +  // PHASE 1 UPDATE - Handle broken strands
 +  for (let i = webStrands.length - 1; i >= 0; i--) {
 +    let strand = webStrands[i]
 +    strand.update()
++
 +    // Remove broken strands
 +    if (strand.broken) {
 +      // Create particles for breaking effect
 +      if (strand.path && strand.path.length > 0) {
 +        let midPoint = strand.path[Math.floor(strand.path.length / 2)]
 +        for (let j = 0; j < 5; j++) {
 +          let p = new Particle(midPoint.x, midPoint.y)
 +          p.color = color(255, 255, 255)
 +          p.vel = createVector(random(-2, 2), random(-3, 0))
 +          particles.push(p)
+         }
+-
 -        // Make webs sway
 -        for (let strand of webStrands) {
 -            if (!strand.broken) {
 -                strand.vibrate(windStrength * 0.5);
 -                // Check if strand is overstretched and should break
 -                if (strand.tension > 1.2 && windStrength > 3) {
 -                    if (random() < 0.01) { // Small chance per frame
 -                        strand.broken = true;
 -                        notifications.push(new Notification("Wind snapped a web!", color(255, 150, 100)));
 -                    }
 +      }
++
 +      // Check all stuck/caught flies to see if they need to be released
 +      for (let fly of flies) {
 +        if (fly.stuck || fly.caught) {
 +          // Check if this fly still has valid web support
 +          let hasSupport = false
 +          for (let otherStrand of webStrands) {
 +            if (otherStrand !== strand && !otherStrand.broken) {
 +              // Check if fly is on this other strand
 +              if (otherStrand.path && otherStrand.path.length > 1) {
 +                for (let k = 0; k < otherStrand.path.length - 1; k++) {
 +                  let p1 = otherStrand.path[k]
 +                  let p2 = otherStrand.path[k + 1]
 +                  let d = fly.pointToLineDistance(fly.pos, p1, p2)
 +                  if (d < fly.radius + 5) {
 +                    hasSupport = true
 +                    break
 +                  }
+                 }
 +              }
 +              if (hasSupport) break
+             }
 -        }
+-
 -        // Update wind particles
 -        for (let i = windParticles.length - 1; i >= 0; i--) {
 -            let p = windParticles[i];
 -            p.x += cos(windDirection) * windStrength * 3;
 -            p.life--;
 -            if (p.life <= 0 || p.x < -50 || p.x > width + 50) {
 -                windParticles.splice(i, 1);
 +          }
++
 +          // If no support, release the fly
 +          if (!hasSupport) {
 +            fly.stuck = false
 +            fly.caught = false
 +            fly.currentSpeed = fly.baseSpeed
 +            fly.touchedStrands.clear()
 +            fly.slowedBy.clear()
 +            fly.vel = createVector(random(-0.5, 0.5), 1.5)
++
 +            // Create release particles
 +            for (let j = 0; j < 3; j++) {
 +              let p = new Particle(fly.pos.x, fly.pos.y)
 +              p.color = color(255, 255, 0, 100)
 +              p.vel = createVector(random(-1, 1), random(0, 1))
 +              p.size = 2
 +              particles.push(p)
+             }
 +          }
+         }
+-
 -        // Spawn new wind particles
 -        if (frameCount % 5 === 0) {
 -            windParticles.push({
 -                x: windDirection > 0 ? -20 : width + 20,
 -                y: random(height),
 -                life: 120,
 -                size: random(2, 4)
 -            });
 -        }
 +      }
++
 +      webStrands.splice(i, 1)
 +    } else {
 +      strand.display()
+     }
+-
 -    // Update and display game objects
 -    for (let obstacle of obstacles) {
 -        obstacle.update(); // Update movement and animations
 -        obstacle.display();
 -    }
+-
 -    for (let box of foodBoxes) {
 -        box.display();
 -    }
+-
 -    // PHASE 4B: Display wind effects
 -    if (windActive) {
 -        push();
 -        noStroke();
 -        for (let p of windParticles) {
 -            fill(255, 255, 255, p.life * 0.5);
 -            ellipse(p.x, p.y, p.size);
 -        }
+-
 -        // Wind indicator
 -        push();
 -        translate(width / 2, 50);
 -        stroke(255, 255, 255, 100);
 -        strokeWeight(3);
 -        let arrowLength = windStrength * 10;
 -        line(0, 0, cos(windDirection) * arrowLength, 0);
 -        // Arrowhead
 -        push();
 -        translate(cos(windDirection) * arrowLength, 0);
 -        rotate(windDirection);
 -        line(0, 0, -5, -3);
 -        line(0, 0, -5, 3);
 -        pop();
+-
 -        // Wind strength text
 -        fill(255, 255, 255, 150);
 -        noStroke();
 -        textAlign(CENTER);
 -        textSize(12);
 -        text("WIND: " + Math.round(windStrength), 0, 20);
 -        pop();
 -        pop();
 -    }
+-
 -    for (let i = particles.length - 1; i >= 0; i--) {
 -        particles[i].update();
 -        particles[i].display();
 -        if (particles[i].isDead()) {
 -            particles.splice(i, 1);
 -        }
 +  }
++
 +  for (let node of webNodes) {
 +    node.update()
 +  }
++
 +  // Display current strand being created
 +  if (currentStrand && isDeployingWeb && spider.isAirborne) {
 +    let opacity = map(webSilk, 0, 20, 50, 150)
 +    stroke(255, 255, 255, opacity)
 +    strokeWeight(1.5)
++
 +    if (currentStrand.path && currentStrand.path.length > 0) {
 +      noFill()
 +      beginShape()
 +      curveVertex(currentStrand.path[0].x, currentStrand.path[0].y)
 +      for (let point of currentStrand.path) {
 +        curveVertex(point.x, point.y)
 +      }
 +      curveVertex(spider.pos.x, spider.pos.y)
 +      curveVertex(spider.pos.x, spider.pos.y)
 +      endShape()
 +    } else {
 +      line(
 +        currentStrand.start.x,
 +        currentStrand.start.y,
 +        spider.pos.x,
 +        spider.pos.y
 +      )
+     }
+-
 -    // PHASE 1 UPDATE - Handle broken strands
 -    for (let i = webStrands.length - 1; i >= 0; i--) {
 -        let strand = webStrands[i];
 -        strand.update();
+-
 -        // Remove broken strands
 -        if (strand.broken) {
 -            // Create particles for breaking effect
 -            if (strand.path && strand.path.length > 0) {
 -                let midPoint = strand.path[Math.floor(strand.path.length / 2)];
 -                for (let j = 0; j < 5; j++) {
 -                    let p = new Particle(midPoint.x, midPoint.y);
 -                    p.color = color(255, 255, 255);
 -                    p.vel = createVector(random(-2, 2), random(-3, 0));
 -                    particles.push(p);
 -                }
 -            }
+-
 -            // Check all stuck/caught flies to see if they need to be released
 -            for (let fly of flies) {
 -                if (fly.stuck || fly.caught) {
 -                    // Check if this fly still has valid web support
 -                    let hasSupport = false;
 -                    for (let otherStrand of webStrands) {
 -                        if (otherStrand !== strand && !otherStrand.broken) {
 -                            // Check if fly is on this other strand
 -                            if (otherStrand.path && otherStrand.path.length > 1) {
 -                                for (let k = 0; k < otherStrand.path.length - 1; k++) {
 -                                    let p1 = otherStrand.path[k];
 -                                    let p2 = otherStrand.path[k + 1];
 -                                    let d = fly.pointToLineDistance(fly.pos, p1, p2);
 -                                    if (d < fly.radius + 5) {
 -                                        hasSupport = true;
 -                                        break;
 -                                    }
 -                                }
 -                            }
 -                            if (hasSupport) break;
 -                        }
 -                    }
+-
 -                    // If no support, release the fly
 -                    if (!hasSupport) {
 -                        fly.stuck = false;
 -                        fly.caught = false;
 -                        fly.currentSpeed = fly.baseSpeed;
 -                        fly.touchedStrands.clear();
 -                        fly.slowedBy.clear();
 -                        fly.vel = createVector(random(-0.5, 0.5), 1.5);
+-
 -                        // Create release particles
 -                        for (let j = 0; j < 3; j++) {
 -                            let p = new Particle(fly.pos.x, fly.pos.y);
 -                            p.color = color(255, 255, 0, 100);
 -                            p.vel = createVector(random(-1, 1), random(0, 1));
 -                            p.size = 2;
 -                            particles.push(p);
 -                        }
 -                    }
 -                }
 -            }
+-
 -            webStrands.splice(i, 1);
 -        } else {
 -            strand.display();
 -        }
 +  }
++
 +  for (let i = flies.length - 1; i >= 0; i--) {
 +    flies[i].update()
 +    flies[i].display()
 +  }
++
 +  spider.update()
 +  spider.display()
++
 +  // PHASE 4: Exhaustion indicator
 +  if (gamePhase === 'DAWN' && isExhausted) {
 +    push()
 +    textAlign(CENTER)
 +    textSize(16)
 +    fill(255, 100, 100, 200 + sin(frameCount * 0.2) * 55)
 +    stroke(0)
 +    strokeWeight(2)
 +    text('NO STAMINA!', spider.pos.x, spider.pos.y - 30)
 +    pop()
 +  }
++
 +  // PHASE 4: Update and display birds during dawn
 +  if (gamePhase === 'DAWN') {
 +    // Update stamina
 +    if (!spider.isAirborne && spider.vel.mag() < 0.1) {
 +      // Resting - faster regen
 +      jumpStamina += staminaRegenRate * 2.5
 +    } else {
 +      // Moving - normal regen
 +      jumpStamina += staminaRegenRate
+     }
+-
 -    for (let node of webNodes) {
 -        node.update();
 -    }
+-
 -    // Display current strand being created
 -    if (currentStrand && isDeployingWeb && spider.isAirborne) {
 -        let opacity = map(webSilk, 0, 20, 50, 150);
 -        stroke(255, 255, 255, opacity);
 -        strokeWeight(1.5);
+-
 -        if (currentStrand.path && currentStrand.path.length > 0) {
 -            noFill();
 -            beginShape();
 -            curveVertex(currentStrand.path[0].x, currentStrand.path[0].y);
 -            for (let point of currentStrand.path) {
 -                curveVertex(point.x, point.y);
 -            }
 -            curveVertex(spider.pos.x, spider.pos.y);
 -            curveVertex(spider.pos.x, spider.pos.y);
 -            endShape();
 -        } else {
 -            line(currentStrand.start.x, currentStrand.start.y, spider.pos.x, spider.pos.y);
 +    jumpStamina = min(jumpStamina, maxJumpStamina)
 +    isExhausted = jumpStamina < jumpCost
++
 +    // Update and display birds
 +    for (let i = birds.length - 1; i >= 0; i--) {
 +      let bird = birds[i]
 +      if (bird) {
 +        bird.update()
 +        bird.display()
++
 +        // Remove birds that have flown off screen
 +        if (
 +          bird.y < -100 ||
 +          bird.y > height + 100 ||
 +          bird.x < -100 ||
 +          bird.x > width + 100
 +        ) {
 +          if (bird.state === 'retreating' && !bird.active) {
 +            birds.splice(i, 1)
 +          }
+         }
 +      }
+     }
+-
 -    for (let i = flies.length - 1; i >= 0; i--) {
 -        flies[i].update();
 -        flies[i].display();
 -    }
+-
 -    spider.update();
 -    spider.display();
+-
 -    // PHASE 4: Exhaustion indicator
 -    if (gamePhase === 'DAWN' && isExhausted) {
 -        push();
 -        textAlign(CENTER);
 -        textSize(16);
 -        fill(255, 100, 100, 200 + sin(frameCount * 0.2) * 55);
 -        stroke(0);
 -        strokeWeight(2);
 -        text("NO STAMINA!", spider.pos.x, spider.pos.y - 30);
 -        pop();
 -    }
+-
 -    // PHASE 4: Update and display birds during dawn
 -    if (gamePhase === 'DAWN') {
 -        // Update stamina
 -        if (!spider.isAirborne && spider.vel.mag() < 0.1) {
 -            // Resting - faster regen
 -            jumpStamina += staminaRegenRate * 2.5;
 -        } else {
 -            // Moving - normal regen
 -            jumpStamina += staminaRegenRate;
 -        }
 -        jumpStamina = min(jumpStamina, maxJumpStamina);
 -        isExhausted = jumpStamina < jumpCost;
+-
 -        // Update birds
 -        for (let bird of birds) {
 -            bird.update();
 -            bird.display();
 -        }
++
 +    // Debug: Show bird count
 +    if (frameCount % 60 === 0) {
 +      console.log(`Dawn birds active: ${birds.length}`)
+     }
+-
 -    // PHASE 4B: Update thief birds during night
 -    if (gamePhase === 'NIGHT') {
 -        for (let i = birds.length - 1; i >= 0; i--) {
 -            let bird = birds[i];
 -            bird.update();
 -            bird.display();
+-
 -            // Remove inactive thief birds
 -            if (bird.isThief && !bird.active) {
 -                birds.splice(i, 1);
 -            }
 -        }
 +  }
++
 +  // PHASE 4B: Update thief birds during night
 +  if (gamePhase === 'NIGHT') {
 +    for (let i = birds.length - 1; i >= 0; i--) {
 +      let bird = birds[i]
 +      bird.update()
 +      bird.display()
++
 +      // Remove inactive thief birds
 +      if (bird.isThief && !bird.active) {
 +        birds.splice(i, 1)
 +      }
+     }
+-
 -    // PHASE 3: Spider Sense - show fly path predictions
 -    if (upgrades.spiderSense && upgrades.spiderSense.level > 0) {
 -        push();
 -        strokeWeight(1);
 -        for (let fly of flies) {
 -            if (!fly.stuck && !fly.caught) {
 -                // Predict future position
 -                let futurePos = p5.Vector.add(fly.pos, p5.Vector.mult(fly.vel, 30));
 -                stroke(255, 255, 255, 30);
 -                line(fly.pos.x, fly.pos.y, futurePos.x, futurePos.y);
 -                noFill();
 -                stroke(255, 255, 255, 20);
 -                ellipse(futurePos.x, futurePos.y, 10);
 -            }
 -        }
 -        pop();
 -    }
+-
 -    // PHASE 2: Display notifications
 -    for (let i = notifications.length - 1; i >= 0; i--) {
 -        notifications[i].update();
 -        notifications[i].display();
 -        if (notifications[i].isDead()) {
 -            notifications.splice(i, 1);
 -        }
 +  }
++
 +  // PHASE 3: Spider Sense - show fly path predictions
 +  if (upgrades.spiderSense && upgrades.spiderSense.level > 0) {
 +    push()
 +    strokeWeight(1)
 +    for (let fly of flies) {
 +      if (!fly.stuck && !fly.caught) {
 +        // Predict future position
 +        let futurePos = p5.Vector.add(fly.pos, p5.Vector.mult(fly.vel, 30))
 +        stroke(255, 255, 255, 30)
 +        line(fly.pos.x, fly.pos.y, futurePos.x, futurePos.y)
 +        noFill()
 +        stroke(255, 255, 255, 20)
 +        ellipse(futurePos.x, futurePos.y, 10)
 +      }
+     }
+-
 -    // PHASE 5: Display achievements
 -    displayAchievements();
+-
 -    // Update resources
 -    updateResources();
+-
 -    // PHASE 5: Check achievements continuously
 -    checkAchievements();
+-
 -    // PHASE 3: Update jump charging
 -    if (chargingJump && !spider.isAirborne) {
 -        jumpChargeTime++;
 -        spider.jumpChargeVisual = min(jumpChargeTime / maxJumpCharge, 1);
 -    } else {
 -        spider.jumpChargeVisual = 0;
 -    }
+-
 -    // Handle web deployment
 -    handleWebDeployment();
+-
 -    // Update UI
 -    updateUI();
+-
 -    // Spawn entities during night - PHASE 1 UPDATE
 -    if (gamePhase === 'NIGHT') {
 -        // Dynamic spawn rate based on difficulty
 -        let spawnRate = max(90, 120 - currentNight * 5); // Faster spawning over time
 -        if (phaseTimer % spawnRate === 0 && flies.length < 10 + currentNight * 2) {
 -            // PHASE 2: Spawn different types during the night too
 -            let flyType = 'regular';
 -            let roll = random();
+-
 -            if (currentNight >= 5 && roll < 0.03) {
 -                flyType = 'queen';
 -            } else if (roll < 0.08) {
 -                flyType = 'golden';
 -            } else if (roll < 0.20) {
 -                flyType = 'moth';
 -            }
+-
 -            let fly = new Fly(flyType);
 -            let speedMult = 1 + Math.floor((currentNight - 1) / 3) * 0.1;
 -            fly.baseSpeed = baseFlySpeed * speedMult;
 -            if (flyType === 'golden') fly.baseSpeed *= 1.3;
 -            if (flyType === 'moth') fly.baseSpeed *= 0.8;
 -            if (flyType === 'queen') fly.baseSpeed *= 0.5;
 -            fly.currentSpeed = fly.baseSpeed;
 -            flies.push(fly);
 -        }
 -        if (phaseTimer % 300 === 0 && foodBoxes.length < 6) {
 -            spawnFoodBox();
 -        }
+-
 -        // PHASE 4B: Spawn thief birds at night (after Night 5)
 -        if (currentNight >= 5) {
 -            thiefBirdTimer++;
 -            if (thiefBirdTimer >= nextThiefTime) {
 -                spawnThiefBird();
 -                thiefBirdTimer = 0;
 -                nextThiefTime = random(2700, 3600); // 45-60 seconds
 -            }
 -        }
+-
 -        // PHASE 4B: Random wind gusts at night
 -        if (!windActive && frameCount > nextWindTime) {
 -            startWindGust();
 -        }
 +    pop()
 +  }
++
 +  // PHASE 2: Display notifications
 +  for (let i = notifications.length - 1; i >= 0; i--) {
 +    notifications[i].update()
 +    notifications[i].display()
 +    if (notifications[i].isDead()) {
 +      notifications.splice(i, 1)
+     }
 -}
 +  }
++
 +  // PHASE 5: Display achievements
 +  displayAchievements()
++
 +  // Update resources
 +  updateResources()
++
 +  // PHASE 5: Check achievements continuously
 +  checkAchievements()
++
 +  // PHASE 3: Update jump charging
 +  if (chargingJump && !spider.isAirborne) {
 +    jumpChargeTime++
 +    spider.jumpChargeVisual = min(jumpChargeTime / maxJumpCharge, 1)
 +  } else {
 +    spider.jumpChargeVisual = 0
 +  }
 -// Continue with all the remaining functions...
 -function openStatsPanel() {
 -    // Implementation continues from original file
 +  // Handle web deployment
 +  handleWebDeployment()
++
 +  // Update UI
 +  updateUI()
++
 +  // Spawn entities during night - PHASE 1 UPDATE
 +  if (gamePhase === 'NIGHT') {
 +    // Dynamic spawn rate based on difficulty
 +    let spawnRate = max(90, 120 - currentNight * 5) // Faster spawning over time
 +    if (phaseTimer % spawnRate === 0 && flies.length < 10 + currentNight * 2) {
 +      // PHASE 2: Spawn different types during the night too
 +      let flyType = 'regular'
 +      let roll = random()
++
 +      if (currentNight >= 5 && roll < 0.03) {
 +        flyType = 'queen'
 +      } else if (roll < 0.08) {
 +        flyType = 'golden'
 +      } else if (roll < 0.2) {
 +        flyType = 'moth'
 +      }
++
 +      let fly = new Fly(flyType)
 +      let speedMult = 1 + Math.floor((currentNight - 1) / 3) * 0.1
 +      fly.baseSpeed = baseFlySpeed * speedMult
 +      if (flyType === 'golden') fly.baseSpeed *= 1.3
 +      if (flyType === 'moth') fly.baseSpeed *= 0.8
 +      if (flyType === 'queen') fly.baseSpeed *= 0.5
 +      fly.currentSpeed = fly.baseSpeed
 +      flies.push(fly)
 +    }
 +    if (phaseTimer % 300 === 0 && foodBoxes.length < 6) {
 +      spawnFoodBox()
 +    }
++
 +    // PHASE 4B: Spawn thief birds at night (after Night 5)
 +    if (currentNight >= 5) {
 +      thiefBirdTimer++
 +      if (thiefBirdTimer >= nextThiefTime) {
 +        spawnThiefBird()
 +        thiefBirdTimer = 0
 +        nextThiefTime = random(2700, 3600) // 45-60 seconds
 +      }
 +    }
++
 +    // PHASE 4B: Random wind gusts at night
 +    if (!windActive && frameCount > nextWindTime) {
 +      startWindGust()
 +    }
 +  }
+ }
 -function checkAchievements() {
 -    // Implementation continues from original file
 +function openStatsPanel () {
 +  // Update stats display
 +  let statsHTML = `
 +        <div>Total Flies Caught: ${stats.totalFliesCaught}</div>
 +        <div>Regular: ${stats.regularCaught}</div>
 +        <div>Golden: ${stats.goldenCaught}</div>
 +        <div>Moths: ${stats.mothsCaught}</div>
 +        <div>Queens: ${stats.queensCaught}</div>
 +        <div>Longest Night: ${stats.longestNight}</div>
 +        <div>Total Jumps: ${stats.totalJumps}</div>
 +        <div>Wind Jumps: ${stats.windJumps}</div>
 +        <div>Thieves Scared: ${stats.thievesScared}</div>
 +        <div>Perfect Dawns: ${stats.perfectDawns}</div>
 +    `
 +  document.getElementById('stats-list').innerHTML = statsHTML
++
 +  // Update skins display
 +  let skinsHTML = ''
 +  let skins = [
 +    { id: 'default', name: 'Classic', icon: '🕷️', unlocked: true },
 +    {
 +      id: 'galaxy',
 +      name: 'Galaxy',
 +      icon: '🌌',
 +      unlocked: unlockedSkins.galaxy
 +    },
 +    {
 +      id: 'golden',
 +      name: 'Golden',
 +      icon: '✨',
 +      unlocked: unlockedSkins.golden
 +    },
 +    {
 +      id: 'shadow',
 +      name: 'Shadow',
 +      icon: '🌑',
 +      unlocked: unlockedSkins.shadow
 +    },
 +    {
 +      id: 'rainbow',
 +      name: 'Rainbow',
 +      icon: '🌈',
 +      unlocked: unlockedSkins.rainbow
 +    }
 +  ]
++
 +  for (let skin of skins) {
 +    let selected = currentSkin === skin.id
 +    let locked = !skin.unlocked
 +    skinsHTML += `
 +            <div onclick="selectSkin('${skin.id}')"
 +                 style="padding: 10px; background: ${
 +                   selected ? '#FFD700' : locked ? '#444' : '#666'
 +                 };
 +                        border-radius: 10px; cursor: ${
 +                          locked ? 'not-allowed' : 'pointer'
 +                        };
 +                        opacity: ${locked ? '0.5' : '1'}; text-align: center;">
 +                <div style="font-size: 30px;">${skin.icon}</div>
 +                <div style="font-size: 12px; color: ${
 +                  selected ? '#000' : '#FFF'
 +                };">
 +                    ${skin.name}${locked ? ' 🔒' : ''}
 +                </div>
 +            </div>
 +        `
 +  }
 +  document.getElementById('skins-list').innerHTML = skinsHTML
++
 +  // Update achievements display
 +  let achievementsHTML = ''
 +  for (let key in achievements) {
 +    let ach = achievements[key]
 +    let progress =
 +      ach.progress !== undefined ? ` (${ach.progress}/${ach.target})` : ''
 +    achievementsHTML += `
 +            <div style="padding: 8px; background: ${
 +              ach.unlocked ? '#4CAF50' : '#444'
 +            };
 +                       border-radius: 5px; opacity: ${
 +                         ach.unlocked ? '1' : '0.6'
 +                       };">
 +                ${ach.icon} ${ach.name}${!ach.unlocked ? progress : ' ✓'}
 +            </div>
 +        `
 +  }
 +  document.getElementById('achievements-list').innerHTML = achievementsHTML
++
 +  // Show panel
 +  document.getElementById('stats-panel').style.display = 'block'
++
 +  // Add close button listener
 +  document.getElementById('close-stats-btn').onclick = () => {
 +    document.getElementById('stats-panel').style.display = 'none'
++
 +    // IMMEDIATELY transition to dusk after closing stats
 +    if (gamePhase === 'DAY') {
 +      gamePhase = 'DAY_TO_DUSK'
 +      phaseTimer = 0
 +    }
 +  }
+ }
 -function checkNightAchievements() {
 -    // Implementation continues from original file
 +// Make selectSkin global
 +window.selectSkin = function (skinId) {
 +  if (unlockedSkins[skinId]) {
 +    currentSkin = skinId
 +    saveGame()
 +    openStatsPanel() // Refresh display
 +    notifications.push(
 +      new Notification(`Skin changed to ${skinId}!`, color(100, 255, 100))
 +    )
 +  }
+ }
 -function checkDawnAchievements() {
 -    // Implementation continues from original file
 +// ============================================
 +// PHASE 5: ACHIEVEMENTS & COSMETICS
 +// ============================================
++
 +function checkAchievements () {
 +  // Night Owl - Survive X nights
 +  if (!achievements.nightOwl.unlocked) {
 +    achievements.nightOwl.progress = nightsSurvived
 +    if (nightsSurvived >= achievements.nightOwl.target) {
 +      unlockAchievement('nightOwl')
 +    }
 +  }
++
 +  // Silk Master - 15+ strands at once
 +  if (!achievements.silkMaster.unlocked) {
 +    let activeStrands = webStrands.filter(s => !s.broken).length
 +    achievements.silkMaster.progress = max(
 +      achievements.silkMaster.progress,
 +      activeStrands
 +    )
 +    if (activeStrands >= achievements.silkMaster.target) {
 +      unlockAchievement('silkMaster')
 +    }
 +  }
++
 +  // Wind Rider - Jump during wind
 +  if (
 +    !achievements.windRider.unlocked &&
 +    achievements.windRider.progress >= achievements.windRider.target
 +  ) {
 +    unlockAchievement('windRider')
 +  }
++
 +  // Thief Defender
 +  if (
 +    !achievements.thiefDefender.unlocked &&
 +    stats.thievesScared >= achievements.thiefDefender.target
 +  ) {
 +    achievements.thiefDefender.progress = stats.thievesScared
 +    unlockAchievement('thiefDefender')
 +  }
++
 +  // Queen Slayer
 +  if (!achievements.queenSlayer.unlocked) {
 +    achievements.queenSlayer.progress = stats.queensCaught
 +    if (stats.queensCaught >= achievements.queenSlayer.target) {
 +      unlockAchievement('queenSlayer')
 +    }
 +  }
++
 +  // Galaxy Unlock - 15 nights
 +  if (!achievements.galaxyUnlock.unlocked) {
 +    achievements.galaxyUnlock.progress = nightsSurvived
 +    if (nightsSurvived >= achievements.galaxyUnlock.target) {
 +      unlockAchievement('galaxyUnlock')
 +      unlockedSkins.galaxy = true
 +    }
 +  }
++
 +  // Golden Hunter - 100 golden flies
 +  if (!achievements.goldenHunter.unlocked) {
 +    achievements.goldenHunter.progress = stats.goldenCaught
 +    if (stats.goldenCaught >= achievements.goldenHunter.target) {
 +      unlockAchievement('goldenHunter')
 +      unlockedSkins.golden = true
 +    }
 +  }
++
 +  // Web Master - 500 total flies
 +  if (!achievements.webMaster.unlocked) {
 +    achievements.webMaster.progress = stats.totalFliesCaught
 +    if (stats.totalFliesCaught >= achievements.webMaster.target) {
 +      unlockAchievement('webMaster')
 +      unlockedSkins.rainbow = true
 +    }
 +  }
++
 +  // Speedrunner - 30 flies before night 5
 +  if (
 +    !achievements.speedrunner.unlocked &&
 +    currentNight < 5 &&
 +    stats.totalFliesCaught >= 30
 +  ) {
 +    unlockAchievement('speedrunner')
 +  }
+ }
 -function unlockAchievement(achievementKey) {
 -    // Implementation continues from original file
 +function checkNightAchievements () {
 +  // Called at end of night
++
 +  // Feast - 20 flies munched in one night
 +  if (
 +    !achievements.feast.unlocked &&
 +    stats.fliesMunchedInCurrentNight >= achievements.feast.target
 +  ) {
 +    achievements.feast.progress = stats.fliesMunchedInCurrentNight
 +    unlockAchievement('feast')
 +  }
++
 +  // Architect - Catch 5 flies without munching
 +  if (
 +    !achievements.architect.unlocked &&
 +    stats.fliesCaughtWithoutMunch >= achievements.architect.target
 +  ) {
 +    achievements.architect.progress = stats.fliesCaughtWithoutMunch
 +    unlockAchievement('architect')
 +  }
++
 +  // Untouchable - No strands lost
 +  if (!achievements.untouchable.unlocked && stats.strandsLostInNight === 0) {
 +    unlockAchievement('untouchable')
 +  }
++
 +  // Shadow Predator - 50 flies in one night
 +  if (
 +    !achievements.shadowPredator.unlocked &&
 +    fliesCaught >= achievements.shadowPredator.target
 +  ) {
 +    achievements.shadowPredator.progress = fliesCaught
 +    unlockAchievement('shadowPredator')
 +    unlockedSkins.shadow = true
 +  }
++
 +  // Reset night-specific counters
 +  stats.fliesMunchedInCurrentNight = 0
 +  stats.fliesCaughtWithoutMunch = fliesCaught
 +  stats.strandsLostInNight = 0
+ }
 -function displayAchievements() {
 -    // Implementation continues from original file
 +function checkDawnAchievements () {
 +  // Perfect Dawn - no bird hits
 +  if (!achievements.perfectDawn.unlocked && stats.birdHitsTaken === 0) {
 +    unlockAchievement('perfectDawn')
 +    stats.perfectDawns++
 +  }
++
 +  // Exhaustion Master - survive with < 20 stamina
 +  if (!achievements.exhaustionMaster.unlocked && jumpStamina < 20) {
 +    unlockAchievement('exhaustionMaster')
 +  }
++
 +  // Reset dawn counter
 +  stats.birdHitsTaken = 0
+ }
 -function saveGame() {
 -    // Implementation continues from original file
 +function unlockAchievement (achievementKey) {
 +  let achievement = achievements[achievementKey]
 +  if (achievement.unlocked) return
++
 +  achievement.unlocked = true
 +  achievementQueue.push(achievement)
++
 +  // Save to localStorage
 +  saveGame()
+ }
 -function loadGame() {
 -    let saveData = localStorage.getItem('cobGameSave');
 -    if (saveData) {
 -        let data = JSON.parse(saveData);
 -        achievements = data.achievements || achievements;
 -        stats = data.stats || stats;
 -        unlockedSkins = data.unlockedSkins || unlockedSkins;
 -        currentSkin = data.currentSkin || 'default';
 -        upgrades = data.upgrades || upgrades;
 -        playerPoints = data.playerPoints || 0;
 -        nightsSurvived = data.nightsSurvived || 0;
 -        currentNight = data.currentNight || 1;
+-
 -        // Apply upgrades (spider exists now)
 -        applyUpgradeEffects();
 +function displayAchievements () {
 +  // Show queued achievements
 +  if (!showingAchievement && achievementQueue.length > 0) {
 +    showingAchievement = achievementQueue.shift()
 +    achievementDisplayTimer = 240 // 4 seconds
 +  }
++
 +  // Display current achievement
 +  if (showingAchievement && achievementDisplayTimer > 0) {
 +    push()
++
 +    // Background
 +    let alpha =
 +      achievementDisplayTimer > 200
 +        ? 255
 +        : map(achievementDisplayTimer, 0, 40, 0, 255)
 +    fill(20, 20, 40, alpha * 0.9)
 +    stroke(255, 215, 0, alpha)
 +    strokeWeight(3)
 +    rectMode(CENTER)
 +    rect(width / 2, 100, 400, 80, 10)
++
 +    // Icon
 +    textAlign(CENTER)
 +    textSize(30)
 +    fill(255, 255, 255, alpha)
 +    text(showingAchievement.icon, width / 2 - 150, 105)
++
 +    // Text
 +    textSize(20)
 +    fill(255, 215, 0, alpha)
 +    text('ACHIEVEMENT UNLOCKED!', width / 2, 85)
++
 +    textSize(16)
 +    fill(255, 255, 255, alpha)
 +    text(showingAchievement.name, width / 2, 105)
++
 +    textSize(12)
 +    fill(200, 200, 200, alpha)
 +    text(showingAchievement.desc, width / 2, 125)
++
 +    pop()
++
 +    achievementDisplayTimer--
 +    if (achievementDisplayTimer <= 0) {
 +      showingAchievement = null
+     }
 +  }
+ }
 -function spawnThiefBird() {
 -    // Implementation continues from original file
 +function saveGame () {
 +  // Save to localStorage
 +  let saveData = {
 +    achievements: achievements,
 +    stats: stats,
 +    unlockedSkins: unlockedSkins,
 +    currentSkin: currentSkin,
 +    upgrades: upgrades,
 +    playerPoints: playerPoints,
 +    nightsSurvived: nightsSurvived,
 +    currentNight: currentNight
 +  }
++
 +  localStorage.setItem('cobGameSave', JSON.stringify(saveData))
+ }
 -function startWindGust() {
 -    // Implementation continues from original file
 +function loadGame () {
 +  let saveData = localStorage.getItem('cobGameSave')
 +  if (saveData) {
 +    let data = JSON.parse(saveData)
 +    achievements = data.achievements || achievements
 +    stats = data.stats || stats
 +    unlockedSkins = data.unlockedSkins || unlockedSkins
 +    currentSkin = data.currentSkin || 'default'
 +    upgrades = data.upgrades || upgrades
 +    playerPoints = data.playerPoints || 0
 +    nightsSurvived = data.nightsSurvived || 0
 +    currentNight = data.currentNight || 1
++
 +    // Apply upgrades
 +    applyUpgradeEffects()
 +  }
+ }
 -function updateWind() {
 -    // Implementation continues from original file
 +// ============================================
 +// PHASE 4B: NIGHT THREATS
 +// ============================================
++
 +function spawnThiefBird () {
 +  // Check if there are caught flies to steal
 +  let caughtFlies = flies.filter(f => f.stuck || f.caught)
 +  if (caughtFlies.length === 0) return
++
 +  // Create a thief bird
 +  let thief = new Bird('swoop', true)
 +  thief.active = true
 +  thief.attackDelay = 60 // Attack quickly
 +  birds.push(thief)
++
 +  // PHASE 5: Track thief scared if spider is near
 +  if (
 +    dist(
 +      spider.pos.x,
 +      spider.pos.y,
 +      caughtFlies[0].pos.x,
 +      caughtFlies[0].pos.y
 +    ) < 80
 +  ) {
 +    stats.thievesScared++
 +  }
++
 +  // Visual warning
 +  push()
 +  textAlign(CENTER)
 +  textSize(30)
 +  fill(200, 50, 200)
 +  stroke(0)
 +  strokeWeight(3)
 +  text('THIEF!', width / 2, height / 2)
 +  pop()
+ }
 -function spawnDawnBirds() {
 -    // Implementation continues from original file
 +function startWindGust () {
 +  windActive = true
 +  windDirection = random() < 0.5 ? 0 : PI // Left or right
 +  windStrength = random(2, 5) // Variable strength
 +  windDuration = random(300, 600) // 5-10 seconds
 +  windTimer = 0
 +  windParticles = []
++
 +  // Notification
 +  let direction = windDirection === 0 ? '→' : '←'
 +  notifications.push(
 +    new Notification(`Wind gust ${direction}`, color(200, 200, 255))
 +  )
+ }
 -function openUpgradeShop() {
 -    // Implementation continues from original file
 +function updateWind () {
 +  if (!windActive) return
++
 +  windTimer++
++
 +  // Fade in and out
 +  if (windTimer < 60) {
 +    // Fade in
 +    windStrength = lerp(0, windStrength, windTimer / 60)
 +  } else if (windTimer > windDuration - 60) {
 +    // Fade out
 +    windStrength = lerp(windStrength, 0, (windTimer - (windDuration - 60)) / 60)
 +  }
++
 +  // End wind
 +  if (windTimer >= windDuration) {
 +    windActive = false
 +    windTimer = 0
 +    windParticles = []
 +    nextWindTime = frameCount + random(1800, 3600) // 30-60 seconds until next wind
 +  }
+ }
 -function closeUpgradeShop() {
 -    // Implementation continues from original file
 +// ============================================
 +// PHASE 4: DAWN SURVIVAL FUNCTIONS
 +// ============================================
++
 +function spawnDawnBirds () {
 +  birds = []
++
 +  // Start with 3 birds, add 1 every 3 nights (capped at 6)
 +  let numBirds = min(3 + Math.floor((currentNight - 1) / 3), 6)
++
 +  // Mix of attack patterns
 +  let patterns = ['dive', 'dive', 'glide'] // More dive birds
 +  if (currentNight >= 3) patterns.push('circle')
 +  if (currentNight >= 6) patterns.push('dive', 'glide')
++
 +  for (let i = 0; i < numBirds; i++) {
 +    let pattern = random(patterns)
 +    let bird = new Bird(pattern, false) // false = not a thief
 +    bird.active = false // Will activate after delay
 +    bird.attackDelay = 60 + i * 60 // Stagger attack delays
 +    birds.push(bird)
 +  }
++
 +  // Notification
 +  notifications.push(
 +    new Notification(`DAWN! ${numBirds} birds hunting!`, color(255, 150, 100))
 +  )
++
 +  // Debug log to confirm birds are spawning
 +  console.log(`Spawned ${numBirds} dawn birds`)
+ }
 -function updateShopDisplay() {
 -    // Implementation continues from original file
 +// ============================================
 +// PHASE 3: UPGRADE SHOP FUNCTIONS
 +// ============================================
++
 +function openUpgradeShop () {
 +  if (currentNight <= 1) return // No shop on first night
++
 +  shopOpen = true
 +  noLoop() // Pause the game
++
 +  // Calculate points from flies caught this session
 +  playerPoints = totalFliesCaught
++
 +  // Update shop UI
 +  document.getElementById('upgrade-shop').style.display = 'block'
 +  document.getElementById('available-points').textContent = playerPoints
++
 +  // Populate upgrade lists
 +  updateShopDisplay()
++
 +  // Add continue button listener
 +  document.getElementById('continue-btn').onclick = closeUpgradeShop
+ }
 -function applyUpgradeEffects() {
 -    // Check if spider exists before applying upgrades
 -    if (!spider) return;
+-
 -    // Reset to base values
 -    spider.jumpPower = 12;
 -    maxWebSilk = 100;
 -    silkDrainRate = 2;
 -    spider.munchCooldownMax = 30; // Add this property to spider
+-
 -    // Apply Tier 1 upgrades
 -    if (upgrades.strongLegs.level > 0) {
 -        spider.jumpPower = 12 * (1 + 0.15 * upgrades.strongLegs.level);
 -    }
+-
 -    if (upgrades.silkGlands.level > 0) {
 -        maxWebSilk = 100 + (20 * upgrades.silkGlands.level);
 -        webSilk = min(webSilk, maxWebSilk); // Cap current silk to new max
 -    }
+-
 -    if (upgrades.efficientSpinning.level > 0) {
 -        silkDrainRate = 2 * (1 - 0.2 * upgrades.efficientSpinning.level);
 -    }
+-
 -    if (upgrades.quickMunch.level > 0) {
 -        spider.munchCooldownMax = 30 * (1 - 0.3 * upgrades.quickMunch.level);
 -    }
+-
 -    // Tier 2 upgrades are handled in their respective functions
 +function closeUpgradeShop () {
 +  shopOpen = false
 +  document.getElementById('upgrade-shop').style.display = 'none'
++
 +  // IMMEDIATELY transition to dusk after closing shop
 +  if (gamePhase === 'DAY') {
 +    gamePhase = 'DAY_TO_DUSK'
 +    phaseTimer = 0
 +  }
++
 +  loop() // Resume the game
+ }
 -function spawnNightFlies() {
 -    // Implementation continues from original file
 +function updateShopDisplay () {
 +  let tier1HTML = ''
 +  let tier2HTML = ''
 +  let tier1Count = 0
++
 +  // Count tier 1 upgrades
 +  for (let key in upgrades) {
 +    if (upgrades[key].tier === 1 && upgrades[key].level > 0) {
 +      tier1Count++
 +    }
 +  }
++
 +  // Display Tier 1 upgrades
 +  for (let key in upgrades) {
 +    let upgrade = upgrades[key]
 +    if (upgrade.tier === 1) {
 +      let canAfford = playerPoints >= upgrade.cost
 +      let maxed = upgrade.level >= upgrade.maxLevel
 +      let buttonText = maxed ? 'MAXED' : `Buy (${upgrade.cost} pts)`
 +      let buttonDisabled = maxed || !canAfford ? 'disabled' : ''
 +      let opacity = maxed ? '0.5' : '1'
++
 +      tier1HTML += `
 +                <div style="margin: 10px 0; padding: 10px; background: rgba(0,0,0,0.3);
 +                           border-radius: 10px; opacity: ${opacity};">
 +                    <div style="display: flex; justify-content: space-between; align-items: center;">
 +                        <div>
 +                            <span style="font-size: 24px;">${
 +                              upgrade.icon
 +                            }</span>
 +                            <strong>${upgrade.name}</strong> (${
 +        upgrade.level
 +      }/${upgrade.maxLevel})
 +                            <br><small>${upgrade.description}</small>
 +                        </div>
 +                        <button onclick="buyUpgrade('${key}')" ${buttonDisabled}
 +                                style="padding: 5px 15px; background: ${
 +                                  canAfford && !maxed ? '#4CAF50' : '#666'
 +                                };
 +                                      color: white; border: none; border-radius: 5px; cursor: ${
 +                                        canAfford && !maxed
 +                                          ? 'pointer'
 +                                          : 'not-allowed'
 +                                      };">
 +                            ${buttonText}
 +                        </button>
 +                    </div>
 +                </div>
 +            `
 +    }
 +  }
++
 +  // Display Tier 2 upgrades
 +  for (let key in upgrades) {
 +    let upgrade = upgrades[key]
 +    if (upgrade.tier === 2) {
 +      let unlocked = tier1Count >= upgrade.requires
 +      let canAfford = playerPoints >= upgrade.cost && unlocked
 +      let maxed = upgrade.level >= upgrade.maxLevel
 +      let buttonText = maxed
 +        ? 'MAXED'
 +        : !unlocked
 +        ? `Needs ${upgrade.requires} Tier 1`
 +        : `Buy (${upgrade.cost} pts)`
 +      let buttonDisabled = maxed || !canAfford ? 'disabled' : ''
 +      let opacity = !unlocked ? '0.3' : maxed ? '0.5' : '1'
++
 +      tier2HTML += `
 +                <div style="margin: 10px 0; padding: 10px; background: rgba(0,0,0,0.3);
 +                           border-radius: 10px; opacity: ${opacity};">
 +                    <div style="display: flex; justify-content: space-between; align-items: center;">
 +                        <div>
 +                            <span style="font-size: 24px;">${
 +                              upgrade.icon
 +                            }</span>
 +                            <strong>${upgrade.name}</strong> (${
 +        upgrade.level
 +      }/${upgrade.maxLevel})
 +                            <br><small>${upgrade.description}</small>
 +                        </div>
 +                        <button onclick="buyUpgrade('${key}')" ${buttonDisabled}
 +                                style="padding: 5px 15px; background: ${
 +                                  canAfford && !maxed ? '#FF69B4' : '#666'
 +                                };
 +                                      color: white; border: none; border-radius: 5px; cursor: ${
 +                                        canAfford && !maxed
 +                                          ? 'pointer'
 +                                          : 'not-allowed'
 +                                      };">
 +                            ${buttonText}
 +                        </button>
 +                    </div>
 +                </div>
 +            `
 +    }
 +  }
++
 +  document.getElementById('upgrade-list-tier1').innerHTML = tier1HTML
 +  document.getElementById('upgrade-list-tier2').innerHTML = tier2HTML
++
 +  // Update tier 2 section opacity
 +  document.getElementById('tier2-upgrades').style.opacity =
 +    tier1Count >= 2 ? '1' : '0.5'
+ }
 -function escapeFlies() {
 -    // Implementation continues from original file
 +// Make buyUpgrade global so onclick can access it
 +window.buyUpgrade = function (upgradeKey) {
 +  let upgrade = upgrades[upgradeKey]
 +  if (!upgrade) return
++
 +  // Check tier requirements
 +  if (upgrade.tier === 2) {
 +    let tier1Count = 0
 +    for (let key in upgrades) {
 +      if (upgrades[key].tier === 1 && upgrades[key].level > 0) {
 +        tier1Count++
 +      }
 +    }
 +    if (tier1Count < upgrade.requires) return
 +  }
++
 +  // Check if can afford and not maxed
 +  if (playerPoints >= upgrade.cost && upgrade.level < upgrade.maxLevel) {
 +    playerPoints -= upgrade.cost
 +    upgrade.level++
++
 +    // Apply upgrade effects immediately
 +    applyUpgradeEffects()
++
 +    // Update display
 +    document.getElementById('available-points').textContent = playerPoints
 +    updateShopDisplay()
++
 +    // Show notification
 +    notifications.push(
 +      new Notification(`Upgraded ${upgrade.name}!`, color(100, 255, 100))
 +    )
 +  }
 +}
++
 +function applyUpgradeEffects () {
 +  if (!spider) return // Ensure spider exists
++
 +  // Reset to base values
 +  spider.jumpPower = 12
 +  maxWebSilk = 100
 +  silkDrainRate = 2
 +  spider.munchCooldownMax = 30 // Add this property to spider
++
 +  // Apply Tier 1 upgrades
 +  if (upgrades.strongLegs.level > 0) {
 +    spider.jumpPower = 12 * (1 + 0.15 * upgrades.strongLegs.level)
 +  }
++
 +  if (upgrades.silkGlands.level > 0) {
 +    maxWebSilk = 100 + 20 * upgrades.silkGlands.level
 +    webSilk = min(webSilk, maxWebSilk) // Cap current silk to new max
 +  }
++
 +  if (upgrades.efficientSpinning.level > 0) {
 +    silkDrainRate = 2 * (1 - 0.2 * upgrades.efficientSpinning.level)
 +  }
++
 +  if (upgrades.quickMunch.level > 0) {
 +    spider.munchCooldownMax = 30 * (1 - 0.3 * upgrades.quickMunch.level)
 +  }
++
 +  // Tier 2 upgrades are handled in their respective functions
 +}
++
 +function spawnNightFlies () {
 +  // Base flies + more per night
 +  let numFlies = 5 + currentNight
++
 +  // Apply difficulty scaling
 +  let flySpeedMultiplier = 1 + Math.floor((currentNight - 1) / 3) * 0.1 // +10% every 3 nights
++
 +  for (let i = 0; i < numFlies; i++) {
 +    // PHASE 2: Spawn different fly types with rarity
 +    let flyType = 'regular'
 +    let roll = random()
++
 +    if (currentNight >= 5 && roll < 0.05) {
 +      // Queen flies: 5% chance after night 5
 +      flyType = 'queen'
 +    } else if (roll < 0.1) {
 +      // Golden flies: 10% chance
 +      flyType = 'golden'
 +    } else if (roll < 0.25) {
 +      // Moths: 15% chance
 +      flyType = 'moth'
 +    }
++
 +    let fly = new Fly(flyType)
 +    fly.baseSpeed = baseFlySpeed * flySpeedMultiplier
 +    if (flyType === 'golden') fly.baseSpeed *= 1.3 // Golden are always faster
 +    if (flyType === 'moth') fly.baseSpeed *= 0.8 // Moths are slower
 +    if (flyType === 'queen') fly.baseSpeed *= 0.5 // Queens are much slower
 +    fly.currentSpeed = fly.baseSpeed
 +    flies.push(fly)
 +  }
++
 +  // PHASE 2: Guarantee at least 1 golden fly per night
 +  if (flies.filter(f => f.type === 'golden').length === 0) {
 +    let goldenFly = new Fly('golden')
 +    goldenFly.baseSpeed = baseFlySpeed * flySpeedMultiplier * 1.3
 +    goldenFly.currentSpeed = goldenFly.baseSpeed
 +    flies.push(goldenFly)
 +    // Add notification
 +    notifications.push(
 +      new Notification('Golden Firefly Appeared! ✨', color(255, 215, 0))
 +    )
 +  }
++
 +  // PHASE 2: Guarantee a queen on nights 10+
 +  if (
 +    currentNight >= 10 &&
 +    flies.filter(f => f.type === 'queen').length === 0
 +  ) {
 +    let queenFly = new Fly('queen')
 +    queenFly.baseSpeed = baseFlySpeed * flySpeedMultiplier * 0.5
 +    queenFly.currentSpeed = queenFly.baseSpeed
 +    flies.push(queenFly)
 +    // Add notification
 +    notifications.push(
 +      new Notification('Queen Firefly Arrived! 👑', color(200, 100, 255))
 +    )
 +  }
++
 +  // Spawn some food boxes
 +  for (let i = 0; i < 3; i++) {
 +    spawnFoodBox()
 +  }
 +}
++
 +function escapeFlies () {
 +  // Store escaping flies (could be used for visual effect later)
 +  fliesEscaped = []
++
 +  for (let fly of flies) {
 +    if (!fly.stuck) {
 +      fliesEscaped.push({
 +        x: fly.pos.x,
 +        y: fly.pos.y,
 +        type: fly.type // PHASE 2: Store actual type
 +      })
 +    }
 +  }
++
 +  // Clear all flies
 +  flies = []
 +}
++
 +function degradeWebs () {
 +  // Degrade each web strand by 10%
 +  for (let strand of webStrands) {
 +    strand.strength *= 0.9
++
 +    // Very weak strands break
 +    if (strand.strength < 0.3) {
 +      strand.broken = true
 +    }
++
 +    // Add slight sag to simulate aging
 +    if (strand.path && strand.path.length > 2) {
 +      for (let i = 1; i < strand.path.length - 1; i++) {
 +        strand.path[i].y += random(2, 5)
 +      }
 +    }
 +  }
++
 +  // Create some particles to show degradation
 +  for (let i = 0; i < 10; i++) {
 +    let p = new Particle(random(width), random(height))
 +    p.color = color(255, 255, 255, 100)
 +    p.vel = createVector(0, random(0.5, 2))
 +    p.size = 2
 +    particles.push(p)
 +  }
 +}
++
 +function prepareDusk () {
 +  // Return some flies for the next night (visual continuity)
 +  let returnCount = min(3, fliesEscaped.length)
 +  for (let i = 0; i < returnCount; i++) {
 +    // PHASE 2: Recreate the same type of fly that escaped
 +    let fly = new Fly(fliesEscaped[i].type)
 +    // Start from edge but move toward previous positions
 +    fly.wanderAngle = atan2(
 +      fliesEscaped[i].y - fly.pos.y,
 +      fliesEscaped[i].x - fly.pos.x
 +    )
 +    flies.push(fly)
 +  }
+ }
 -function degradeWebs() {
 -    // Implementation continues from original file
 +function drawSun () {
 +  push()
 +  noStroke()
++
 +  // Sun glow
 +  fill(255, 230, 100, sunOpacity * 0.3)
 +  ellipse(width - 150, sunY, 120)
 +  fill(255, 220, 50, sunOpacity * 0.5)
 +  ellipse(width - 150, sunY, 80)
 +  fill(255, 200, 0, sunOpacity)
 +  ellipse(width - 150, sunY, 50)
++
 +  pop()
 +}
++
 +function propagateVibration (sourceStrand, vibrationAmount) {
 +  // FIX: Instead of checking all strand pairs, use a limited propagation
 +  // Only check strands that share endpoints (actually connected)
++
 +  let vibratedStrands = new Set()
 +  vibratedStrands.add(sourceStrand)
++
 +  // Find directly connected strands only
 +  for (let strand of webStrands) {
 +    if (strand === sourceStrand || strand.broken) continue
++
 +    // Check if strands share an endpoint (much faster than distance checks)
 +    let connected = false
++
 +    // Check if endpoints are very close (essentially the same point)
 +    if (sourceStrand.start && strand.start) {
 +      if (
 +        dist(
 +          sourceStrand.start.x,
 +          sourceStrand.start.y,
 +          strand.start.x,
 +          strand.start.y
 +        ) < 5
 +      ) {
 +        connected = true
 +      }
 +    }
 +    if (!connected && sourceStrand.start && strand.end) {
 +      if (
 +        dist(
 +          sourceStrand.start.x,
 +          sourceStrand.start.y,
 +          strand.end.x,
 +          strand.end.y
 +        ) < 5
 +      ) {
 +        connected = true
 +      }
 +    }
 +    if (!connected && sourceStrand.end && strand.start) {
 +      if (
 +        dist(
 +          sourceStrand.end.x,
 +          sourceStrand.end.y,
 +          strand.start.x,
 +          strand.start.y
 +        ) < 5
 +      ) {
 +        connected = true
 +      }
 +    }
 +    if (!connected && sourceStrand.end && strand.end) {
 +      if (
 +        dist(
 +          sourceStrand.end.x,
 +          sourceStrand.end.y,
 +          strand.end.x,
 +          strand.end.y
 +        ) < 5
 +      ) {
 +        connected = true
 +      }
 +    }
++
 +    if (connected) {
 +      strand.vibrate(vibrationAmount)
 +      vibratedStrands.add(strand)
++
 +      // Stop after vibrating 5 strands to prevent performance issues
 +      if (vibratedStrands.size >= 5) break
 +    }
 +  }
+ }
 -function prepareDusk() {
 -    // Implementation continues from original file
 +// ============================================
 +// ORIGINAL FUNCTIONS WITH PHASE 1 UPDATES
 +// ============================================
++
 +function updateSkyColors () {
 +  // PHASE 1 - Complete rewrite for full cycle
 +  if (gamePhase === 'DAWN') {
 +    // Dawn: dark purple/blue to soft orange/pink
 +    currentSkyColor1 = lerpColor(
 +      color(70, 70, 120),
 +      color(255, 200, 150),
 +      phaseTimer / DAWN_DURATION
 +    )
 +    currentSkyColor2 = lerpColor(
 +      color(30, 30, 60),
 +      color(255, 150, 100),
 +      phaseTimer / DAWN_DURATION
 +    )
 +    moonOpacity = lerp(255, 0, phaseTimer / DAWN_DURATION)
 +    moonY = lerp(60, -50, phaseTimer / DAWN_DURATION)
 +    sunY = lerp(height + 50, height - 100, phaseTimer / DAWN_DURATION)
 +    sunOpacity = lerp(0, 100, phaseTimer / DAWN_DURATION)
 +  } else if (gamePhase === 'DAWN_TO_DAY') {
 +    let t = phaseTimer / TRANSITION_DURATION
 +    currentSkyColor1 = lerpColor(color(255, 200, 150), color(135, 206, 235), t)
 +    currentSkyColor2 = lerpColor(color(255, 150, 100), color(255, 255, 200), t)
 +    sunY = lerp(height - 100, height * 0.3, t)
 +    sunOpacity = lerp(100, 255, t)
 +  } else if (gamePhase === 'DAY') {
 +    // Day: bright blue sky
 +    currentSkyColor1 = color(135, 206, 235)
 +    currentSkyColor2 = color(255, 255, 200)
 +    sunY = lerp(height * 0.3, 100, phaseTimer / DAY_DURATION)
 +    sunOpacity = 255
 +  } else if (gamePhase === 'DAY_TO_DUSK') {
 +    let t = phaseTimer / TRANSITION_DURATION
 +    currentSkyColor1 = lerpColor(color(135, 206, 235), color(255, 140, 90), t)
 +    currentSkyColor2 = lerpColor(color(255, 255, 200), color(255, 183, 77), t)
 +    sunY = lerp(100, 60, t)
 +    sunOpacity = lerp(255, 150, t)
 +  } else if (gamePhase === 'DUSK') {
 +    // Dusk: orange/purple sunset
 +    currentSkyColor1 = lerpColor(
 +      color(255, 140, 90),
 +      color(200, 100, 120),
 +      phaseTimer / DUSK_DURATION
 +    )
 +    currentSkyColor2 = lerpColor(
 +      color(255, 183, 77),
 +      color(120, 60, 120),
 +      phaseTimer / DUSK_DURATION
 +    )
 +    sunY = lerp(60, -50, phaseTimer / DUSK_DURATION)
 +    sunOpacity = lerp(150, 0, phaseTimer / DUSK_DURATION)
 +  } else if (gamePhase === 'DUSK_TO_NIGHT') {
 +    let t = phaseTimer / TRANSITION_DURATION
 +    currentSkyColor1 = lerpColor(color(200, 100, 120), color(25, 25, 112), t)
 +    currentSkyColor2 = lerpColor(color(120, 60, 120), color(0, 0, 40), t)
 +    moonOpacity = t * 255
 +    moonY = lerp(100, 60, t)
 +  } else if (gamePhase === 'NIGHT') {
 +    // Night: dark blue/purple
 +    currentSkyColor1 = color(25, 25, 112)
 +    currentSkyColor2 = color(0, 0, 40)
 +    moonOpacity = 255
 +    moonY = 60
 +  } else if (gamePhase === 'NIGHT_TO_DAWN') {
 +    let t = phaseTimer / TRANSITION_DURATION
 +    currentSkyColor1 = lerpColor(color(25, 25, 112), color(70, 70, 120), t)
 +    currentSkyColor2 = lerpColor(color(0, 0, 40), color(30, 30, 60), t)
 +  }
+ }
 -function drawSun() {
 -    // Implementation continues from original file
 +function drawSkyGradient () {
 +  for (let i = 0; i <= height; i++) {
 +    let inter = map(i, 0, height, 0, 1)
 +    let c = lerpColor(currentSkyColor1, currentSkyColor2, inter)
 +    stroke(c)
 +    line(0, i, width, i)
 +  }
++
 +  // Draw home branch
 +  if (window.homeBranch) {
 +    push()
 +    let branch = window.homeBranch
++
 +    // Branch shadow
 +    push()
 +    translate(0, branch.y + 5)
 +    rotate(branch.angle)
 +    noStroke()
 +    fill(0, 0, 0, 30)
++
 +    // Shadow with taper
 +    beginShape()
 +    vertex(branch.startX, 10)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.3,
 +      8,
 +      branch.startX + (branch.endX - branch.startX) * 0.7,
 +      5,
 +      branch.endX,
 +      3
 +    )
 +    vertex(branch.endX, -3)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.7,
 +      -5,
 +      branch.startX + (branch.endX - branch.startX) * 0.3,
 +      -8,
 +      branch.startX,
 +      -10
 +    )
 +    endShape(CLOSE)
 +    pop()
++
 +    // Main branch with organic shape and taper
 +    push()
 +    translate(0, branch.y)
 +    rotate(branch.angle)
++
 +    noStroke()
++
 +    // Base color - PHASE 1: Update for all phases
 +    if (gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN') {
 +      fill(30, 15, 5)
 +    } else {
 +      fill(92, 51, 23)
 +    }
++
 +    // Branch body with taper
 +    beginShape()
 +    vertex(branch.startX, -branch.thickness)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.3,
 +      -branch.thickness * 0.9,
 +      branch.startX + (branch.endX - branch.startX) * 0.7,
 +      -branch.thickness * 0.6,
 +      branch.endX,
 +      -branch.thickness * 0.35
 +    )
 +    vertex(branch.endX, branch.thickness * 0.35)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.7,
 +      branch.thickness * 0.6,
 +      branch.startX + (branch.endX - branch.startX) * 0.3,
 +      branch.thickness * 0.9,
 +      branch.startX,
 +      branch.thickness
 +    )
 +    endShape(CLOSE)
++
 +    // Add a fork around 70% down the branch
 +    push()
 +    let forkX = branch.startX + (branch.endX - branch.startX) * 0.7
 +    let forkY = 0
 +    translate(forkX, forkY)
 +    rotate(((branch.side === 'right' ? -1 : 1) * PI) / 6)
++
 +    // Fork branch
 +    if (gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN') {
 +      fill(35, 18, 6)
 +    } else {
 +      fill(102, 58, 28)
 +    }
++
 +    beginShape()
 +    vertex(0, -8)
 +    bezierVertex(20, -7, 35, -5, 50, -3)
 +    vertex(50, 3)
 +    bezierVertex(35, 5, 20, 7, 0, 8)
 +    endShape(CLOSE)
 +    pop()
++
 +    // Add lighter highlights
 +    if (gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN') {
 +      fill(50, 25, 10, 150)
 +    } else {
 +      fill(139, 90, 43, 180)
 +    }
++
 +    // Highlight on top ridge
 +    beginShape()
 +    vertex(branch.startX + 20, -branch.thickness * 0.8)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.4,
 +      -branch.thickness * 0.7,
 +      branch.startX + (branch.endX - branch.startX) * 0.6,
 +      -branch.thickness * 0.5,
 +      branch.endX - 20,
 +      -branch.thickness * 0.25
 +    )
 +    vertex(branch.endX - 20, -branch.thickness * 0.15)
 +    bezierVertex(
 +      branch.startX + (branch.endX - branch.startX) * 0.6,
 +      -branch.thickness * 0.4,
 +      branch.startX + (branch.endX - branch.startX) * 0.4,
 +      -branch.thickness * 0.6,
 +      branch.startX + 20,
 +      -branch.thickness * 0.7
 +    )
 +    endShape(CLOSE)
++
 +    // Bark texture lines
 +    stroke(60, 30, 10, 100)
 +    strokeWeight(1)
 +    for (let texture of branch.barkTextures) {
 +      if (texture.x % 20 < 10) {
 +        line(texture.x, texture.yOff, texture.x + 3, texture.endYOff)
 +      }
 +    }
++
 +    // Knots
 +    noStroke()
 +    if (gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN') {
 +      fill(40, 20, 5)
 +    } else {
 +      fill(80, 40, 15)
 +    }
 +    ellipse(branch.startX + (branch.endX - branch.startX) * 0.3, -5, 12, 8)
 +    ellipse(branch.startX + (branch.endX - branch.startX) * 0.65, 3, 8, 10)
++
 +    pop()
++
 +    // Small twigs - properly attached to the rotated branch
 +    stroke(
 +      gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN'
 +        ? color(40, 20, 0)
 +        : color(101, 67, 33)
 +    )
++
 +    // Just add a couple simple twigs for visual interest
 +    strokeWeight(3)
 +    line(
 +      branch.startX + (branch.endX - branch.startX) * 0.3,
 +      -5,
 +      branch.startX + (branch.endX - branch.startX) * 0.3 - 10,
 +      -15
 +    )
 +    line(
 +      branch.startX + (branch.endX - branch.startX) * 0.6,
 +      0,
 +      branch.startX + (branch.endX - branch.startX) * 0.6 + 8,
 +      -12
 +    )
++
 +    // Add leaves (properly positioned within rotated branch)
 +    for (let leaf of branch.leaves) {
 +      let leafX = branch.startX + (branch.endX - branch.startX) * leaf.t
 +      push()
 +      translate(leafX, leaf.yOffset)
 +      rotate(leaf.rotation)
++
 +      // Leaf shadow
 +      noStroke()
 +      fill(0, 0, 0, 20)
 +      ellipse(2, 2, leaf.width, leaf.height)
++
 +      // Leaf body
 +      if (gamePhase === 'NIGHT' || gamePhase === 'NIGHT_TO_DAWN') {
 +        fill(20, 40, 20)
 +      } else {
 +        fill(34, 139, 34)
 +      }
 +      ellipse(0, 0, leaf.width, leaf.height)
++
 +      // Leaf vein
 +      stroke(25, 100, 25, 100)
 +      strokeWeight(0.5)
 +      line(-leaf.width / 2 + 2, 0, leaf.width / 2 - 2, 0)
 +      pop()
 +    }
++
 +    pop()
 +  }
+ }
 -function updateSkyColors() {
 -    // Implementation continues from original file
 +function drawMoon () {
 +  push()
 +  noStroke()
++
 +  // Brighter, farther-reaching moon glow
 +  fill(255, 255, 240, moonOpacity)
 +  ellipse(width - 100, moonY, 52)
++
 +  // Multi-layer radial glow for reach
 +  push()
 +  blendMode(ADD)
 +  fill(255, 255, 230, moonOpacity * 0.55)
 +  ellipse(width - 100, moonY, 90)
 +  fill(255, 255, 210, moonOpacity * 0.35)
 +  ellipse(width - 100, moonY, 140)
 +  fill(220, 230, 255, moonOpacity * 0.22)
 +  ellipse(width - 100, moonY, 200)
 +  pop()
++
 +  // Moon craters with better contrast
 +  fill(240, 240, 210, moonOpacity * 0.7)
 +  ellipse(width - 105, moonY - 5, 8)
 +  ellipse(width - 95, moonY + 8, 12)
 +  ellipse(width - 110, moonY + 10, 6)
++
 +  // Subtle "godrays" emanating from the moon
 +  push()
 +  blendMode(ADD)
 +  let baseA = frameCount * 0.0023 // slow drift
 +  let rayCount = 8
 +  for (let i = 0; i < rayCount; i++) {
 +    let a =
 +      baseA +
 +      i * ((Math.PI * 2) / rayCount) +
 +      (noise(i * 0.2, frameCount * 0.005) - 0.5) * 0.2
 +    let len = 140 + noise(i * 1.7, frameCount * 0.003) * 120 // 140-260px
 +    let w0 = 6 + noise(i * 0.9) * 6 // near width
 +    let w1 = 18 + noise(i * 0.7) * 16 // far width
 +    let cx = width - 100
 +    let cy = moonY
 +    fill(220, 230, 255, moonOpacity * 0.18)
 +    noStroke()
 +    beginShape()
 +    vertex(cx + Math.cos(a + 0.03) * w0, cy + Math.sin(a + 0.03) * w0)
 +    vertex(cx + Math.cos(a - 0.03) * w0, cy + Math.sin(a - 0.03) * w0)
 +    vertex(
 +      cx + Math.cos(a) * len + Math.cos(a + 0.12) * w1,
 +      cy + Math.sin(a) * len + Math.sin(a + 0.12) * w1
 +    )
 +    vertex(
 +      cx + Math.cos(a) * len + Math.cos(a - 0.12) * w1,
 +      cy + Math.sin(a) * len + Math.sin(a - 0.12) * w1
 +    )
 +    endShape(CLOSE)
 +  }
 +  pop()
++
 +  pop()
+ }
 -function drawSkyGradient() {
 -    // Implementation continues from original file
 +function updateResources () {
 +  // PHASE 1 - Apply difficulty scaling to silk regen
 +  let silkPenalty = Math.floor((currentNight - 1) / 5) * 0.05
 +  let adjustedRegenRate = silkRechargeRate * (1 - silkPenalty)
++
 +  webSilk = min(webSilk + adjustedRegenRate, maxWebSilk)
++
 +  // Handle silk drain for both keyboard and touch
 +  if (
 +    isDeployingWeb &&
 +    spider.isAirborne &&
 +    (spacePressed || touchHolding) &&
 +    webSilk > 0
 +  ) {
 +    webSilk = max(0, webSilk - silkDrainRate)
 +    if (webSilk <= 0) {
 +      isDeployingWeb = false
 +      spacePressed = false
 +      touchHolding = false
 +      if (currentStrand) {
 +        webStrands.pop()
 +        currentStrand = null
 +      }
 +    }
 +  }
++
 +  if (!spacePressed && !touchHolding && isDeployingWeb) {
 +    isDeployingWeb = false
 +  }
+ }
 -function drawMoon() {
 -    // Implementation continues from original file
 +function handleWebDeployment () {
 +  // Handle keyboard-based web deployment
 +  if (spacePressed && spider.isAirborne && !isDeployingWeb && webSilk > 10) {
 +    isDeployingWeb = true
 +    currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
 +    currentStrand.path = [spider.lastAnchorPoint.copy()]
 +    webStrands.push(currentStrand)
 +    webNodes.push(
 +      new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y)
 +    )
 +  }
++
 +  // Update web for keyboard controls
 +  if (currentStrand && isDeployingWeb && spider.isAirborne && spacePressed) {
 +    currentStrand.end = spider.pos.copy()
 +    if (frameCount % 2 === 0) {
 +      currentStrand.path.push(spider.pos.copy())
 +    }
 +  }
++
 +  // Touch-based web deployment is handled in touchMoved()
+ }
 -function updateResources() {
 -    // Implementation continues from original file
 +function updateUI () {
 +  // Update control instructions based on device
 +  let isMobile =
 +    /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
 +      navigator.userAgent
 +    )
++
 +  // PHASE 3: Add upgrade-specific controls
 +  let controls = []
 +  if (isMobile) {
 +    controls.push(
 +      'Tap to jump • Hold mid-air for web • Double-tap spider to munch!'
 +    )
 +  } else {
 +    controls.push('Click to jump • Space to spin web • Shift to munch!')
 +  }
++
 +  // Add upgrade controls
 +  if (upgrades.powerJump && upgrades.powerJump.level > 0) {
 +    controls.push('Hold click to charge jump!')
 +  }
 +  if (upgrades.silkRecycle && upgrades.silkRecycle.level > 0) {
 +    controls.push('Press R to recycle web!')
 +  }
++
 +  document.getElementById('info').innerHTML =
 +    controls.join('<br>') +
 +    '<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>'
++
 +  // PHASE 1 UPDATES
 +  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('total-score').textContent = totalFliesCaught
++
 +  // Update phase display
 +  let phaseDisplay = gamePhase
 +  if (gamePhase === 'DUSK_TO_NIGHT') phaseDisplay = 'NIGHTFALL'
 +  else if (gamePhase === 'NIGHT_TO_DAWN') phaseDisplay = 'DAWN BREAKS'
 +  else if (gamePhase === 'DAWN_TO_DAY') phaseDisplay = 'SUNRISE'
 +  else if (gamePhase === 'DAY_TO_DUSK') phaseDisplay = 'SUNSET'
 +  document.getElementById('phase').textContent = phaseDisplay
++
 +  // Update night counter
 +  document.getElementById('night-counter').textContent = `Night ${currentNight}`
++
 +  // Update timer based on phase
 +  let timerText = ''
 +  let potentialStamina = 30 + fliesMunched * 10
 +  potentialStamina = min(potentialStamina, 200)
++
 +  let staminaColor = ''
 +  if (potentialStamina <= 50) {
 +    staminaColor = 'style="color: #ff4444;"'
 +  } else if (potentialStamina <= 80) {
 +    staminaColor = 'style="color: #ffaa44;"'
 +  } else {
 +    staminaColor = 'style="color: #44ff44;"'
 +  }
++
 +  document.getElementById('timer').innerHTML =
 +    timerText +
 +    `<br><small ${staminaColor}>Dawn Stamina: ${potentialStamina}</small>`
++
 +  if (gamePhase === 'DUSK') {
 +    let timeLeft = Math.ceil((DUSK_DURATION - phaseTimer) / 60)
 +    timerText = `${timeLeft}s to prepare!`
 +  } else if (gamePhase === 'NIGHT') {
 +    let timeLeft = Math.ceil((NIGHT_DURATION - phaseTimer) / 60)
 +    // PHASE 2: Count different fly types
 +    let regularCount = flies.filter(f => f.type === 'regular').length
 +    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
++
 +    timerText = `${timeLeft}s • ${flies.length} flies`
++
 +    // Show special fly counts if any
 +    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(' ')})`
 +    }
 +  } else if (gamePhase === 'DAWN') {
 +    let timeLeft = Math.ceil((DAWN_DURATION - phaseTimer) / 60)
 +    // PHASE 4: Show birds and exhaustion status
 +    let activeBirds = birds.filter(b => b.attacking).length
 +    timerText = `${timeLeft}s • ${birds.length} birds`
 +    if (activeBirds > 0) timerText += ` (${activeBirds} attacking!)`
 +    if (isExhausted) timerText += ' EXHAUSTED!'
 +    if (phaseTimer < 180) {
 +      document.getElementById('timer').innerHTML =
 +        timerText +
 +        `<br><small style="color: #FFD700;">+${staminaBonus} from flies!</small>`
 +    }
 +    if (jumpStamina <= 20 && frameCount % 30 < 15) {
 +      document.getElementById('web-meter-fill').style.opacity = '0.5'
 +    } else {
 +      document.getElementById('web-meter-fill').style.opacity = '1'
 +    }
 +  } else if (gamePhase === 'DAY') {
 +    timerText = 'Rest & repair'
 +  } else if (gamePhase.includes('TO')) {
 +    timerText = '...'
 +  }
 +  document.getElementById('timer').textContent = timerText
++
 +  // Show difficulty indicators
 +  if (currentNight > 1) {
 +    let speedBonus = Math.floor((currentNight - 1) / 3) * 10
 +    let silkPenalty = Math.floor((currentNight - 1) / 5) * 5
++
 +    if (speedBonus > 0 || silkPenalty > 0) {
 +      let diffText = []
 +      if (speedBonus > 0) diffText.push(`Flies +${speedBonus}% speed`)
 +      if (silkPenalty > 0) diffText.push(`Silk -${silkPenalty}% regen`)
++
 +      // Add a small difficulty indicator if needed
 +      if (gamePhase === 'DUSK' && phaseTimer < 180) {
 +        document.getElementById('timer').textContent += ` (${diffText.join(
 +          ', '
 +        )})`
 +      }
 +    }
 +  }
++
 +  // PHASE 4: Update meter based on phase
 +  if (gamePhase === 'DAWN') {
 +    // Show stamina instead of silk during dawn
 +    document.getElementById('web-meter-label').textContent = 'STAMINA'
 +    let staminaPercent = (jumpStamina / maxJumpStamina) * 100
 +    document.getElementById('web-meter-fill').style.width = staminaPercent + '%'
++
 +    // Color based on stamina level
 +    if (jumpStamina < jumpCost) {
 +      // Exhausted - red flash
 +      let flash = sin(frameCount * 0.3) * 0.5 + 0.5
 +      document.getElementById(
 +        'web-meter-fill'
 +      ).style.background = `linear-gradient(90deg, rgb(255, ${
 +        50 + flash * 50
 +      }, ${50 + flash * 50}), rgb(200, ${30 + flash * 30}, ${30 + flash * 30}))`
 +    } else if (jumpStamina < maxJumpStamina * 0.3) {
 +      // Very tired - orange-red
 +      document.getElementById('web-meter-fill').style.background =
 +        'linear-gradient(90deg, #FF6B35, #FF4444)'
 +    } else if (jumpStamina < maxJumpStamina * 0.5) {
 +      // Tired - orange
 +      document.getElementById('web-meter-fill').style.background =
 +        'linear-gradient(90deg, #FFA500, #FF8C00)'
 +    } 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 {
 +    // Normal silk meter
 +    document.getElementById('web-meter-label').textContent = 'SILK'
 +    let meterPercent = (webSilk / maxWebSilk) * 100
 +    document.getElementById('web-meter-fill').style.width = meterPercent + '%'
++
 +    if (webSilk < 20) {
 +      let flash = sin(frameCount * 0.2) * 0.5 + 0.5
 +      document.getElementById(
 +        'web-meter-fill'
 +      ).style.background = `linear-gradient(90deg, rgb(255, ${
 +        100 + flash * 100
 +      }, ${100 + flash * 100}), rgb(255, ${150 + flash * 50}, ${
 +        150 + flash * 50
 +      }))`
 +    } else {
 +      document.getElementById('web-meter-fill').style.background =
 +        'linear-gradient(90deg, #87CEEB, #E0F6FF)'
 +    }
 +  }
+ }
 -function handleWebDeployment() {
 -    // Implementation continues from original file
 +function triggerGameOver (reason) {
 +  if (gameOver) return // Already game over
++
 +  gameOver = true
 +  gameOverTimer = 0
 +  deathReason = reason
 +  finalScore = totalFliesCaught
++
 +  // Save high score
 +  let highScore = localStorage.getItem('cobHighScore') || 0
 +  if (finalScore > highScore) {
 +    localStorage.setItem('cobHighScore', finalScore)
 +  }
++
 +  // Stop game music/sounds if any
 +  noLoop() // Pause the game
++
 +  // Show game over screen after a short delay
 +  setTimeout(showGameOverScreen, 1000)
+ }
 -function updateUI() {
 -    // Implementation continues from original file
 +// Add game over screen function:
 +function showGameOverScreen () {
 +  // Create game over overlay
 +  let gameOverHTML = `
 +        <div id="game-over-screen" style="
 +            position: fixed;
 +            top: 0;
 +            left: 0;
 +            width: 100%;
 +            height: 100%;
 +            background: rgba(0, 0, 0, 0.9);
 +            display: flex;
 +            flex-direction: column;
 +            justify-content: center;
 +            align-items: center;
 +            z-index: 1000;
 +            color: white;
 +            font-family: Arial, sans-serif;
 +        ">
 +            <h1 style="color: #ff4444; font-size: 48px; margin-bottom: 20px;">GAME OVER</h1>
 +            <p style="font-size: 24px; color: #ffaaaa; margin-bottom: 30px;">${deathReason}</p>
++
 +            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px; margin-bottom: 30px;">
 +                <h2 style="color: #FFD700; margin-bottom: 15px;">Final Stats</h2>
 +                <p style="font-size: 20px;">Nights Survived: ${nightsSurvived}</p>
 +                <p style="font-size: 20px;">Total Flies Caught: ${finalScore}</p>
 +                <p style="font-size: 20px;">High Score: ${
 +                  localStorage.getItem('cobHighScore') || 0
 +                }</p>
 +            </div>
++
 +            <button onclick="restartGame()" style="
 +                padding: 15px 40px;
 +                font-size: 24px;
 +                background: #4CAF50;
 +                color: white;
 +                border: none;
 +                border-radius: 10px;
 +                cursor: pointer;
 +                transition: all 0.3s;
 +            " onmouseover="this.style.background='#5CBF60'" onmouseout="this.style.background='#4CAF50'">
 +                Try Again
 +            </button>
 +        </div>
 +    `
++
 +  document.body.insertAdjacentHTML('beforeend', gameOverHTML)
+ }
 -function recycleNearbyWeb() {
 -    // Implementation continues from original file
 +// Add restart game function:
 +window.restartGame = function () {
 +  // Remove game over screen
 +  let gameOverScreen = document.getElementById('game-over-screen')
 +  if (gameOverScreen) {
 +    gameOverScreen.remove()
 +  }
++
 +  // Reset game state
 +  gameOver = false
 +  gameOverTimer = 0
 +  deathReason = ''
++
 +  // Reset to initial values
 +  gamePhase = 'DUSK'
 +  phaseTimer = 0
 +  nightsSurvived = 0
 +  currentNight = 1
 +  fliesCaught = 0
 +  fliesMunched = 0
 +  totalFliesCaught = 0
 +  jumpStamina = 100
 +  maxJumpStamina = 100
 +  webSilk = 100
++
 +  // Clear entities
 +  flies = []
 +  birds = []
 +  webStrands = []
 +  particles = []
 +  notifications = []
++
 +  // Restart the game loop
 +  loop()
++
 +  // Respawn spider at home
 +  if (window.homeBranch) {
 +    let spiderStartX = window.homeBranch.endX
 +    let branchSurfaceY =
 +      window.homeBranch.y - window.homeBranch.thickness * 0.35
 +    spider.pos.x = spiderStartX
 +    spider.pos.y = branchSurfaceY - 8
 +    spider.vel.mult(0)
 +    spider.isAirborne = false
 +  }
+ }
  // Input handlers
 -let touchStartTime = 0;
 -let lastTapTime = 0;
 -let touchHolding = false;
 -let touchStartX = 0;
 -let touchStartY = 0;
+-
 -function keyPressed() {
 -    // Implementation continues from original file
 -}
 +let touchStartTime = 0
 +let lastTapTime = 0
 +let touchHolding = false
 +let touchStartX = 0
 +let touchStartY = 0
 -function keyReleased() {
 -    // Implementation continues from original file
 +function keyPressed () {
 +  if (key === ' ') {
 +    spacePressed = true
 +    return false
 +  }
 +  if (keyCode === SHIFT) {
 +    spider.munch()
 +    return false
 +  }
 +  // PHASE 3: Silk Recycle with R key
 +  if (key === 'r' || key === 'R') {
 +    if (upgrades.silkRecycle && upgrades.silkRecycle.level > 0) {
 +      recycleNearbyWeb()
 +    }
 +    return false
 +  }
 +  // PHASE 5: Stats panel with S key
 +  if (key === 's' || key === 'S') {
 +    if (gamePhase === 'DAY' || gamePhase === 'DUSK') {
 +      openStatsPanel()
 +    }
 +    return false
 +  }
+ }
 -function mousePressed() {
 -    // Implementation continues from original file
 +function keyReleased () {
 +  if (key === ' ') {
 +    spacePressed = false
 +    isDeployingWeb = false
 +    return false
 +  }
+ }
 -function mouseReleased() {
 -    // Implementation continues from original file
 +function mousePressed () {
 +  // Only handle mouse on desktop (not touch devices)
 +  if (touches.length === 0) {
 +    if (!spider.isAirborne) {
 +      // PHASE 3: Power Jump - start charging if upgrade unlocked
 +      if (upgrades.powerJump && upgrades.powerJump.level > 0) {
 +        chargingJump = true
 +        jumpChargeTime = 0
 +      } else {
 +        spider.jump(mouseX, mouseY)
 +      }
 +    }
 +  }
+ }
 -function touchStarted() {
 -    // Implementation continues from original file
 +function mouseReleased () {
 +  // PHASE 3: Power Jump - release charged jump
 +  if (chargingJump && !spider.isAirborne) {
 +    let chargeRatio = min(jumpChargeTime / maxJumpCharge, 1)
 +    let chargeMultiplier = 1 + chargeRatio // 1x to 2x multiplier
 +    spider.jumpChargeVisual = 0
 +    spider.jump(mouseX, mouseY, chargeMultiplier)
++
 +    // Create charge release particles
 +    if (chargeRatio > 0.5) {
 +      for (let i = 0; i < 10; i++) {
 +        let p = new Particle(spider.pos.x, spider.pos.y)
 +        p.color = color(255, 255, 100)
 +        p.vel = createVector(random(-3, 3), random(-1, 2))
 +        p.size = 5
 +        particles.push(p)
 +      }
 +    }
 +  }
 +  chargingJump = false
 +  jumpChargeTime = 0
+ }
 -function touchMoved() {
 -    // Implementation continues from original file
 +// PHASE 3: Silk Recycle function
 +function recycleNearbyWeb () {
 +  let recycled = false
++
 +  for (let i = webStrands.length - 1; i >= 0; i--) {
 +    let strand = webStrands[i]
 +    if (strand.broken) continue
++
 +    // Check if spider is near any part of the strand
 +    let nearStrand = false
 +    if (strand.path && strand.path.length > 0) {
 +      for (let point of strand.path) {
 +        if (dist(spider.pos.x, spider.pos.y, point.x, point.y) < 50) {
 +          nearStrand = true
 +          break
 +        }
 +      }
 +    }
++
 +    if (nearStrand) {
 +      // Recycle the strand
 +      webSilk = min(webSilk + 10, maxWebSilk) // Recover 50% of typical strand cost
++
 +      // Create recycling particles
 +      for (let j = 0; j < strand.path.length; j += 3) {
 +        let point = strand.path[j]
 +        let p = new Particle(point.x, point.y)
 +        p.color = color(150, 255, 150)
 +        p.vel = createVector(
 +          (spider.pos.x - point.x) * 0.02,
 +          (spider.pos.y - point.y) * 0.02
 +        )
 +        p.size = 3
 +        particles.push(p)
 +      }
++
 +      // Remove the strand
 +      webStrands.splice(i, 1)
 +      recycled = true
++
 +      // Show notification
 +      notifications.push(
 +        new Notification('Web Recycled +10 Silk', color(150, 255, 150))
 +      )
 +      break // Only recycle one strand at a time
 +    }
 +  }
++
 +  if (!recycled) {
 +    notifications.push(
 +      new Notification('No web nearby to recycle', color(255, 100, 100))
 +    )
 +  }
+ }
 -function touchEnded() {
 -    // Implementation continues from original file
 +function touchStarted () {
 +  if (touches.length > 0) {
 +    touchStartTime = millis()
 +    touchStartX = touches[0].x
 +    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
++
 +    if (touchOnSpider && millis() - lastTapTime < 300) {
 +      // Double tap detected on spider - MUNCH!
 +      spider.munch()
 +      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)
 +      lastTapTime = millis()
 +    } else if (spider.isAirborne && webSilk > 10 && !isDeployingWeb) {
 +      // Start web deployment if airborne (only if not already deploying)
 +      touchHolding = true
 +      isDeployingWeb = true
 +      currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
 +      currentStrand.path = [spider.lastAnchorPoint.copy()]
 +      webStrands.push(currentStrand)
 +      webNodes.push(
 +        new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y)
 +      )
 +    } else if (spider.isAirborne && isDeployingWeb) {
 +      // If already deploying and user taps again, just continue (don't create new strand)
 +      touchHolding = true
 +    }
 +  }
 +  return false // Prevent default
+ }
 -function windowResized() {
 -    resizeCanvas(window.innerWidth, window.innerHeight);
 +function touchMoved () {
 +  // Update web deployment target while holding
 +  if (
 +    touchHolding &&
 +    spider.isAirborne &&
 +    isDeployingWeb &&
 +    currentStrand &&
 +    webSilk > 0
 +  ) {
 +    // Web follows spider while deploying (not finger position)
 +    currentStrand.end = spider.pos.copy()
 +    if (frameCount % 2 === 0) {
 +      currentStrand.path.push(spider.pos.copy())
 +    }
 +  }
 +  return false // Prevent default
+ }
 -// Make functions globally accessible
 -window.selectSkin = function(skinId) {
 -    // Implementation continues from original file
 +function touchEnded () {
 +  touchHolding = false
++
 +  // Stop web deployment when releasing touch
 +  if (isDeployingWeb && spider.isAirborne) {
 +    isDeployingWeb = false
 +  }
++
 +  return false // Prevent default
+ }
 -window.buyUpgrade = function(upgradeKey) {
 -    // Implementation continues from original file
 -}
 +function windowResized () {
 +  resizeCanvas(window.innerWidth, window.innerHeight)
 +}