feat(player): enhance movement mechanics with sliding, jump buffering, and wall bounce features

src/config.js

@@ -26,7 +26,28 @@ export const CFG = {
     health: 100,
     jumpVel: 5,
     eyeHeight: 1.8,
-    crouchEyeHeight: 1.2
+    crouchEyeHeight: 1.2,
+    // Apex-like movement tuning
+    move: {
+      friction: 5.5,           // ground friction (~4-6)
+      stopSpeed: 6.0,          // speed where friction clamps (m/s)
+      groundAccel: 11.0,       // ground acceleration
+      airAccel: 18.0,          // air acceleration (allow redirection)
+      gravity: 15.0,           // matches prior gravity
+      jumpSpeed: 5.0,          // vertical impulse (mirrors jumpVel)
+      airSpeedCap: 10.0,       // optional cap on sideways air accel
+      // Sliding
+      slideFriction: 1.2,      // lower than ground friction
+      slideAccel: 10.0,
+      slideMinSpeed: 6.0,      // enter slide when crouch and >= this speed
+      slideJumpBoost: 1.0,     // forward boost on slide-jump (m/s)
+      // Helpers
+      jumpBuffer: 0.12,        // seconds to buffer jump presses
+      coyoteTime: 0.12,        // late jump after leaving ground
+      // Wall bounce
+      wallBounceWindow: 0.10,  // seconds after wall contact to accept jump
+      wallBounceImpulse: 1.2   // outward push on wall bounce (m/s)
+    }
   },
   flashlight: {
     on: true,

src/events.js

@@ -15,6 +15,9 @@ export function setupEvents({ startGame, restartGame, beginReload, updateWeaponA
       G.controls.lock();
     } else if (G.state === 'paused') {
       G.controls.lock();
+    } else if (G.state === 'gameover') {
+      // Restart on click after game over
+      restartGame();
     }
   });
 
@@ -24,6 +27,9 @@ export function setupEvents({ startGame, restartGame, beginReload, updateWeaponA
     } else if (G.state === 'paused') {
       G.state = 'playing';
       overlay.classList.add('hidden');
+    } else if (G.state === 'gameover') {
+      // Treat lock like a fresh start after game over
+      startGame();
     }
   });
 
