`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
 -        ellipse(-wingSpread, 0, 20, 12)
 -        ellipse(wingSpread, 0, 20, 12)
 -        pop()
 +        fill(255, 255, 200, 30 + sin(this.wingPhase * 2) * 20)
 +        ellipse(0, 0, this.radius * 3, this.radius * 2)
+       }
 +      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)
 -      for (let i = 0; i < 3; i++) {
 -        let legY = -this.radius * 0.3 + i * this.radius * 0.3
 -        let legMove = sin(this.wingPhase * 2 + i) * 2
 -        line(-this.radius * 0.8, legY, -this.radius * 1.2 + legMove, legY + 5)
 -        line(this.radius * 0.8, legY, this.radius * 1.2 - legMove, legY + 5)
 -      }
 +      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)
        // 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, 4)
 +      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()

js/game.jsmodified

          obstacles.push(new Obstacle(x, y, 20, 'leaf')); // Use leaf as invisible anchor
+     }
 -    // Create fewer, bigger, quirkier obstacles
 -    let numObstacles = Math.floor((width * height) / 120000); // Much fewer
 -    numObstacles = constrain(numObstacles, 8, 15);
 +    // Create more obstacles for denser coverage
 +    let numObstacles = Math.floor((width * height) / 60000); // More obstacles
 +    numObstacles = constrain(numObstacles, 15, 25);
 -    // Create ant balloons (2-3)
 -    let numBalloons = Math.floor(random(2, 4));
 +    // 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(120, width - 120);
 -            let y = random(80, height * 0.5); // Balloons float in upper half
 -            let radius = random(40, 55); // Bigger
 +            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 + 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)
 -    let numBeetles = Math.floor(random(2, 4));
 +    // 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(100, width - 100);
 -            let y = random(height * 0.3, height * 0.7); // Middle areas
 -            let radius = random(35, 50);
 +            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 + 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
 -    let numLeaves = Math.floor(random(3, 5));
 +    // 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) {
 -            let x = random(80, width - 80);
 -            let y = random(100, height - 150);
 -            let radius = random(30, 40);
 +            // 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 + 60) {
 +                if (dist(x, y, obstacle.x, obstacle.y) < radius + obstacle.radius + 35) {
                      valid = false;
                      break;
+                 }
+         }
+     }
 -    // Add guaranteed edge anchor points (smaller, stable leaves)
 -    obstacles.push(new Obstacle(50, height/2, 25, 'leaf'));
 -    obstacles.push(new Obstacle(width - 50, height/2, 25, 'leaf'));
 -    obstacles.push(new Obstacle(width/2, 60, 25, 'leaf'));
+-
 -    // Bottom anchors for better coverage
 -    if (width > 1000) {
 -        obstacles.push(new Obstacle(width/3, height - 130, 25, 'leaf'));
 -        obstacles.push(new Obstacle(2*width/3, height - 130, 25, 'leaf'));
 +    // 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