quake2ts 0.0.52 → 0.0.55

package/packages/game/dist/esm/index.js

@@ -358,7 +358,167 @@ var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
   WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
   return WaterLevel3;
 })(WaterLevel || {});
+function applyPmoveFriction(params) {
+  const {
+    velocity,
+    frametime,
+    onGround,
+    groundIsSlick,
+    onLadder,
+    waterlevel,
+    pmFriction,
+    pmStopSpeed,
+    pmWaterFriction
+  } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: velocity.z };
+  }
+  let drop = 0;
+  if (onGround && !groundIsSlick || onLadder) {
+    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+    const friction = pmFriction;
+    drop += control * friction * frametime;
+  }
+  if (waterlevel > 0 && !onLadder) {
+    drop += speed * pmWaterFriction * waterlevel * frametime;
+  }
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  const scale = newspeed / speed;
+  return scaleVec3(velocity, scale);
+}
+function applyPmoveAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspeed - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * frametime * wishspeed;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function buildAirGroundWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+function buildWaterWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  if (cmd.upmove > 10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else if (cmd.upmove < -10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
+  }
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  wishspeed *= 0.5;
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
 var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+var FRAMETIME = 0.025;
+var categorizePosition2 = (state, trace) => {
+  const point = { ...state.origin };
+  point.z -= 0.25;
+  const traceResult = trace(state.origin, point);
+  return {
+    ...state,
+    onGround: traceResult.fraction < 1
+  };
+};
+var checkWater = (state, pointContents2) => {
+  const point = { ...state.origin };
+  point.z += state.mins.z + 1;
+  const contents = pointContents2(point);
+  if (contents & 33554432) {
+    return { ...state, waterLevel: 1 };
+  }
+  return { ...state, waterLevel: 0 };
+};
+var applyPmove = (state, cmd, trace, pointContents2) => {
+  let newState = { ...state };
+  newState = categorizePosition2(newState, trace);
+  newState = checkWater(newState, pointContents2);
+  const { origin, velocity, onGround, waterLevel } = newState;
+  const frictionedVelocity = applyPmoveFriction({
+    velocity,
+    frametime: FRAMETIME,
+    onGround,
+    groundIsSlick: false,
+    onLadder: false,
+    waterlevel: waterLevel,
+    pmFriction: 6,
+    pmStopSpeed: 100,
+    pmWaterFriction: 1
+  });
+  const wish = waterLevel >= 2 ? buildWaterWish({
+    forward: { x: 1, y: 0, z: 0 },
+    right: { x: 0, y: 1, z: 0 },
+    cmd,
+    maxSpeed: 320
+  }) : buildAirGroundWish({
+    forward: { x: 1, y: 0, z: 0 },
+    right: { x: 0, y: 1, z: 0 },
+    cmd,
+    maxSpeed: 320
+  });
+  const finalVelocity = applyPmoveAccelerate({
+    velocity: frictionedVelocity,
+    wishdir: wish.wishdir,
+    wishspeed: wish.wishspeed,
+    accel: onGround ? 10 : 1,
+    frametime: FRAMETIME
+  });
+  const traceResult = trace(origin, {
+    x: origin.x + finalVelocity.x * FRAMETIME,
+    y: origin.y + finalVelocity.y * FRAMETIME,
+    z: origin.z + finalVelocity.z * FRAMETIME
+  });
+  return {
+    ...newState,
+    origin: traceResult.endpos,
+    velocity: finalVelocity
+  };
+};
 
 // src/entities/entity.ts
 var MoveType = /* @__PURE__ */ ((MoveType2) => {
@@ -936,6 +1096,14 @@ var EntitySystem = class {
       callback(entity);
     }
   }
+  find(predicate) {
+    for (const entity of this.pool) {
+      if (predicate(entity)) {
+        return entity;
+      }
+    }
+    return void 0;
+  }
   spawn() {
     return this.pool.spawn();
   }
@@ -1925,6 +2093,11 @@ function spawnEntitiesFromText(text, options) {
   }
   return spawned;
 }
+function findPlayerStart(entities) {
+  return entities.find(
+    (entity) => entity.classname === "info_player_start"
+  );
+}
 function registerDefaultSpawns(registry) {
   registry.register("worldspawn", (entity) => {
     entity.movetype = 2 /* Push */;
@@ -4085,7 +4258,7 @@ var WEAPONS = {
 
 // src/index.ts
 var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
-function createGame(engine, options) {
+function createGame(trace, pointContents, engine, options) {
   const gravity = options.gravity;
   const levelClock = new LevelClock();
   const frameLoop = new GameFrameLoop();
@@ -4134,15 +4307,39 @@ function createGame(engine, options) {
   return {
     init(startTimeMs) {
       resetState(startTimeMs);
-      void engine.trace({ x: 0, y: 0, z: 0 }, gravity);
       return snapshot(0);
     },
     shutdown() {
     },
     spawnWorld() {
+      const playerStart = findPlayerStart(entities);
+      if (playerStart) {
+        const player = entities.spawn();
+        player.classname = "player";
+        player.origin = { ...playerStart.origin };
+        player.angles = { ...playerStart.angles };
+        player.health = 100;
+        player.mins = { x: -16, y: -16, z: -24 };
+        player.maxs = { x: 16, y: 16, z: 32 };
+        entities.finalizeSpawn(player);
+        origin = { ...player.origin };
+      }
     },
-    frame(step) {
+    frame(step, command) {
       const context = frameLoop.advance(step);
+      const player = entities.find((e) => e.classname === "player");
+      if (command && player) {
+        const pcmd = {
+          forwardmove: command.forwardmove,
+          sidemove: command.sidemove,
+          upmove: command.upmove,
+          buttons: command.buttons
+        };
+        const playerState = { origin: player.origin, velocity: player.velocity, onGround: false, waterLevel: 0, mins: player.mins, maxs: player.maxs };
+        const newState = applyPmove(playerState, pcmd, trace, pointContents);
+        player.origin = newState.origin;
+        player.velocity = newState.velocity;
+      }
       return snapshot(context.frame);
     },
     entities,