`e0cda7f`

some better web physics

Authored by

espadonne 8 months ago

SHA: e0cda7f63cf8d96c0b4be85a24473f659eaec90b
Parents: 80c0bbb
Tree: d9ef3da

3 changed files

Status	File	+	-
M	`js/entities.js`	48	2
M	`js/game.js`	1	1
M	`js/physics.js`	55	1

js/entities.jsmodified

          this.munchCooldown = 0;
+     }
 -    jump(targetX, targetY) {
 +jump(targetX, targetY) {
          if (!this.canJump) return;
          let direction = createVector(targetX - this.pos.x, targetY - this.pos.y);
 +        let clickDistance = direction.mag();
          direction.normalize();
 -        direction.mult(this.jumpPower);
++
 +        // 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();
++
 +        // Check if we're jumping off a web strand
 +        for (let strand of webStrands) {
 +            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
++
 +                // Apply appropriate recoil based on movement type
 +                if (isShimmy) {
 +                    // Trigger shimmy visual effect
 +                    this.shimmyEffect = 20;
++
 +                    // NO recoil at all for shimmying - just tiny vibration
 +                    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);
 +                } else {
 +                    // Scale recoil based on actual jump power
 +                    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);
 +                    }
 +                }
++
 +                break;
 +            }
 +        }
+     }
      munch() {

js/game.jsmodified

      // Place spider on top of the visual branch at the tip (8 is spider radius)
      spider = new Spider(spiderStartX, branchSurfaceY - 8);
+-
++
      // Add invisible obstacles along the branch for web anchor points
      let numBranchAnchors = 3;
      for (let i = 0; i < numBranchAnchors; i++) {

js/physics.jsmodified

          this.vibration = 0;
          this.path = [];
          this.segments = []; // For physics simulation
 -        this.maxLength = 200; // Maximum strand length before it breaks
 +        this.maxLength = 260; // Maximum strand length before it breaks (increased by 30%)
          this.tension = 0;
          this.broken = false;
 +        this.recoil = 0; // Recoil amplitude for spring physics
 +        this.recoilVelocity = 0; // Velocity of recoil oscillation
 +        this.damping = 0.75; // Damping factor for recoil (much faster damping to prevent accumulation)
 +        this.springConstant = 0.04; // Spring stiffness (much softer spring)
 +        this.flexibility = 1.0; // How much the web can be dragged by flies
+     }
      update() {
          this.vibration *= 0.95;
 +        // Update recoil physics (spring oscillation)
 +        if (abs(this.recoil) > 0.01 || abs(this.recoilVelocity) > 0.01) {
 +            // Apply spring force (Hooke's law)
 +            let springForce = -this.springConstant * this.recoil;
 +            this.recoilVelocity += springForce;
++
 +            // Apply damping
 +            this.recoilVelocity *= this.damping;
++
 +            // Update recoil position
 +            this.recoil += this.recoilVelocity;
++
 +            // Clamp small values to stop oscillation
 +            if (abs(this.recoil) < 0.01 && abs(this.recoilVelocity) < 0.01) {
 +                this.recoil = 0;
 +                this.recoilVelocity = 0;
 +            }
 +        }
++
          // Calculate strand length and tension
          if (this.end) {
              let length = dist(this.start.x, this.start.y, this.end.x, this.end.y);
              this.tension = length / this.maxLength;
 +            // Calculate flexibility factor (longer, less taut webs are more flexible)
 +            this.flexibility = map(this.tension, 0.2, 1.0, 1.5, 0.3); // More flexible when less taut
 +            this.flexibility = constrain(this.flexibility, 0.3, 1.5);
++
              // Break if overstretched or unsupported arc
              if (this.tension > 1.5 || this.checkUnsupportedArc()) {
                  this.broken = true;
                      point.y += 0.22;
                      point.x += windX * (0.6 + i / this.path.length * 0.8);
                      point.y += windY * 0.4;
++
 +                    // Apply recoil to path points (very subtle)
 +                    point.y += this.recoil * (1 + sin(i * 0.3) * 0.5);
+                 }
+             }
              let sag = horizontalDist * 0.12;
              midY += sag * (1 - cos(PI * 0.5));
 +            // Apply recoil deformation to the web (very subtle)
 +            midY += this.recoil * 2; // Further reduced from 3
++
              beginShape();
              curveVertex(this.start.x, this.start.y);
              curveVertex(this.start.x, this.start.y);
      vibrate(amount) {
          this.vibration = min(this.vibration + amount, 10);
+     }
++
 +    // Apply recoil force when spider interacts with the web
 +    applyRecoil(force) {
 +        // Newton's third law - the web recoils opposite to the applied force
 +        this.recoilVelocity += force;
++
 +        // Also trigger vibration for visual feedback (scaled down)
 +        this.vibrate(abs(force) * 1);
++
 +        // Add some energy dissipation through the web network (more subtle)
 +        for (let node of webNodes) {
 +            let d1 = dist(node.x, node.y, this.start.x, this.start.y);
 +            let d2 = dist(node.x, node.y, this.end.x, this.end.y);
 +            let minDist = min(d1, d2);
 +            if (minDist < 100) {
 +                let forceFalloff = map(minDist, 0, 100, 0.3, 0);
 +                node.applyForce(0, force * forceFalloff * 0.15);
 +            }
 +        }
 +    }
+ }