@@ -49,10 +55,9 @@ export function setupEvents({ startGame, restartGame, beginReload, updateWeaponA
         }
         break;
       case 'Space':
-        if (G.state === 'playing' && G.player.grounded) {
-          // Jump
-          G.player.yVel = CFG.player.jumpVel;
-          G.player.grounded = false;
+        if (G.state === 'playing') {
+          // Use buffered jump handled in player physics
+          G.input.jump = true;
         }
         break;
       case 'KeyF':
@@ -69,8 +74,6 @@ export function setupEvents({ startGame, restartGame, beginReload, updateWeaponA
       case 'KeyR':
         if (G.state === 'playing') {
           beginReload();
-        } else if (G.state === 'gameover') {
-          restartGame();
         }
         break;
     }
@@ -90,6 +93,9 @@ export function setupEvents({ startGame, restartGame, beginReload, updateWeaponA
           releaseGrenade();
         }
         break;
+      case 'Space':
+        G.input.jump = false;
+        break;
     }
   });
 

src/hud.js

@@ -92,7 +92,7 @@ export function showOverlay(type) {
       <h1>You Died</h1>
       <p>Score: ${G.player.score}</p>
       <p>Wave: ${G.waves.current}</p>
-      <p>Press R to Restart</p>
+      <p>Click to Restart</p>
     `;
   }
 }

src/main.js

@@ -65,7 +65,14 @@ function init() {
     alive: true,
     score: 0,
     yVel: 0,
-    grounded: true
+    grounded: true,
+    // Apex-like movement state
+    sliding: false,
+    jumpBuffer: 0,
+    coyoteTimer: 0,
+    lastWallNormal: new THREE.Vector3(),
+    wallContactTimer: 0
+    , jumpHeld: false
   };
   G.weapon.ammo = CFG.gun.magSize;
   G.weapon.reserve = Infinity;
@@ -105,6 +112,13 @@ function startGame() {
   G.player.alive = true;
   G.player.pos.set(0, getTerrainHeight(0, 0) + (CFG.player.eyeHeight || 1.8), 0);
   G.player.vel.set(0, 0, 0);
+  G.player.yVel = 0;
+  G.player.grounded = true;
+  G.player.sliding = false;
+  G.player.jumpBuffer = 0;
+  G.player.coyoteTimer = 0;
+  G.player.lastWallNormal.set(0, 0, 0);
+  G.player.wallContactTimer = 0;
   G.camera.position.copy(G.player.pos);
   G.damageFlash = 0;
   G.healFlash = 0;

src/player.js

@@ -3,82 +3,191 @@ import { CFG } from './config.js';
 import { G } from './globals.js';
 import { getTerrainHeight, getNearbyTrees } from './world.js';
 
-const MOVE = new THREE.Vector3();
+// Working vectors
 const FWD = new THREE.Vector3();
 const RIGHT = new THREE.Vector3();
 const NEXT = new THREE.Vector3();
 const PREV = new THREE.Vector3();
 
+// Helpers implementing Quake/Source-like movement in XZ plane
+function applyFriction(vel, friction, stopSpeed, dt) {
+  const vx = vel.x, vz = vel.z;
+  const speed = Math.hypot(vx, vz);
+  if (speed <= 0.0001) return;
+  const control = Math.max(speed, stopSpeed);
+  const drop = control * friction * dt;
+  const newSpeed = Math.max(0, speed - drop);
+  if (newSpeed !== speed) {
+    const k = newSpeed / speed;
+    vel.x *= k;
+    vel.z *= k;
+  }
+}
+
+function accelerate(vel, wishDir, wishSpeed, accel, dt) {
+  const current = vel.x * wishDir.x + vel.z * wishDir.z;
+  let add = wishSpeed - current;
+  if (add <= 0) return;
+  const push = Math.min(accel * wishSpeed * dt, add);
+  vel.x += wishDir.x * push;
+  vel.z += wishDir.z * push;
+}
+
+function airAccelerate(vel, wishDir, wishSpeedCap, airAccel, dt) {
+  const current = vel.x * wishDir.x + vel.z * wishDir.z;
+  const wishSpeed = Math.min(wishSpeedCap, Math.hypot(wishDir.x, wishDir.z) > 0 ? wishSpeedCap : 0);
+  let add = wishSpeed - current;
+  if (add <= 0) return;
+  const push = Math.min(airAccel * wishSpeed * dt, add);
+  vel.x += wishDir.x * push;
+  vel.z += wishDir.z * push;
+}
+
 export function updatePlayer(delta) {
   if (!G.player.alive) return;
 
-  // Movement
-  MOVE.set(0, 0, 0);
+  const P = G.player;
+  const M = CFG.player.move;
 
+  // Forward/right in the horizontal plane
   G.camera.getWorldDirection(FWD);
-  FWD.y = 0;
-  FWD.normalize();
+  FWD.y = 0; FWD.normalize();
+  RIGHT.crossVectors(FWD, G.camera.up).normalize();
 
-  RIGHT.crossVectors(FWD, G.camera.up);
+  // Build wish direction from inputs
+  let wishX = 0, wishZ = 0;
+  if (G.input.w) { wishX += FWD.x; wishZ += FWD.z; }
+  if (G.input.s) { wishX -= FWD.x; wishZ -= FWD.z; }
+  if (G.input.d) { wishX += RIGHT.x; wishZ += RIGHT.z; }
+  if (G.input.a) { wishX -= RIGHT.x; wishZ -= RIGHT.z; }
+  const wishLen = Math.hypot(wishX, wishZ);
+  if (wishLen > 0.0001) { wishX /= wishLen; wishZ /= wishLen; }
 
-  if (G.input.w) MOVE.add(FWD);
-  if (G.input.s) MOVE.sub(FWD);
-  if (G.input.a) MOVE.sub(RIGHT);
-  if (G.input.d) MOVE.add(RIGHT);
+  // Desired speeds
+  let baseSpeed = P.speed * (G.input.sprint ? CFG.player.sprintMult : 1);
+  const crouchMult = (CFG.player.crouchMult || 1);
+  // If not sliding, crouch reduces speed
+  if (G.input.crouch && !P.sliding) baseSpeed *= crouchMult;
 
-  if (MOVE.length() > 0) {
-    MOVE.normalize();
-    let speed = G.player.speed * (G.input.sprint ? CFG.player.sprintMult : 1);
-    if (G.input.crouch) speed *= (CFG.player.crouchMult || 1);
-    MOVE.multiplyScalar(speed * delta);
+  // Timers: jump buffer and coyote time
+  // Buffer jump on key press (edge), not hold
+  if (G.input.jump && !P.jumpHeld) {
+    P.jumpBuffer = M.jumpBuffer;
+  } else {
+    P.jumpBuffer = Math.max(0, P.jumpBuffer - delta);
   }
+  P.jumpHeld = !!G.input.jump;
 
-  // Apply movement with collision
-  NEXT.copy(G.player.pos).add(MOVE);
+  if (P.grounded) P.coyoteTimer = M.coyoteTime; else P.coyoteTimer = Math.max(0, P.coyoteTimer - delta);
+  P.wallContactTimer = Math.max(0, P.wallContactTimer - delta);
 
-  // Tree collisions (use spatial grid)
+  // Sliding enter/exit
+  const horizSpeed = Math.hypot(P.vel.x, P.vel.z);
+  if (P.grounded && G.input.crouch && (horizSpeed >= M.slideMinSpeed)) {
+    P.sliding = true;
+  } else if (!G.input.crouch || !P.grounded) {
+    P.sliding = false;
+  }
+
+  // Jump handling (ground, coyote, or wall bounce)
+  let skippedFriction = false;
+  if (P.jumpBuffer > 0) {
+    if (P.coyoteTimer > 0) {
+      // Ground/coyote jump
+      P.yVel = M.jumpSpeed;
+      // Slide-jump: preserve momentum and add small boost
+      if (P.sliding) {
+        const sp = Math.hypot(P.vel.x, P.vel.z);
+        if (sp > 0.0001) {
+          const nx = P.vel.x / sp, nz = P.vel.z / sp;
+          P.vel.x += nx * M.slideJumpBoost;
+          P.vel.z += nz * M.slideJumpBoost;
+        }
+        skippedFriction = true;
+      }
+      P.grounded = false;
+      P.jumpBuffer = 0; // consume
+      P.coyoteTimer = 0;
+    } else if (!P.grounded && P.wallContactTimer > 0) {
+      // Wall bounce: reflect into-wall component and add outward pop
+      const n = P.lastWallNormal;
+      const dot = P.vel.x * n.x + P.vel.z * n.z;
+      // Remove into-wall component
+      P.vel.x -= n.x * dot;
+      P.vel.z -= n.z * dot;
+      // Add outward impulse
+      P.vel.x += n.x * M.wallBounceImpulse;
+      P.vel.z += n.z * M.wallBounceImpulse;
+      // Give a small jump
+      P.yVel = M.jumpSpeed;
+      P.jumpBuffer = 0;
+      P.wallContactTimer = 0;
+    }
+  }
+
+  // State-based friction and acceleration
+  if (P.grounded) {
+    // Friction (skip on slide-jump frame)
+    if (!skippedFriction) {
+      const fric = P.sliding ? M.slideFriction : M.friction;
+      applyFriction(P.vel, fric, M.stopSpeed, delta);
+    }
+    // Accelerate toward wishdir
+    accelerate(P.vel, { x: wishX, z: wishZ }, baseSpeed, P.sliding ? M.slideAccel : M.groundAccel, delta);
+  } else {
+    // Air movement
+    airAccelerate(P.vel, { x: wishX, z: wishZ }, M.airSpeedCap, M.airAccel, delta);
+  }
+
+  // Gravity (vertical only)
+  P.yVel -= M.gravity * delta;
+
+  // Integrate position
+  NEXT.copy(P.pos);
+  NEXT.x += P.vel.x * delta;
+  NEXT.z += P.vel.z * delta;
+  NEXT.y += P.yVel * delta;
+
+  // Collide with tree trunks (cylinders in XZ), push out
   const nearTrees = getNearbyTrees(NEXT.x, NEXT.z, 3.5);
   for (let i = 0; i < nearTrees.length; i++) {
     const tree = nearTrees[i];
     const dx = NEXT.x - tree.x;
     const dz = NEXT.z - tree.z;
-    const dist = Math.sqrt(dx * dx + dz * dz);
-    const minDist = G.player.radius + tree.radius;
+    const dist = Math.hypot(dx, dz);
+    const minDist = P.radius + tree.radius;
     if (dist < minDist && dist > 0) {
-      const pushX = (dx / dist) * (minDist - dist);
-      const pushZ = (dz / dist) * (minDist - dist);
-      NEXT.x += pushX;
-      NEXT.z += pushZ;
+      const nx = dx / dist;
+      const nz = dz / dist;
+      const push = (minDist - dist);
+      NEXT.x += nx * push;
+      NEXT.z += nz * push;
+      // Record wall contact for potential wall-bounce when airborne
+      if (!P.grounded) {
+        P.lastWallNormal.set(nx, 0, nz);
+        P.wallContactTimer = Math.max(P.wallContactTimer, CFG.player.move.wallBounceWindow);
+      }
     }
   }
 
-  // Bounds
-  const halfSize = CFG.forestSize / 2 - G.player.radius;
+  // Bounds clamp
+  const halfSize = CFG.forestSize / 2 - P.radius;
   NEXT.x = Math.max(-halfSize, Math.min(halfSize, NEXT.x));
   NEXT.z = Math.max(-halfSize, Math.min(halfSize, NEXT.z));
 
-  // Gravity
-  G.player.yVel -= 15 * delta; // gravity
-  NEXT.y += G.player.yVel * delta;
-
-  // Grounded against terrain height
+  // Ground resolve against terrain (using eye height)
   const eye = G.input.crouch ? (CFG.player.crouchEyeHeight || 1.8) : (CFG.player.eyeHeight || 1.8);
   const groundEye = getTerrainHeight(NEXT.x, NEXT.z) + eye;
   if (NEXT.y <= groundEye) {
     NEXT.y = groundEye;
-    G.player.yVel = 0;
-    G.player.grounded = true;
+    P.yVel = 0;
+    P.grounded = true;
   } else {
-    G.player.grounded = false;
+    P.grounded = false;
   }
 
-  // Update velocity estimate (units/sec)
-  PREV.copy(G.player.pos);
-  G.player.pos.copy(NEXT);
-  if (delta > 0) {
-    G.player.vel.copy(G.player.pos).sub(PREV).multiplyScalar(1 / delta);
-    // Ignore vertical component for prediction stability
-    G.player.vel.y = 0;
-  }
-  G.camera.position.copy(G.player.pos);
+  // Commit position and keep camera in sync
+  PREV.copy(P.pos);
+  P.pos.copy(NEXT);
+  G.camera.position.copy(P.pos);
 }