`3a2c3d0`

better handling web drift

Authored by

espadonne 8 months ago

SHA: 3a2c3d0ed38136c68e45c79b65aa84d422a9c9f0
Parents: 5fa41f1
Tree: 71a4e73

2 changed files

Status	File	+	-
M	`js/entities.js`	70	20
M	`js/game.js`	61	32

js/entities.jsmodified

      this.maxSpeed = 15
      this.munchRadius = 20
      this.munchCooldown = 0
++    this.attachedObstacle = null // Track which obstacle spider is on
+   }
    jump(targetX, targetY) {
+   }
    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)
++      // 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)
++    }
++
      if (this.isAirborne) {
        this.acc.add(this.gravity)
++      this.attachedObstacle = null // Clear attachment when jumping
+     }
      this.vel.add(this.acc)
      if (this.pos.y >= height - this.radius) {
        this.pos.y = height - this.radius
        this.land()
++      this.attachedObstacle = null
+     }
      // Check wall collisions
            // Place spider on the branch surface
            this.pos.y = branchSurfaceY - this.radius
            this.land()
++          this.attachedObstacle = null
+         }
+       }
+     }
      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()
+   }
        p5.Vector.mult(line, projLength)
+     )
      this.pos = closestPoint
++    this.attachedObstacle = null // Not on an obstacle
      this.land()
+   }
        pop()
      } else if (this.type === 'beetle') {
--      // Big beetle!
++      // Big floating beetle!
        push()
        rotate(this.rotation)
        fill(0, 0, 0, 40)
        ellipse(3, 3, this.radius * 1.8, this.radius * 2.2)
--      // Wings (if flying at night)
++      // Wings - always visible and flapping since they're floating
++      push()
++      // Wing flap animation
++      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)
++      // Wing details
++      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)
++      // Wing details
++      noStroke()
++      fill(200, 200, 200, 80)
++      ellipse(wingSpread * 0.6, 0, wingSpread * 0.8, 10)
++      pop()
++
++      // Extra glow at night
        if (gamePhase === 'NIGHT') {
--        push()
--        fill(255, 255, 255, 100 + sin(this.wingPhase) * 50)
          noStroke()
--        let wingSpread = sin(this.wingPhase) * 15
++        fill(255, 255, 200, 30 + sin(this.wingPhase * 2) * 20)
--        ellipse(-wingSpread, 0, 20, 12)
++        ellipse(0, 0, this.radius * 3, this.radius * 2)
--        ellipse(wingSpread, 0, 20, 12)
--        pop()
+       }
++      pop()
--      // Main beetle body
++      // Main beetle body (on top of wings)
        fill(red(this.beetleColor), green(this.beetleColor), blue(this.beetleColor))
        stroke(0)
        strokeWeight(2)
        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)
--      // Legs
++      // No legs - they're flying!
++      // Just small leg stubs tucked under the body
        stroke(0)
--      strokeWeight(2)
++      strokeWeight(1)
--      for (let i = 0; i < 3; i++) {
++      // Tiny tucked legs
--        let legY = -this.radius * 0.3 + i * this.radius * 0.3
++      line(-this.radius * 0.5, -this.radius * 0.2, -this.radius * 0.6, -this.radius * 0.1)
--        let legMove = sin(this.wingPhase * 2 + i) * 2
++      line(this.radius * 0.5, -this.radius * 0.2, this.radius * 0.6, -this.radius * 0.1)
--        line(-this.radius * 0.8, legY, -this.radius * 1.2 + legMove, legY + 5)
++      line(-this.radius * 0.5, this.radius * 0.2, -this.radius * 0.6, this.radius * 0.1)
--        line(this.radius * 0.8, legY, this.radius * 1.2 - legMove, legY + 5)
++      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)
--      // Eyes
++      // Eyes (bigger and more prominent)
        fill(255, 0, 0)
        noStroke()
--      ellipse(-5, -this.radius * 0.7, 4)
++      ellipse(-5, -this.radius * 0.7, 5)
--      ellipse(5, -this.radius * 0.7, 4)
++      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()

js/game.jsmodified

          obstacles.push(new Obstacle(x, y, 20, 'leaf')); // Use leaf as invisible anchor
+     }
--    // Create fewer, bigger, quirkier obstacles
++    // Create more obstacles for denser coverage
--    let numObstacles = Math.floor((width * height) / 120000); // Much fewer
++    let numObstacles = Math.floor((width * height) / 60000); // More obstacles
--    numObstacles = constrain(numObstacles, 8, 15);
++    numObstacles = constrain(numObstacles, 15, 25);
--    // Create ant balloons (2-3)
++    // Create ant balloons (4-6)
--    let numBalloons = Math.floor(random(2, 4));
++    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(120, width - 120);
++            let x = random(80, width - 80);
--            let y = random(80, height * 0.5); // Balloons float in upper half
++            let y = random(60, height * 0.55); // Balloons float in upper half
--            let radius = random(40, 55); // Bigger
++            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 + 80) {
++                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 + 50) {
++                if (Math.abs(y - branchY) < radius + 35) {
                      valid = false;
+                 }
+             }
+         }
+     }
--    // Create beetles (2-3)
++    // Create beetles (3-5)
--    let numBeetles = Math.floor(random(2, 4));
++    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(100, width - 100);
++            let x = random(70, width - 70);
--            let y = random(height * 0.3, height * 0.7); // Middle areas
++            let y = random(height * 0.2, height * 0.8); // Spread throughout middle/lower
--            let radius = random(35, 50);
++            let radius = random(30, 40);
              let valid = true;
              for (let obstacle of obstacles) {
--                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 70) {
++                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 + 40) {
++                if (Math.abs(y - branchY) < radius + 30) {
                      valid = false;
+                 }
+             }
+         }
+     }
--    // Create leaves (3-4) for more stable anchor points
++    // Create LOTS of leaves (8-12) for excellent hopping coverage
--    let numLeaves = Math.floor(random(3, 5));
++    let numLeaves = Math.floor(random(8, 13));
      for (let i = 0; i < numLeaves; i++) {
          let attempts = 0;
          let placed = false;
          while (!placed && attempts < 30) {
--            let x = random(80, width - 80);
++            // Distribute leaves more evenly across the screen
--            let y = random(100, height - 150);
++            let gridX = (i % 4) * (width / 4) + random(50, width/4 - 50);
--            let radius = random(30, 40);
++            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 + 60) {
++                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 35) {
                      valid = false;
                      break;
+                 }
+         }
+     }
--    // Add guaranteed edge anchor points (smaller, stable leaves)
++    // Add even more guaranteed coverage points (smaller leaves)
--    obstacles.push(new Obstacle(50, height/2, 25, 'leaf'));
++    // Corners
--    obstacles.push(new Obstacle(width - 50, height/2, 25, 'leaf'));
++    obstacles.push(new Obstacle(50, 80, 18, 'leaf'));
--    obstacles.push(new Obstacle(width/2, 60, 25, 'leaf'));
++    obstacles.push(new Obstacle(width - 50, 80, 18, 'leaf'));
--
++    obstacles.push(new Obstacle(50, height - 100, 18, 'leaf'));
--    // Bottom anchors for better coverage
++    obstacles.push(new Obstacle(width - 50, height - 100, 18, 'leaf'));
--    if (width > 1000) {
++
--        obstacles.push(new Obstacle(width/3, height - 130, 25, 'leaf'));
++    // Edge midpoints
--        obstacles.push(new Obstacle(2*width/3, height - 130, 25, 'leaf'));
++    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