zeroed-some/cob / 827e77f

Browse files

webs drift with obstacles

Authored by espadonne
SHA
827e77f157f73f51e9ddd169c8b3f7b999e7a581
Parents
b588850
Tree
1a9a35e

3 changed files

StatusFile+-
M js/entities.js 149 130
M js/game.js 69 30
M js/physics.js 9 0
js/entities.jsmodified
@@ -350,126 +350,133 @@ class Spider {
350350
     this.land()
351351
   }
352352
353
-  land () {
354
-    this.vel.mult(0)
355
-    this.isAirborne = false
356
-    this.canJump = true
353
+land() {
354
+  this.vel.mult(0);
355
+  this.isAirborne = false;
356
+  this.canJump = true;
357
+
358
+  // FIX: Check if we're actually landing on something valid
359
+  let landedOnSomething = false;
360
+  let landingPoint = null; // Store where we're landing for anchor
361
+  let landingObstacle = null; // NEW: Track which obstacle we're landing on
362
+
363
+  // Check if on ground
364
+  if (this.pos.y >= height - this.radius - 5) {
365
+    landedOnSomething = true;
366
+    landingPoint = createVector(this.pos.x, height);
367
+  }
357368
358
-    // FIX: Check if we're actually landing on something valid
359
-    let landedOnSomething = false
360
-    let landingPoint = null // Store where we're landing for anchor
361
-
362
-    // Check if on ground
363
-    if (this.pos.y >= height - this.radius - 5) {
364
-      landedOnSomething = true
365
-      landingPoint = createVector(this.pos.x, height)
366
-    }
367
-
368
-    // Check if on an obstacle
369
-    if (!landedOnSomething) {
370
-      for (let obstacle of obstacles) {
371
-        if (this.checkObstacleCollision(obstacle)) {
372
-          landedOnSomething = true
373
-          // Calculate edge point for anchor
374
-          let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x)
375
-          landingPoint = createVector(
376
-            obstacle.x + cos(angle) * obstacle.radius,
377
-            obstacle.y + sin(angle) * obstacle.radius
378
-          )
379
-          break
380
-        }
369
+  // Check if on an obstacle
370
+  if (!landedOnSomething) {
371
+    for (let obstacle of obstacles) {
372
+      if (this.checkObstacleCollision(obstacle)) {
373
+        landedOnSomething = true;
374
+        landingObstacle = obstacle; // NEW: Store the obstacle
375
+        // Calculate edge point for anchor
376
+        let angle = atan2(this.pos.y - obstacle.y, this.pos.x - obstacle.x);
377
+        landingPoint = createVector(
378
+          obstacle.x + cos(angle) * obstacle.radius,
379
+          obstacle.y + sin(angle) * obstacle.radius
380
+        );
381
+        break;
381382
       }
382383
     }
384
+  }
383385
384
-    // Check if on a web strand
385
-    if (!landedOnSomething) {
386
-      for (let strand of webStrands) {
387
-        if (
388
-          strand !== currentStrand &&
389
-          !strand.broken &&
390
-          this.checkStrandCollision(strand)
391
-        ) {
392
-          landedOnSomething = true
393
-          // For web strands, use spider position as anchor
394
-          landingPoint = this.pos.copy()
395
-          break
396
-        }
386
+  // Check if on a web strand
387
+  if (!landedOnSomething) {
388
+    for (let strand of webStrands) {
389
+      if (strand !== currentStrand && !strand.broken && this.checkStrandCollision(strand)) {
390
+        landedOnSomething = true;
391
+        // For web strands, use spider position as anchor
392
+        landingPoint = this.pos.copy();
393
+        break;
397394
       }
398395
     }
396
+  }
399397
400
-    // Check if on home branch
401
-    if (!landedOnSomething && window.homeBranch) {
402
-      let branch = window.homeBranch
403
-      let branchStart = Math.min(branch.startX, branch.endX)
404
-      let branchEnd = Math.max(branch.startX, branch.endX)
405
-
406
-      if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
407
-        let t = (this.pos.x - branchStart) / (branchEnd - branchStart)
408
-        t = constrain(t, 0, 1)
409
-        let branchTopThickness = lerp(
410
-          branch.thickness * 0.9,
411
-          branch.thickness * 0.35,
412
-          t
413
-        )
414
-        let branchSurfaceY = branch.y - branchTopThickness
415
-        let angleCorrection = (this.pos.x - branchStart) * branch.angle
416
-        branchSurfaceY += angleCorrection
417
-
418
-        if (abs(this.pos.y - branchSurfaceY) < this.radius + 10) {
419
-          landedOnSomething = true
420
-          landingPoint = createVector(this.pos.x, branchSurfaceY)
421
-        }
398
+  // Check if on home branch
399
+  if (!landedOnSomething && window.homeBranch) {
400
+    let branch = window.homeBranch;
401
+    let branchStart = Math.min(branch.startX, branch.endX);
402
+    let branchEnd = Math.max(branch.startX, branch.endX);
403
+
404
+    if (this.pos.x >= branchStart - 10 && this.pos.x <= branchEnd + 10) {
405
+      let t = (this.pos.x - branchStart) / (branchEnd - branchStart);
406
+      t = constrain(t, 0, 1);
407
+      let branchTopThickness = lerp(branch.thickness * 0.9, branch.thickness * 0.35, t);
408
+      let branchSurfaceY = branch.y - branchTopThickness;
409
+      let angleCorrection = (this.pos.x - branchStart) * branch.angle;
410
+      branchSurfaceY += angleCorrection;
411
+
412
+      if (abs(this.pos.y - branchSurfaceY) < this.radius + 10) {
413
+        landedOnSomething = true;
414
+        landingPoint = createVector(this.pos.x, branchSurfaceY);
422415
       }
423416
     }
417
+  }
424418
425
-    // FIX: If we're deploying web but didn't land on anything valid, destroy the web
426
-    if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
427
-      if (landedOnSomething && landingPoint) {
428
-        // Valid landing - finalize the web at the landing point
429
-        currentStrand.end = landingPoint.copy() // Use edge point, not spider center
430
-        if (!currentStrand.path || currentStrand.path.length === 0) {
431
-          currentStrand.path = [landingPoint.copy()]
432
-        } else {
433
-          currentStrand.path.push(landingPoint.copy())
434
-        }
435
-        webNodes.push(new WebNode(landingPoint.x, landingPoint.y))
436
-
437
-        // Update last anchor for next web
438
-        this.lastAnchorPoint = landingPoint.copy()
419
+  // FIX: If we're deploying web but didn't land on anything valid, destroy the web
420
+  if (currentStrand && isDeployingWeb && (spacePressed || touchHolding)) {
421
+    if (landedOnSomething && landingPoint) {
422
+      // Valid landing - finalize the web at the landing point
423
+      currentStrand.end = landingPoint.copy(); // Use edge point, not spider center
424
+
425
+      // NEW: Track obstacle attachment for the end point
426
+      if (landingObstacle) {
427
+        currentStrand.endObstacle = landingObstacle;
428
+        currentStrand.endAngle = atan2(
429
+          landingPoint.y - landingObstacle.y,
430
+          landingPoint.x - landingObstacle.x
431
+        );
432
+      }
433
+
434
+      if (!currentStrand.path || currentStrand.path.length === 0) {
435
+        currentStrand.path = [landingPoint.copy()];
439436
       } else {
440
-        // Invalid landing in mid-air - destroy the web!
441
-        if (
442
-          webStrands.length > 0 &&
443
-          webStrands[webStrands.length - 1] === currentStrand
444
-        ) {
445
-          webStrands.pop() // Remove the invalid strand
437
+        currentStrand.path.push(landingPoint.copy());
438
+      }
439
+
440
+      let newNode = new WebNode(landingPoint.x, landingPoint.y);
441
+      // NEW: Track node attachment
442
+      if (landingObstacle) {
443
+        newNode.attachedObstacle = landingObstacle;
444
+        newNode.attachmentAngle = currentStrand.endAngle;
445
+      }
446
+      webNodes.push(newNode);
446447
447
-          // Create poof particles
448
-          for (let i = 0; i < 8; i++) {
449
-            let p = new Particle(this.pos.x, this.pos.y)
450
-            p.color = color(255, 255, 255, 150)
451
-            p.vel = createVector(random(-3, 3), random(-3, 3))
452
-            p.size = 4
453
-            particles.push(p)
454
-          }
448
+      // Update last anchor for next web
449
+      this.lastAnchorPoint = landingPoint.copy();
450
+    } else {
451
+      // Invalid landing in mid-air - destroy the web!
452
+      if (webStrands.length > 0 && webStrands[webStrands.length - 1] === currentStrand) {
453
+        webStrands.pop(); // Remove the invalid strand
455454
456
-          // Notification
457
-          if (notifications.length < 3) {
458
-            notifications.push(
459
-              new Notification('Web needs anchor point!', color(255, 150, 150))
460
-            )
461
-          }
455
+        // Create poof particles
456
+        for (let i = 0; i < 8; i++) {
457
+          let p = new Particle(this.pos.x, this.pos.y);
458
+          p.color = color(255, 255, 255, 150);
459
+          p.vel = createVector(random(-3, 3), random(-3, 3));
460
+          p.size = 4;
461
+          particles.push(p);
462
+        }
463
+
464
+        // Notification
465
+        if (notifications.length < 3) {
466
+          notifications.push(new Notification("Web needs anchor point!", color(255, 150, 150)));
462467
         }
463468
       }
464
-    } else if (landedOnSomething && landingPoint) {
465
-      // Update last anchor point even when not deploying web
466
-      this.lastAnchorPoint = landingPoint.copy()
467469
     }
468
-
469
-    currentStrand = null
470
-    isDeployingWeb = false
470
+  } else if (landedOnSomething && landingPoint) {
471
+    // Update last anchor point even when not deploying web
472
+    this.lastAnchorPoint = landingPoint.copy();
471473
   }
472474
475
+  currentStrand = null;
476
+  isDeployingWeb = false;
477
+}
478
+
479
+
473480
   display () {
474481
     push()
475482
     translate(this.pos.x, this.pos.y)
@@ -904,38 +911,50 @@ class Obstacle {
904911
     }
905912
   }
906913
907
-  updateAttachedStrands () {
908
-    // Update web strands that are connected to this obstacle
909
-    for (let strand of webStrands) {
910
-      // Check if strand starts near this obstacle's edge
911
-      let startDist = dist(strand.start.x, strand.start.y, this.x, this.y)
912
-      if (startDist >= this.radius - 5 && startDist <= this.radius + 15) {
913
-        // Strand is attached to edge - update to maintain edge connection
914
-        let angle = atan2(strand.start.y - this.y, strand.start.x - this.x)
915
-        strand.start.x = this.x + cos(angle) * this.radius
916
-        strand.start.y = this.y + sin(angle) * this.radius
917
-        if (strand.path && strand.path.length > 0) {
918
-          strand.path[0].x = strand.start.x
919
-          strand.path[0].y = strand.start.y
920
-        }
914
+updateAttachedStrands() {
915
+  // Update web strands that are connected to this obstacle
916
+  for (let strand of webStrands) {
917
+    if (!strand || strand.broken) continue;
918
+
919
+    // Check if strand starts at this obstacle
920
+    if (strand.startObstacle === this) {
921
+      // Update the start position to maintain the attachment
922
+      let angle = strand.startAngle; // Use stored angle
923
+      strand.start.x = this.x + cos(angle) * this.radius;
924
+      strand.start.y = this.y + sin(angle) * this.radius;
925
+
926
+      // Update path if it exists
927
+      if (strand.path && strand.path.length > 0) {
928
+        strand.path[0].x = strand.start.x;
929
+        strand.path[0].y = strand.start.y;
921930
       }
922
-
923
-      // Check if strand ends near this obstacle's edge
924
-      if (strand.end) {
925
-        let endDist = dist(strand.end.x, strand.end.y, this.x, this.y)
926
-        if (endDist >= this.radius - 5 && endDist <= this.radius + 15) {
927
-          // Strand is attached to edge - update to maintain edge connection
928
-          let angle = atan2(strand.end.y - this.y, strand.end.x - this.x)
929
-          strand.end.x = this.x + cos(angle) * this.radius
930
-          strand.end.y = this.y + sin(angle) * this.radius
931
-          if (strand.path && strand.path.length > 0) {
932
-            strand.path[strand.path.length - 1].x = strand.end.x
933
-            strand.path[strand.path.length - 1].y = strand.end.y
934
-          }
935
-        }
931
+    }
932
+
933
+    // Check if strand ends at this obstacle
934
+    if (strand.endObstacle === this) {
935
+      // Update the end position to maintain the attachment
936
+      let angle = strand.endAngle; // Use stored angle
937
+      strand.end.x = this.x + cos(angle) * this.radius;
938
+      strand.end.y = this.y + sin(angle) * this.radius;
939
+
940
+      // Update path if it exists
941
+      if (strand.path && strand.path.length > 0) {
942
+        strand.path[strand.path.length - 1].x = strand.end.x;
943
+        strand.path[strand.path.length - 1].y = strand.end.y;
936944
       }
937945
     }
938946
   }
947
+
948
+  // Also update web nodes attached to this obstacle
949
+  for (let node of webNodes) {
950
+    if (node.attachedObstacle === this) {
951
+      let angle = node.attachmentAngle;
952
+      node.x = this.x + cos(angle) * this.radius;
953
+      node.y = this.y + sin(angle) * this.radius;
954
+    }
955
+  }
956
+}
957
+
939958
940959
   breakAttachedStrands () {
941960
     // Check for strands attached to this obstacle's edge
js/game.jsmodified
@@ -2509,29 +2509,50 @@ function updateResources () {
25092509
   }
25102510
 }
25112511
2512
-function handleWebDeployment () {
2512
+function handleWebDeployment() {
25132513
   // Handle keyboard-based web deployment
25142514
   if (spacePressed && spider.isAirborne && !isDeployingWeb && webSilk > 10) {
2515
-    isDeployingWeb = true
2516
-    currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
2517
-    currentStrand.path = [spider.lastAnchorPoint.copy()]
2518
-    webStrands.push(currentStrand)
2519
-    webNodes.push(
2520
-      new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y)
2521
-    )
2515
+    isDeployingWeb = true;
2516
+    currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null);
2517
+    currentStrand.path = [spider.lastAnchorPoint.copy()];
2518
+
2519
+    // NEW: Check if starting from an obstacle
2520
+    for (let obstacle of obstacles) {
2521
+      let d = dist(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y, obstacle.x, obstacle.y);
2522
+      // Check if anchor is on obstacle edge (within tolerance)
2523
+      if (abs(d - obstacle.radius) < 10) {
2524
+        currentStrand.startObstacle = obstacle;
2525
+        currentStrand.startAngle = atan2(
2526
+          spider.lastAnchorPoint.y - obstacle.y,
2527
+          spider.lastAnchorPoint.x - obstacle.x
2528
+        );
2529
+        break;
2530
+      }
2531
+    }
2532
+
2533
+    webStrands.push(currentStrand);
2534
+
2535
+    let newNode = new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y);
2536
+    // NEW: Track node attachment if on obstacle
2537
+    if (currentStrand.startObstacle) {
2538
+      newNode.attachedObstacle = currentStrand.startObstacle;
2539
+      newNode.attachmentAngle = currentStrand.startAngle;
2540
+    }
2541
+    webNodes.push(newNode);
25222542
   }
25232543
25242544
   // Update web for keyboard controls
25252545
   if (currentStrand && isDeployingWeb && spider.isAirborne && spacePressed) {
2526
-    currentStrand.end = spider.pos.copy()
2546
+    currentStrand.end = spider.pos.copy();
25272547
     if (frameCount % 2 === 0) {
2528
-      currentStrand.path.push(spider.pos.copy())
2548
+      currentStrand.path.push(spider.pos.copy());
25292549
     }
25302550
   }
25312551
25322552
   // Touch-based web deployment is handled in touchMoved()
25332553
 }
25342554
2555
+
25352556
 function updateUI () {
25362557
   // Update control instructions based on device
25372558
   let isMobile =
@@ -3002,40 +3023,58 @@ function recycleNearbyWeb () {
30023023
   }
30033024
 }
30043025
3005
-function touchStarted () {
3026
+function touchStarted() {
30063027
   if (touches.length > 0) {
3007
-    touchStartTime = millis()
3008
-    touchStartX = touches[0].x
3009
-    touchStartY = touches[0].y
3028
+    touchStartTime = millis();
3029
+    touchStartX = touches[0].x;
3030
+    touchStartY = touches[0].y;
30103031
30113032
     // Check for double tap on spider to munch
3012
-    let touchOnSpider =
3013
-      dist(touches[0].x, touches[0].y, spider.pos.x, spider.pos.y) < 30
3033
+    let touchOnSpider = dist(touches[0].x, touches[0].y, spider.pos.x, spider.pos.y) < 30;
30143034
30153035
     if (touchOnSpider && millis() - lastTapTime < 300) {
30163036
       // Double tap detected on spider - MUNCH!
3017
-      spider.munch()
3018
-      lastTapTime = 0 // Reset to prevent triple tap
3037
+      spider.munch();
3038
+      lastTapTime = 0; // Reset to prevent triple tap
30193039
     } else if (!spider.isAirborne) {
30203040
       // Single tap while on ground - jump
3021
-      spider.jump(touches[0].x, touches[0].y)
3022
-      lastTapTime = millis()
3041
+      spider.jump(touches[0].x, touches[0].y);
3042
+      lastTapTime = millis();
30233043
     } else if (spider.isAirborne && webSilk > 10 && !isDeployingWeb) {
30243044
       // Start web deployment if airborne (only if not already deploying)
3025
-      touchHolding = true
3026
-      isDeployingWeb = true
3027
-      currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null)
3028
-      currentStrand.path = [spider.lastAnchorPoint.copy()]
3029
-      webStrands.push(currentStrand)
3030
-      webNodes.push(
3031
-        new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y)
3032
-      )
3045
+      touchHolding = true;
3046
+      isDeployingWeb = true;
3047
+      currentStrand = new WebStrand(spider.lastAnchorPoint.copy(), null);
3048
+      currentStrand.path = [spider.lastAnchorPoint.copy()];
3049
+
3050
+      for (let obstacle of obstacles) {
3051
+        let d = dist(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y, obstacle.x, obstacle.y);
3052
+        // Check if anchor is on obstacle edge (within tolerance)
3053
+        if (abs(d - obstacle.radius) < 10) {
3054
+          currentStrand.startObstacle = obstacle;
3055
+          currentStrand.startAngle = atan2(
3056
+            spider.lastAnchorPoint.y - obstacle.y,
3057
+            spider.lastAnchorPoint.x - obstacle.x
3058
+          );
3059
+          break;
3060
+        }
3061
+      }
3062
+
3063
+      webStrands.push(currentStrand);
3064
+
3065
+      let newNode = new WebNode(spider.lastAnchorPoint.x, spider.lastAnchorPoint.y);
3066
+      // NEW: Track node attachment if on obstacle
3067
+      if (currentStrand.startObstacle) {
3068
+        newNode.attachedObstacle = currentStrand.startObstacle;
3069
+        newNode.attachmentAngle = currentStrand.startAngle;
3070
+      }
3071
+      webNodes.push(newNode);
30333072
     } else if (spider.isAirborne && isDeployingWeb) {
30343073
       // If already deploying and user taps again, just continue (don't create new strand)
3035
-      touchHolding = true
3074
+      touchHolding = true;
30363075
     }
30373076
   }
3038
-  return false // Prevent default
3077
+  return false; // Prevent default
30393078
 }
30403079
30413080
 function touchMoved () {
js/physics.jsmodified
@@ -16,6 +16,12 @@ class WebStrand {
1616
         this.damping = 0.75; // Damping factor for recoil (much faster damping to prevent accumulation)
1717
         this.springConstant = 0.04; // Spring stiffness (much softer spring)
1818
         this.flexibility = 1.0; // How much the web can be dragged by flies
19
+
20
+        // NEW: Track obstacle attachments
21
+        this.startObstacle = null;
22
+        this.startAngle = 0;
23
+        this.endObstacle = null;
24
+        this.endAngle = 0;
1925
     }
2026
2127
     update() {
@@ -254,6 +260,9 @@ class WebNode {
254260
         this.vx = 0;
255261
         this.vy = 0;
256262
         this.pinned = false;
263
+
264
+        this.attachedObstacle = null;
265
+        this.attachmentAngle = 0;
257266
     }
258267
259268
     applyForce(fx, fy) {