`2a6657e`

improve divebomb, notification spacing

Authored by

espadonne 8 months ago

SHA: 2a6657e74ecfd661f247a56f3a4f0fef46a52451
Parents: 9a2a133
Tree: d249f5c

2 changed files

Status	File	+	-
M	`js/entities.js`	416	394
M	`js/game.js`	44	29

js/entities.jsmodified

+     }
+   }
--    checkWebCollisions() {
++  checkWebCollisions () {
--    let currentlyTouching = new Set();
++    let currentlyTouching = new Set()
      for (let strand of webStrands) {
--      let touching = false;
++      let touching = false
        // Check collision with strand path
        if (strand.path && strand.path.length > 1) {
          // 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 p1 = strand.path[i]
--          let p2 = strand.path[Math.min(i + 1, strand.path.length - 1)];
++          let p2 = strand.path[Math.min(i + 1, strand.path.length - 1)]
--          let d = this.pointToLineDistance(this.pos, p1, p2);
++          let d = this.pointToLineDistance(this.pos, p1, p2)
            if (d < this.radius + 3) {
--            touching = true;
++            touching = true
--            break;
++            break
+           }
+         }
        } else if (strand.start && strand.end) {
          // Fallback for strands without path
--        let d = this.pointToLineDistance(this.pos, strand.start, strand.end);
++        let d = this.pointToLineDistance(this.pos, strand.start, strand.end)
          if (d < this.radius + 3) {
--          touching = true;
++          touching = true
+         }
+       }
        if (touching) {
--        currentlyTouching.add(strand);
++        currentlyTouching.add(strand)
          // If this is a new strand we're touching
          if (!this.touchedStrands.has(strand)) {
--          this.touchedStrands.add(strand);
++          this.touchedStrands.add(strand)
            // Vibrate the web when first touching
--          strand.vibrate(3);
++          strand.vibrate(3)
            // First strand slows us down
            if (this.touchedStrands.size === 1) {
--            this.currentSpeed = this.baseSpeed * 0.4; // Slow to 40% speed
++            this.currentSpeed = this.baseSpeed * 0.4 // Slow to 40% speed
--            this.slowedBy.add(strand);
++            this.slowedBy.add(strand)
              // Visual feedback - yellow particles for slowing
              // LIMIT PARTICLES TO PREVENT FREEZE
--            let particleCount = Math.min(3, 100 - particles.length);
++            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);
++              let p = new Particle(this.pos.x, this.pos.y)
--              p.color = color(255, 255, 0, 150);
++              p.color = color(255, 255, 0, 150)
--              p.vel = createVector(random(-1, 1), random(-1, 1));
++              p.vel = createVector(random(-1, 1), random(-1, 1))
--              p.size = 3;
++              p.size = 3
--              particles.push(p);
++              particles.push(p)
+             }
+           }
            // Second strand catches us
            else if (this.touchedStrands.size >= 2 && !this.caught) {
--            this.caught = true;
++            this.caught = true
--            this.currentSpeed = 0;
++            this.currentSpeed = 0
              // Stronger vibration when caught
--            strand.vibrate(8);
++            strand.vibrate(8)
              // 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);
++            propagateVibration(strand, 2)
              // Create caught particles - LIMIT TO PREVENT FREEZE
--            let particleCount = Math.min(6, 100 - particles.length);
++            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);
++              let p = new Particle(this.pos.x, this.pos.y)
--              p.color = color(255, 200, 0, 200);
++              p.color = color(255, 200, 0, 200)
--              p.vel = createVector(random(-2, 2), random(-2, 2));
++              p.vel = createVector(random(-2, 2), random(-2, 2))
--              particles.push(p);
++              particles.push(p)
+             }
+           }
+         }
      // If we're no longer touching strands we were slowed by, speed back up
      if (this.slowedBy.size > 0 && currentlyTouching.size === 0) {
--      this.currentSpeed = this.baseSpeed;
++      this.currentSpeed = this.baseSpeed
--      this.slowedBy.clear();
++      this.slowedBy.clear()
+     }
+   }
--  pointToLineDistance(point, lineStart, lineEnd) {
++  pointToLineDistance (point, lineStart, lineEnd) {
      // Add null checks
--    if (!point || !lineStart || !lineEnd) return Infinity;
++    if (!point || !lineStart || !lineEnd) return Infinity
--
++
--    let dx = lineEnd.x - lineStart.x;
++    let dx = lineEnd.x - lineStart.x
--    let dy = lineEnd.y - lineStart.y;
++    let dy = lineEnd.y - lineStart.y
--    let lineLength = sqrt(dx * dx + dy * dy);
++    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);
++      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);
++    let t =
--    t = constrain(t, 0, 1);
++      ((point.x - lineStart.x) * dx + (point.y - lineStart.y) * dy) /
--
++      (lineLength * lineLength)
--    let closestX = lineStart.x + t * dx;
++    t = constrain(t, 0, 1)
--    let closestY = lineStart.y + t * dy;
++
--
++    let closestX = lineStart.x + t * dx
--    return dist(point.x, point.y, closestX, closestY);
++    let closestY = lineStart.y + t * dy
++
++    return dist(point.x, point.y, closestX, closestY)
+   }
    display () {
+ }
  class Bird {
--    constructor(pattern, isThief = false) {
++  constructor (pattern, isThief = false) {
--        this.pattern = pattern; // 'dive', 'swoop', 'glide', 'circle'
++    this.pattern = pattern // 'dive', 'swoop', 'glide', 'circle'
--        this.isThief = isThief;
++    this.isThief = isThief
--        this.active = false;
++    this.active = false
--        this.attacking = false;
++    this.attacking = false
--        this.attackDelay = isThief ? 120 : random(30, 90); // MUCH shorter initial delay
++    this.attackDelay = isThief ? 120 : random(30, 90) // MUCH shorter initial delay
--
++
--        // Position and movement
++    // Position and movement
--        this.x = random(width);
++    this.x = random(width)
--        this.y = -50; // Start above screen
++    this.y = -50 // Start above screen
--        this.vx = 0;
++    this.vx = 0
--        this.vy = 0;
++    this.vy = 0
--        this.targetX = 0;
++    this.targetX = 0
--        this.targetY = 0;
++    this.targetY = 0
--        this.speed = 5; // Increased from 3
++    this.speed = 5 // Increased from 3
--        this.angle = 0;
++    this.angle = 0
--        this.wingPhase = random(TWO_PI);
++    this.wingPhase = random(TWO_PI)
--
++
--        // Visual properties
++    // Visual properties
--        this.size = isThief ? 25 : 20;
++    this.size = isThief ? 25 : 20
--        this.color = isThief ? color(100, 50, 150) : color(50, 50, 50);
++    this.color = isThief ? color(100, 50, 150) : color(50, 50, 50)
--
++
--        // Pattern-specific properties
++    // Pattern-specific properties
--        if (pattern === 'circle') {
++    if (pattern === 'circle') {
--            this.circleRadius = 150;
++      this.circleRadius = 150
--            this.circleAngle = 0;
++      this.circleAngle = 0
--            this.circleCenter = createVector(width/2, height/2);
++      this.circleCenter = createVector(width / 2, height / 2)
--        }
--
--        // 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() {
++    // Attack properties - MUCH MORE AGGRESSIVE
--        // Update wing animation
++    this.diveSpeed = 12 // Increased from 8
--        this.wingPhase += 0.3; // Faster wing flapping
++    this.retreatSpeed = 6 // Increased from 4
--
++    this.state = 'waiting' // 'waiting', 'approaching', 'attacking', 'retreating'
--        // Countdown to attack - MUCH FASTER
++    this.consecutiveAttacks = 0 // Track multiple attacks
--        if (this.attackDelay > 0) {
++    this.maxConsecutiveAttacks = random(2, 4) // Each bird does 2-4 attacks before retreating
--            this.attackDelay--;
++  }
--            // Hover while waiting - more aggressive hovering
++
--            this.y = -30 + sin(frameCount * 0.08) * 15;
++  update () {
--            this.x += sin(frameCount * 0.05) * 3;
++    // Update wing animation
--
++    this.wingPhase += 0.3 // Faster wing flapping
--            // Show warning when about to attack
++
--            if (this.attackDelay < 30) {
++    // Countdown to attack - MUCH FASTER
--                this.y = lerp(this.y, 50, 0.1); // Start moving into view
++    if (this.attackDelay > 0) {
--            }
++      this.attackDelay--
--            return;
++      // Hover while waiting - more aggressive hovering
--        }
++      this.y = -30 + sin(frameCount * 0.08) * 15
--
++      this.x += sin(frameCount * 0.05) * 3
--        // Activate after delay
++
--        if (!this.active) {
++      // Show warning when about to attack
--            this.active = true;
++      if (this.attackDelay < 30) {
--            this.state = 'approaching';
++        this.y = lerp(this.y, 50, 0.1) // Start moving into view
--            this.updateTarget(); // Set initial target
++      }
--        }
++      return
--
++    }
--        // Execute movement pattern
++
--        switch(this.pattern) {
++    // Activate after delay
--            case 'dive':
++    if (!this.active) {
--                this.executeDivePattern();
++      this.active = true
--                break;
++      this.state = 'approaching'
--            case 'swoop':
++      this.updateTarget() // Set initial target
--                this.executeSwoopPattern();
++    }
--                break;
++
--            case 'glide':
++    // Execute movement pattern
--                this.executeGlidePattern();
++    switch (this.pattern) {
--                break;
++      case 'dive':
--            case 'circle':
++        this.executeDivePattern()
--                this.executeCirclePattern();
++        break
--                break;
++      case 'swoop':
--        }
++        this.executeSwoopPattern()
--
++        break
--        // Check collisions
++      case 'glide':
--        this.checkCollisions();
++        this.executeGlidePattern()
--
++        break
--        // Keep on screen during approach
++      case 'circle':
--        if (this.state === 'approaching') {
++        this.executeCirclePattern()
--            this.x = constrain(this.x, 20, width - 20);
++        break
++    }
++
++    // Check collisions
++    this.checkCollisions()
++
++    // Keep on screen during approach
++    if (this.state === 'approaching') {
++      this.x = constrain(this.x, 20, width - 20)
++    }
++  }
++
++  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
++          }
+         }
++      }
+     }
--
++  }
--    updateTarget() {
++
--        if (this.isThief) {
++  executeDivePattern () {
--            // Target caught flies
++    if (this.state === 'approaching') {
--            let caughtFlies = flies.filter(f => f.stuck || f.caught);
++      // Move into position above target MUCH FASTER
--            if (caughtFlies.length > 0) {
++      let dx = this.targetX - this.x
--                let target = random(caughtFlies);
++      let dy = 50 - this.y // Lower starting position for faster attack
--                this.targetX = target.pos.x;
++
--                this.targetY = target.pos.y;
++      this.x += dx * 0.15 // Much faster positioning
--            } else {
++      this.y += dy * 0.15
--                this.active = false; // No targets, deactivate
++
--                return;
++      // 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') {
++      // IMPROVED: Better tracking dive
++      let dx = this.targetX - this.x
++      let dy = this.targetY - this.y
++
++      // Accelerate toward target with better tracking
++      this.vx = dx * 0.08 // Increased horizontal tracking
++      this.vy = min(this.diveSpeed, this.vy + 1) // Accelerating dive
++
++      this.x += this.vx
++      this.y += this.vy
++
++      // Update target position while diving for better accuracy
++      if (frameCount % 10 === 0) {
++        this.targetX = spider.pos.x
++        this.targetY = spider.pos.y
++      }
++
++      // FIX: Check if we've reached or passed the target
++      // More generous hit detection
++      if (this.y > this.targetY - 10 || 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 {
--            // Heavily favor targeting spider (90% chance)
++          // Finally retreat after multiple attacks
--            if (random() < 0.9) {
++          this.state = 'retreating'
--                // Target spider with prediction
++          this.attacking = false
--                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;
--                    }
--                }
--            }
+         }
++      }
++    } else if (this.state === 'retreating') {
++      // 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(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
++      }
+     }
--
++  }
--    executeDivePattern() {
++
--        if (this.state === 'approaching') {
++  executeSwoopPattern () {
--            // Move into position above target MUCH FASTER
++    if (this.state === 'approaching') {
--            let dx = this.targetX - this.x;
++      // Come from the side FAST
--            let dy = 50 - this.y; // Lower starting position for faster attack
++      if (this.x < 0) {
--
++        this.x += 8 // Faster approach
--            this.x += dx * 0.15; // Much faster positioning
++        this.y = height * 0.3 + sin(this.x * 0.03) * 50
--            this.y += dy * 0.15;
++      } else {
--
++        this.state = 'attacking'
--            // When in position, start diving immediately
++        this.attacking = true
--            if (abs(dx) < 50 && abs(dy) < 30) {
++        this.updateTarget()
--                this.state = 'attacking';
++      }
--                this.attacking = true;
++    } else if (this.state === 'attacking') {
--                this.updateTarget(); // Update target position for more accurate dive
++      // Swoop across screen following sine wave but faster
--            }
++      this.x += 9 // Faster swoop
--        } else if (this.state === 'attacking') {
++      this.y = height * 0.3 + sin(this.x * 0.03) * 120
--            // FAST dive toward target
++
--            let dx = this.targetX - this.x;
++      // Track toward target when close
--            this.vy = this.diveSpeed;
++      if (abs(this.x - this.targetX) < 100) {
--            this.vx = dx * 0.05; // Track horizontally too
++        // Aggressively dive toward target
--            this.x += this.vx;
++        let dy = this.targetY - this.y
--            this.y += this.vy;
++        this.y += dy * 0.2
--
++      }
--            // Hit ground or passed target
++
--            if (this.y > this.targetY + 20 || this.y > height - 50) {
++      // Exit screen
--                this.consecutiveAttacks++;
++      if (this.x > width + 50) {
--
++        this.consecutiveAttacks++
--                // Do multiple attacks before retreating
++
--                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
++        if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
--                    // Quick pull up and attack again
++          // Come back from other side
--                    this.state = 'approaching';
++          this.x = -50
--                    this.attacking = false;
++          this.state = 'approaching'
--                    this.y = min(this.y, height - 100); // Don't go too low
++          this.updateTarget()
--                    this.updateTarget(); // Get new target position
++        } else {
--                } else {
++          this.state = 'retreating'
--                    // Finally retreat after multiple attacks
++          this.attacking = false
--                    this.state = 'retreating';
--                    this.attacking = false;
--                }
--            }
--        } else if (this.state === 'retreating') {
--            // 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(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
--            }
+         }
++      }
++    } else if (this.state === 'retreating') {
++      // Reset
++      this.state = 'approaching'
++      this.attackDelay = random(90, 150)
++      this.x = -50
++      this.consecutiveAttacks = 0
++      this.maxConsecutiveAttacks = random(2, 4)
+     }
--
++  }
--    executeSwoopPattern() {
++
--        if (this.state === 'approaching') {
++  executeGlidePattern () {
--            // Come from the side FAST
++    if (this.state === 'approaching') {
--            if (this.x < 0) {
++      // Glide in from top corner faster
--                this.x += 8; // Faster approach
++      this.x += 5
--                this.y = height * 0.3 + sin(this.x * 0.03) * 50;
++      this.y += 2.5
--            } else {
++
--                this.state = 'attacking';
++      if (this.y > height * 0.15) {
--                this.attacking = true;
++        this.state = 'attacking'
--                this.updateTarget();
++        this.attacking = true
--            }
++        this.updateTarget()
--        } else if (this.state === 'attacking') {
++      }
--            // Swoop across screen following sine wave but faster
++    } else if (this.state === 'attacking') {
--            this.x += 9; // Faster swoop
++      // Glide toward target aggressively
--            this.y = height * 0.3 + sin(this.x * 0.03) * 120;
++      let dx = this.targetX - this.x
--
++      let dy = this.targetY - this.y
--            // Track toward target when close
++      let dist = sqrt(dx * dx + dy * dy)
--            if (abs(this.x - this.targetX) < 100) {
++
--                // Aggressively dive toward target
++      if (dist > 10) {
--                let dy = this.targetY - this.y;
++        this.x += (dx / dist) * 7 // Much faster glide
--                this.y += dy * 0.2;
++        this.y += (dy / dist) * 7
--            }
++      }
--
++
--            // Exit screen
++      // Pass through and maybe attack again
--            if (this.x > width + 50) {
++      if (this.y > height - 100 || this.x < -50 || this.x > width + 50) {
--                this.consecutiveAttacks++;
++        this.consecutiveAttacks++
--
++
--                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
++        if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
--                    // Come back from other side
++          // Reset for another pass
--                    this.x = -50;
++          this.state = 'approaching'
--                    this.state = 'approaching';
++          this.x = random() < 0.5 ? -50 : width + 50
--                    this.updateTarget();
++          this.y = random(50, 150)
--                } else {
++          this.updateTarget()
--                    this.state = 'retreating';
++        } else {
--                    this.attacking = false;
++          this.state = 'retreating'
--                }
++          this.attacking = false
--            }
--        } else if (this.state === 'retreating') {
--            // Reset
--            this.state = 'approaching';
--            this.attackDelay = random(90, 150);
--            this.x = -50;
--            this.consecutiveAttacks = 0;
--            this.maxConsecutiveAttacks = random(2, 4);
+         }
++      }
++    } else if (this.state === 'retreating') {
++      // Continue off screen
++      this.x += this.vx
++      this.y += this.vy
++
++      // Reset
++      if (this.y > height + 50 || this.x < -100 || this.x > width + 100) {
++        this.state = 'approaching'
++        this.attackDelay = random(120, 180)
++        this.x = random() < 0.5 ? -50 : width + 50
++        this.y = random(50, 150)
++        this.vx = this.x < width / 2 ? 5 : -5
++        this.vy = 2.5
++        this.consecutiveAttacks = 0
++        this.maxConsecutiveAttacks = random(2, 4)
++      }
+     }
--
++  }
--    executeGlidePattern() {
++
--        if (this.state === 'approaching') {
++  executeCirclePattern () {
--            // Glide in from top corner faster
++    if (this.state === 'approaching') {
--            this.x += 5;
++      // Move to circle start position
--            this.y += 2.5;
++      let startX = this.circleCenter.x + cos(0) * this.circleRadius
--
++      let startY = this.circleCenter.y + sin(0) * this.circleRadius
--            if (this.y > height * 0.15) {
++
--                this.state = 'attacking';
++      let dx = startX - this.x
--                this.attacking = true;
++      let dy = startY - this.y
--                this.updateTarget();
++
--            }
++      this.x += dx * 0.1
--        } else if (this.state === 'attacking') {
++      this.y += dy * 0.1
--            // Glide toward target aggressively
++
--            let dx = this.targetX - this.x;
++      if (abs(dx) < 20 && abs(dy) < 20) {
--            let dy = this.targetY - this.y;
++        this.state = 'attacking'
--            let dist = sqrt(dx * dx + dy * dy);
++        this.attacking = true
--
++        this.circleAngle = 0
--            if (dist > 10) {
++      }
--                this.x += (dx / dist) * 7; // Much faster glide
++    } else if (this.state === 'attacking') {
--                this.y += (dy / dist) * 7;
++      // Circle around center FASTER
--            }
++      this.circleAngle += 0.08 // Faster circling
--
++      this.x = this.circleCenter.x + cos(this.circleAngle) * this.circleRadius
--            // Pass through and maybe attack again
++      this.y = this.circleCenter.y + sin(this.circleAngle) * this.circleRadius
--            if (this.y > height - 100 || this.x < -50 || this.x > width + 50) {
++
--                this.consecutiveAttacks++;
++      // More frequent dives toward center
--
++      if (frameCount % 60 === 0) {
--                if (this.consecutiveAttacks < this.maxConsecutiveAttacks) {
++        // Every second instead of every 2 seconds
--                    // Reset for another pass
++        this.circleRadius = max(30, this.circleRadius - 50)
--                    this.state = 'approaching';
++      } else {
--                    this.x = random() < 0.5 ? -50 : width + 50;
++        this.circleRadius = min(150, this.circleRadius + 2)
--                    this.y = random(50, 150);
++      }
--                    this.updateTarget();
++
--                } else {
++      // Complete circle faster
--                    this.state = 'retreating';
++      if (this.circleAngle > TWO_PI * 1.5) {
--                    this.attacking = false;
++        // 1.5 circles instead of 2
--                }
++        this.state = 'retreating'
--            }
++        this.attacking = false
--        } else if (this.state === 'retreating') {
++      }
--            // Continue off screen
++    } else if (this.state === 'retreating') {
--            this.x += this.vx;
++      // Fly away
--            this.y += this.vy;
++      this.y -= 7
--
++
--            // Reset
++      if (this.y < -50) {
--            if (this.y > height + 50 || this.x < -100 || this.x > width + 100) {
++        this.state = 'approaching'
--                this.state = 'approaching';
++        this.attackDelay = random(150, 240)
--                this.attackDelay = random(120, 180);
++        this.x = random(width)
--                this.x = random() < 0.5 ? -50 : width + 50;
++      }
--                this.y = random(50, 150);
--                this.vx = this.x < width/2 ? 5 : -5;
--                this.vy = 2.5;
--                this.consecutiveAttacks = 0;
--                this.maxConsecutiveAttacks = random(2, 4);
--            }
--        }
+     }
++  }
++
++checkCollisions() {
++    // FIX: Increased collision radius for more generous hit detection
++    let collisionDistance = this.size + spider.radius + 5; // Added 5 pixel buffer
--    executeCirclePattern() {
++    // Check collision with spider
--        if (this.state === 'approaching') {
++    if (this.attacking && dist(this.x, this.y, spider.pos.x, spider.pos.y) < collisionDistance) {
--            // Move to circle start position
++        // Hit spider!
--            let startX = this.circleCenter.x + cos(0) * this.circleRadius;
++        if (gamePhase === 'DAWN') {
--            let startY = this.circleCenter.y + sin(0) * this.circleRadius;
++            // Calculate damage
++            let damage = 20; // Base damage
--            let dx = startX - this.x;
++            // If spider has no stamina, GAME OVER!
--            let dy = startY - this.y;
++            if (jumpStamina <= 0) {
++                triggerGameOver('Exhausted spider caught by bird!');
++                return;
++            }
--            this.x += dx * 0.1;
++            // Otherwise, reduce stamina
--            this.y += dy * 0.1;
++            jumpStamina = max(0, jumpStamina - damage);
++            stats.birdHitsTaken++;
--            if (abs(dx) < 20 && abs(dy) < 20) {
++            // Knockback effect
--                this.state = 'attacking';
++            spider.vel.x = (spider.pos.x - this.x) * 0.3;
--                this.attacking = true;
++            spider.vel.y = -3;
--                this.circleAngle = 0;
++            spider.isAirborne = true;
--            }
--        } else if (this.state === 'attacking') {
--            // 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;
--            // More frequent dives toward center
++            // Red damage particles
--            if (frameCount % 60 === 0) { // Every second instead of every 2 seconds
++            for (let i = 0; i < 12; i++) {
--                this.circleRadius = max(30, this.circleRadius - 50);
++                let p = new Particle(spider.pos.x, spider.pos.y);
--            } else {
++                p.color = color(255, 50, 50);
--                this.circleRadius = min(150, this.circleRadius + 2);
++                p.vel = createVector(random(-4, 4), random(-4, 1));
++                p.size = random(4, 8);
++                particles.push(p);
+             }
--            // Complete circle faster
++            // Screen shake effect
--            if (this.circleAngle > TWO_PI * 1.5) { // 1.5 circles instead of 2
++            if (typeof screenShake !== 'undefined') {
--                this.state = 'retreating';
++                screenShake = 10;
--                this.attacking = false;
+             }
--        } else if (this.state === 'retreating') {
--            // Fly away
--            this.y -= 7;
--            if (this.y < -50) {
++            // Warning notifications - but limited to prevent spam
--                this.state = 'approaching';
++            if (notifications.length < 3) { // Limit notifications
--                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') {
--                // 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 effect
--                spider.vel.x = (spider.pos.x - this.x) * 0.3;
--                spider.vel.y = -3;
--                spider.isAirborne = true;
--
--                // Red damage particles
--                for (let i = 0; i < 12; i++) {
--                    let p = new Particle(spider.pos.x, spider.pos.y);
--                    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;
+         }
++
++        // Bird bounces off
++        this.state = 'retreating';
++        this.attacking = false;
++    }
      // Check collision with web strands
      if (this.attacking) {

js/game.jsmodified

  let gameOverTimer = 0
  let deathReason = ''
  let finalScore = 0
++let screenShake = 0
  // Resources
  let webSilk = 100
    constructor (text, color) {
      this.text = text
      this.color = color
--    this.y = height * 0.3
--    this.alpha = 255
      this.lifetime = 180 // 3 seconds
++    this.alpha = 255
++
++    // IMPROVED: Stacking system to prevent overlap
++    // Find how many notifications are currently active
++    let activeNotifications = notifications.filter(n => n.lifetime > 60).length
++
++    // Stack notifications vertically
++    this.y = height * 0.3 + activeNotifications * 35 // 35 pixels between notifications
++
++    // Prevent too many notifications
++    if (notifications.length > 5) {
++      notifications.shift() // Remove oldest
++    }
+   }
    update () {
      this.lifetime--
++
++    // Fade out in the last second
      if (this.lifetime < 60) {
        this.alpha = map(this.lifetime, 0, 60, 0, 255)
+     }
--    this.y -= 0.5 // Slowly rise
++
++    // Slowly rise
++    this.y -= 0.3 // Slower rise to maintain readability
+   }
    display () {
      push()
      textAlign(CENTER)
--    textSize(24)
++
--    strokeWeight(4)
++    // Add background for better readability
++    fill(0, 0, 0, this.alpha * 0.5)
++    noStroke()
++    rectMode(CENTER)
++    rect(width / 2, this.y, textWidth(this.text) + 20, 30, 5)
++
++    // Text with outline for visibility
++    textSize(20) // Slightly smaller for less overlap
++    strokeWeight(3)
      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)
++    text(this.text, width / 2, this.y + 5)
      pop()
+   }
      gamePhase = 'DAWN'
      phaseTimer = 0
--    // ENHANCED: Calculate dawn stamina with CLEAR BONUS DISPLAY
++    // Calculate dawn stamina with CLEAR BONUS DISPLAY
      let baseStamina = 30
      let flyBonus = fliesMunchedLastNight * 10
--    staminaBonus = flyBonus // Store for display
++    staminaBonus = flyBonus
      maxJumpStamina = baseStamina + flyBonus
--    maxJumpStamina = min(maxJumpStamina, 200) // Cap at 200 instead of 150
++    maxJumpStamina = min(maxJumpStamina, 200)
      jumpStamina = maxJumpStamina
--    // Clear notification showing stamina calculation
++    // IMPROVED: Combine notifications to reduce overlap
--    notifications.push(
++    let staminaMessage = `Dawn: ${maxJumpStamina} stamina (${baseStamina} + ${flyBonus} from ${fliesMunchedLastNight} flies)`
--      new Notification(
++    let warningMessage = ''
--        `Dawn Stamina: ${baseStamina} base + ${flyBonus} (${fliesMunchedLastNight} flies × 10) = ${maxJumpStamina}`,
--        color(255, 200, 100)
--      )
--    )
--    // Warning notifications based on stamina level
      if (maxJumpStamina <= 50) {
++      warningMessage = ' ⚠️ DANGER!'
        notifications.push(
--        new Notification(
++        new Notification(staminaMessage + warningMessage, color(255, 50, 50))
--          '⚠️ DANGER: Very low stamina! Eat more flies next night!',
--          color(255, 50, 50)
--        )
+       )
      } else if (maxJumpStamina <= 80) {
++      warningMessage = ' - Low stamina!'
        notifications.push(
--        new Notification(
++        new Notification(staminaMessage + warningMessage, color(255, 150, 50))
--          'Warning: Low stamina for dawn survival',
--          color(255, 150, 50)
--        )
+       )
      } else if (maxJumpStamina >= 150) {
++      warningMessage = ' - Well fed!'
        notifications.push(
--        new Notification(
++        new Notification(staminaMessage + warningMessage, color(100, 255, 100))
--          'Excellent stamina! Well fed spider!',
--          color(100, 255, 100)
--        )
+       )
++    } else {
++      notifications.push(new Notification(staminaMessage, color(255, 200, 100)))
+     }
      // Spawn birds