quake2ts 0.0.68 → 0.0.71

package/packages/game/dist/cjs/index.cjs

@@ -161,6 +161,12 @@ function lengthSquaredVec3(a) {
 function lengthVec3(a) {
   return Math.sqrt(lengthSquaredVec3(a));
 }
+function distance(a, b) {
+  return lengthVec3(subtractVec3(a, b));
+}
+function vec3Equals(a, b) {
+  return a.x === b.x && a.y === b.y && a.z === b.z;
+}
 function normalizeVec3(a) {
   const len = lengthVec3(a);
   return len === 0 ? a : scaleVec3(a, 1 / len);
@@ -746,9 +752,13 @@ var Entity = class {
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.pos1 = copyVec3();
+    this.pos2 = copyVec3();
     this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
+    this.absmin = copyVec3();
+    this.absmax = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
@@ -770,6 +780,8 @@ var Entity = class {
     this.wait = 0;
     this.delay = 0;
     this.timestamp = 0;
+    this.lip = 0;
+    this.state = 0;
     this.sounds = 0;
     this.noise_index = 0;
     this.fly_sound_debounce_time = 0;
@@ -820,9 +832,13 @@ var Entity = class {
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.pos1 = copyVec3();
+    this.pos2 = copyVec3();
     this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
+    this.absmin = copyVec3();
+    this.absmax = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
@@ -844,6 +860,8 @@ var Entity = class {
     this.wait = 0;
     this.delay = 0;
     this.timestamp = 0;
+    this.lip = 0;
+    this.state = 0;
     this.sounds = 0;
     this.noise_index = 0;
     this.fly_sound_debounce_time = 0;
@@ -865,6 +883,7 @@ var Entity = class {
     this.think = void 0;
     this.touch = void 0;
     this.use = void 0;
+    this.blocked = void 0;
     this.pain = void 0;
     this.die = void 0;
     this.activator = null;
@@ -895,9 +914,13 @@ var ENTITY_FIELD_METADATA = [
   { name: "velocity", type: "vec3", save: true },
   { name: "avelocity", type: "vec3", save: true },
   { name: "angles", type: "vec3", save: true },
+  { name: "pos1", type: "vec3", save: true },
+  { name: "pos2", type: "vec3", save: true },
   { name: "viewheight", type: "int", save: true },
   { name: "mins", type: "vec3", save: true },
   { name: "maxs", type: "vec3", save: true },
+  { name: "absmin", type: "vec3", save: true },
+  { name: "absmax", type: "vec3", save: true },
   { name: "size", type: "vec3", save: true },
   { name: "mass", type: "int", save: true },
   { name: "gravity", type: "float", save: true },
@@ -918,6 +941,8 @@ var ENTITY_FIELD_METADATA = [
   { name: "wait", type: "float", save: true },
   { name: "delay", type: "float", save: true },
   { name: "timestamp", type: "float", save: true },
+  { name: "lip", type: "int", save: true },
+  { name: "state", type: "int", save: true },
   { name: "sounds", type: "int", save: true },
   { name: "noise_index", type: "int", save: true },
   { name: "fly_sound_debounce_time", type: "float", save: true },
@@ -942,6 +967,7 @@ var ENTITY_FIELD_METADATA = [
   { name: "think", type: "callback", save: false },
   { name: "touch", type: "callback", save: false },
   { name: "use", type: "callback", save: false },
+  { name: "blocked", type: "callback", save: false },
   { name: "pain", type: "callback", save: false },
   { name: "die", type: "callback", save: false }
 ];
@@ -975,6 +1001,108 @@ function runProjectileMovement(ent, imports, frametime) {
   const traceResult = imports.trace(ent.origin, ent.mins, ent.maxs, end, ent, ent.clipmask);
   ent.origin = traceResult.endpos;
 }
+function testEntityPosition(ent, imports) {
+  const trace = imports.trace(ent.origin, ent.mins, ent.maxs, ent.origin, ent, ent.clipmask);
+  if (trace.startsolid || trace.allsolid) {
+    return false;
+  }
+  return true;
+}
+function runPush(pusher, system, imports, frametime) {
+  const move = {
+    x: pusher.velocity.x * frametime,
+    y: pusher.velocity.y * frametime,
+    z: pusher.velocity.z * frametime
+  };
+  const amove = {
+    x: pusher.avelocity.x * frametime,
+    y: pusher.avelocity.y * frametime,
+    z: pusher.avelocity.z * frametime
+  };
+  const mins = {
+    x: Math.min(pusher.absmin.x, pusher.absmin.x + move.x) - 2,
+    // Expand slightly? Quake2 does 'mins - move - 2' logic implicitly via box check
+    y: Math.min(pusher.absmin.y, pusher.absmin.y + move.y) - 2,
+    z: Math.min(pusher.absmin.z, pusher.absmin.z + move.z) - 2
+  };
+  const maxs = {
+    x: Math.max(pusher.absmax.x, pusher.absmax.x + move.x) + 2,
+    y: Math.max(pusher.absmax.y, pusher.absmax.y + move.y) + 2,
+    z: Math.max(pusher.absmax.z, pusher.absmax.z + move.z) + 2
+  };
+  const pushed = [];
+  pushed.push({
+    ent: pusher,
+    origin: { ...pusher.origin },
+    angles: { ...pusher.angles },
+    ground: pusher.groundentity
+  });
+  pusher.origin = {
+    x: pusher.origin.x + move.x,
+    y: pusher.origin.y + move.y,
+    z: pusher.origin.z + move.z
+  };
+  pusher.angles = {
+    x: pusher.angles.x + amove.x,
+    y: pusher.angles.y + amove.y,
+    z: pusher.angles.z + amove.z
+  };
+  imports.linkentity(pusher);
+  if (!testEntityPosition(pusher, imports)) {
+    pusher.origin = pushed[0].origin;
+    pusher.angles = pushed[0].angles;
+    imports.linkentity(pusher);
+    return false;
+  }
+  const candidates = [];
+  system.forEachEntity((check) => {
+    if (check === pusher) return;
+    if (check.solid === 0 /* Not */ || check.solid === 1 /* Trigger */) return;
+    if (check.absmin.x >= maxs.x || check.absmax.x <= mins.x || check.absmin.y >= maxs.y || check.absmax.y <= mins.y || check.absmin.z >= maxs.z || check.absmax.z <= mins.z) {
+      return;
+    }
+    candidates.push(check);
+  });
+  for (const ent of candidates) {
+    let moveEntity = false;
+    if (ent.groundentity === pusher) {
+      moveEntity = true;
+    } else {
+      if (ent.absmin.x < pusher.absmax.x && ent.absmax.x > pusher.absmin.x && ent.absmin.y < pusher.absmax.y && ent.absmax.y > pusher.absmin.y && ent.absmin.z < pusher.absmax.z && ent.absmax.z > pusher.absmin.z) {
+        moveEntity = true;
+      }
+    }
+    if (moveEntity) {
+      pushed.push({
+        ent,
+        origin: { ...ent.origin },
+        angles: { ...ent.angles },
+        ground: ent.groundentity
+      });
+      ent.origin = {
+        x: ent.origin.x + move.x,
+        y: ent.origin.y + move.y,
+        z: ent.origin.z + move.z
+      };
+      imports.linkentity(ent);
+      if (!testEntityPosition(ent, imports)) {
+        if (pusher.blocked) {
+          pusher.blocked(pusher, ent);
+        }
+        if (ent.solid !== 0 /* Not */ && (!ent.health || ent.health > 0)) {
+          for (let i = pushed.length - 1; i >= 0; i--) {
+            const p = pushed[i];
+            p.ent.origin = p.origin;
+            p.ent.angles = p.angles;
+            p.ent.groundentity = p.ground, imports.linkentity(p.ent);
+          }
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
 
 // src/entities/pool.ts
 var MAX_EDICTS = 2048;
@@ -1189,7 +1317,7 @@ var ThinkScheduler = class {
       this.schedule(entity, entry.time);
     }
   }
-  runDueThinks(currentTimeSeconds) {
+  runDueThinks(currentTimeSeconds, context) {
     while (this.queue.length > 0) {
       const next = this.queue[0];
       if (next.time > currentTimeSeconds) {
@@ -1206,7 +1334,7 @@ var ThinkScheduler = class {
       if (entity.nextthink !== time) {
         continue;
       }
-      entity.think(entity);
+      entity.think(entity, context);
     }
   }
 };
@@ -1279,7 +1407,19 @@ var EntitySystem = class {
         contents: 0,
         ent: null
       }),
-      pointcontents: () => 0
+      pointcontents: () => 0,
+      linkentity: (ent) => {
+        ent.absmin = {
+          x: ent.origin.x + ent.mins.x,
+          y: ent.origin.y + ent.mins.y,
+          z: ent.origin.z + ent.mins.z
+        };
+        ent.absmax = {
+          x: ent.origin.x + ent.maxs.x,
+          y: ent.origin.y + ent.maxs.y,
+          z: ent.origin.z + ent.maxs.z
+        };
+      }
     };
     this.gravity = gravity || { x: 0, y: 0, z: 0 };
     this.callbackToName = /* @__PURE__ */ new Map();
@@ -1329,6 +1469,9 @@ var EntitySystem = class {
   sound(entity, channel, sound, volume, attenuation, timeofs) {
     this.engine.sound?.(entity, channel, sound, volume, attenuation, timeofs);
   }
+  modelIndex(model) {
+    return this.engine.modelIndex?.(model) || 0;
+  }
   scheduleThink(entity, nextThinkSeconds) {
     this.thinkScheduler.schedule(entity, nextThinkSeconds);
   }
@@ -1357,6 +1500,18 @@ var EntitySystem = class {
     }
     return Array.from(matches).filter((entity) => entity.inUse && !entity.freePending);
   }
+  findByRadius(origin, radius) {
+    const matches = [];
+    for (const entity of this.pool) {
+      if (entity.inUse && !entity.freePending) {
+        const distance2 = lengthVec3(subtractVec3(origin, entity.origin));
+        if (distance2 <= radius) {
+          matches.push(entity);
+        }
+      }
+    }
+    return matches;
+  }
   pickTarget(targetname) {
     if (!targetname) {
       return null;
@@ -1405,7 +1560,7 @@ var EntitySystem = class {
     this.useTargetsImmediate(entity, activator ?? entity);
   }
   runFrame() {
-    this.thinkScheduler.runDueThinks(this.currentTimeSeconds);
+    this.thinkScheduler.runDueThinks(this.currentTimeSeconds, this);
     for (const ent of this.pool) {
       if (!ent.inUse || ent.freePending) {
         continue;
@@ -1425,6 +1580,9 @@ var EntitySystem = class {
           runProjectileMovement(ent, this.imports, frametime);
           ent.timestamp = this.currentTimeSeconds;
           break;
+        case 2 /* Push */:
+          runPush(ent, this, this.imports, frametime);
+          break;
       }
     }
     this.runTouches();
@@ -2993,6 +3151,112 @@ function registerItemSpawns(game, registry) {
   }
 }
 
+// src/entities/funcs.ts
+function door_blocked(self, other) {
+  if (other && other.takedamage) {
+    const damage = self.dmg || 2;
+    other.health -= damage;
+  }
+  if (self.state === 1 /* Opening */) {
+    self.state = 3 /* Closing */;
+    self.think = door_go_down;
+  } else if (self.state === 3 /* Closing */) {
+    self.state = 1 /* Opening */;
+    self.think = door_go_up;
+  }
+}
+function door_go_down(door, context) {
+  if (vec3Equals(door.origin, door.pos1)) {
+    door.state = 2 /* Closed */;
+    door.velocity = { x: 0, y: 0, z: 0 };
+    return;
+  }
+  const move = distance(door.origin, door.pos1);
+  const speed = Math.min(door.speed, move);
+  door.velocity = {
+    x: (door.pos1.x - door.origin.x) / distance(door.pos1, door.origin) * door.speed,
+    y: (door.pos1.y - door.origin.y) / distance(door.pos1, door.origin) * door.speed,
+    z: (door.pos1.z - door.origin.z) / distance(door.pos1, door.origin) * door.speed
+  };
+  if (move <= door.speed * 0.1) {
+    door.velocity = {
+      x: (door.pos1.x - door.origin.x) / 0.1,
+      y: (door.pos1.y - door.origin.y) / 0.1,
+      z: (door.pos1.z - door.origin.z) / 0.1
+    };
+  }
+  context?.scheduleThink(door, context.timeSeconds + 0.1);
+}
+function door_go_up(door, context) {
+  if (vec3Equals(door.origin, door.pos2)) {
+    door.state = 0 /* Open */;
+    door.velocity = { x: 0, y: 0, z: 0 };
+    context?.scheduleThink(door, context.timeSeconds + door.wait);
+    door.think = door_go_down;
+    return;
+  }
+  const move = distance(door.origin, door.pos2);
+  door.velocity = {
+    x: (door.pos2.x - door.origin.x) / distance(door.pos2, door.origin) * door.speed,
+    y: (door.pos2.y - door.origin.y) / distance(door.pos2, door.origin) * door.speed,
+    z: (door.pos2.z - door.origin.z) / distance(door.pos2, door.origin) * door.speed
+  };
+  if (move <= door.speed * 0.1) {
+    door.velocity = {
+      x: (door.pos2.x - door.origin.x) / 0.1,
+      y: (door.pos2.y - door.origin.y) / 0.1,
+      z: (door.pos2.z - door.origin.z) / 0.1
+    };
+  }
+  context?.scheduleThink(door, context.timeSeconds + 0.1);
+}
+var func_door = (entity, context) => {
+  entity.movedir = setMovedir(entity.angles);
+  if (!entity.speed) {
+    entity.speed = 100;
+  }
+  if (!entity.wait) {
+    entity.wait = 3;
+  }
+  if (!entity.lip) {
+    entity.lip = 8;
+  }
+  if (!entity.dmg) {
+    entity.dmg = 2;
+  }
+  if (!entity.health) {
+    entity.health = 0;
+  }
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  entity.blocked = door_blocked;
+  entity.state = 2 /* Closed */;
+  entity.pos1 = { ...entity.origin };
+  const move = entity.movedir.x * (Math.abs(entity.maxs.x - entity.mins.x) - entity.lip) + entity.movedir.y * (Math.abs(entity.maxs.y - entity.mins.y) - entity.lip) + entity.movedir.z * (Math.abs(entity.maxs.z - entity.mins.z) - entity.lip);
+  entity.pos2 = {
+    x: entity.pos1.x + entity.movedir.x * move,
+    y: entity.pos1.y + entity.movedir.y * move,
+    z: entity.pos1.z + entity.movedir.z * move
+  };
+  entity.use = (self) => {
+    if (self.state !== 2 /* Closed */) return;
+    self.state = 1 /* Opening */;
+    self.think = door_go_up;
+    context.entities.scheduleThink(self, context.entities.timeSeconds + 0.1);
+  };
+};
+var func_button = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  entity.use = (self) => {
+    context.entities.useTargets(self, self);
+  };
+};
+function registerFuncSpawns(registry) {
+  registry.register("func_door", func_door);
+  registry.register("func_button", func_button);
+}
+
 // src/entities/spawn.ts
 var FIELD_LOOKUP = new Map(
   ENTITY_FIELD_METADATA.map((field) => [field.name, field])
@@ -3204,6 +3468,7 @@ function registerDefaultSpawns(game, registry) {
   registerTargetSpawns(registry);
   registerMiscSpawns(registry);
   registerItemSpawns(game, registry);
+  registerFuncSpawns(registry);
 }
 function createDefaultSpawnRegistry(game) {
   const registry = new SpawnRegistry();
@@ -3395,19 +3660,19 @@ var TraceMask = /* @__PURE__ */ ((TraceMask2) => {
 })(TraceMask || {});
 
 // src/ai/movement.ts
-function yawVector(yawDegrees, distance) {
-  if (distance === 0) {
+function yawVector(yawDegrees, distance2) {
+  if (distance2 === 0) {
     return { x: 0, y: 0, z: 0 };
   }
   const radians = degToRad(yawDegrees);
   return {
-    x: Math.cos(radians) * distance,
-    y: Math.sin(radians) * distance,
+    x: Math.cos(radians) * distance2,
+    y: Math.sin(radians) * distance2,
     z: 0
   };
 }
-function walkMove(self, yawDegrees, distance) {
-  const delta = yawVector(yawDegrees, distance);
+function walkMove(self, yawDegrees, distance2) {
+  const delta = yawVector(yawDegrees, distance2);
   const origin = self.origin;
   origin.x += delta.x;
   origin.y += delta.y;
@@ -3440,8 +3705,8 @@ function facingIdeal(self) {
   }
   return !(delta > 45 && delta < 315);
 }
-function ai_move(self, distance) {
-  walkMove(self, self.angles.y, distance);
+function ai_move(self, distance2) {
+  walkMove(self, self.angles.y, distance2);
 }
 function setIdealYawTowards(self, target) {
   if (!target) return;
@@ -3455,40 +3720,40 @@ function setIdealYawTowards(self, target) {
 function ai_stand(self, deltaSeconds) {
   changeYaw(self, deltaSeconds);
 }
-function ai_walk(self, distance, deltaSeconds) {
+function ai_walk(self, distance2, deltaSeconds) {
   setIdealYawTowards(self, self.goalentity);
   changeYaw(self, deltaSeconds);
-  if (distance !== 0) {
-    walkMove(self, self.angles.y, distance);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
 }
-function ai_turn(self, distance, deltaSeconds) {
-  if (distance !== 0) {
-    walkMove(self, self.angles.y, distance);
+function ai_turn(self, distance2, deltaSeconds) {
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
   changeYaw(self, deltaSeconds);
 }
-function ai_run(self, distance, deltaSeconds) {
+function ai_run(self, distance2, deltaSeconds) {
   setIdealYawTowards(self, self.enemy ?? self.goalentity);
   changeYaw(self, deltaSeconds);
-  if (distance !== 0) {
-    walkMove(self, self.angles.y, distance);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
 }
-function ai_face(self, enemy, distance, deltaSeconds) {
+function ai_face(self, enemy, distance2, deltaSeconds) {
   if (enemy) {
     setIdealYawTowards(self, enemy);
   }
   changeYaw(self, deltaSeconds);
-  if (distance !== 0) {
-    walkMove(self, self.angles.y, distance);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
 }
-function ai_charge(self, distance, deltaSeconds) {
+function ai_charge(self, distance2, deltaSeconds) {
   setIdealYawTowards(self, self.enemy);
   changeYaw(self, deltaSeconds);
-  if (distance !== 0) {
-    walkMove(self, self.angles.y, distance);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
 }
 
@@ -3520,14 +3785,14 @@ function rangeTo(self, other) {
   const distanceSquared = distanceBetweenBoxesSquared(a.mins, a.maxs, b.mins, b.maxs);
   return Math.sqrt(distanceSquared);
 }
-function classifyRange(distance) {
-  if (distance <= RANGE_MELEE) {
+function classifyRange(distance2) {
+  if (distance2 <= RANGE_MELEE) {
     return "melee" /* Melee */;
   }
-  if (distance <= RANGE_NEAR) {
+  if (distance2 <= RANGE_NEAR) {
     return "near" /* Near */;
   }
-  if (distance <= RANGE_MID) {
+  if (distance2 <= RANGE_MID) {
     return "mid" /* Mid */;
   }
   return "far" /* Far */;
@@ -3607,8 +3872,8 @@ function foundTarget(self, level, options) {
   self.monsterinfo.run?.(self);
 }
 function classifyClientVisibility(self, other, level, trace) {
-  const distance = rangeTo(self, other);
-  const range = classifyRange(distance);
+  const distance2 = rangeTo(self, other);
+  const range = classifyRange(distance2);
   if (range === "far" /* Far */) return false;
   if (other.light_level <= 5) return false;
   if (!visible(self, other, trace, { throughGlass: false })) return false;
@@ -4495,11 +4760,11 @@ function T_RadiusDamage(entities, inflictor, attacker, damage, ignore, radius, d
     }
     const entCenter = ent.mins && ent.maxs ? closestPointToBox(inflictorCenter, addVec3(ent.origin, ent.mins), addVec3(ent.origin, ent.maxs)) : targetCenter(ent);
     const toTarget = subtractVec3(inflictorCenter, entCenter);
-    const distance = lengthVec3(toTarget);
-    if (radius > 0 && distance > radius) {
+    const distance2 = lengthVec3(toTarget);
+    if (radius > 0 && distance2 > radius) {
       continue;
     }
-    const points = damage - 0.5 * distance;
+    const points = damage - 0.5 * distance2;
     if (points <= 0) {
       continue;
     }
@@ -4923,11 +5188,23 @@ function getWeaponState(playerStates, weaponId) {
 
 // src/index.ts
 var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
-function createGame(imports, engine, options) {
+function createGame({ trace, pointcontents }, engine, options) {
   const gravity = options.gravity;
   const levelClock = new LevelClock();
   const frameLoop = new GameFrameLoop();
-  const entities = new EntitySystem(engine, imports, gravity);
+  const linkentity = (ent) => {
+    ent.absmin = {
+      x: ent.origin.x + ent.mins.x,
+      y: ent.origin.y + ent.mins.y,
+      z: ent.origin.z + ent.mins.z
+    };
+    ent.absmax = {
+      x: ent.origin.x + ent.maxs.x,
+      y: ent.origin.y + ent.maxs.y,
+      z: ent.origin.z + ent.maxs.z
+    };
+  };
+  const entities = new EntitySystem(engine, { trace, pointcontents, linkentity }, gravity);
   frameLoop.addStage("prep", (context) => {
     levelClock.tick(context);
     entities.beginFrame(levelClock.current.timeSeconds);
@@ -5005,7 +5282,7 @@ function createGame(imports, engine, options) {
         };
         const playerState = { origin: player.origin, velocity: player.velocity, onGround: false, waterLevel: 0, mins: player.mins, maxs: player.maxs, damageAlpha: 0, damageIndicators: [], viewAngles: player.angles };
         const traceAdapter = (start, end) => {
-          const result = imports.trace(start, player.mins, player.maxs, end, player, 268435457);
+          const result = trace(start, player.mins, player.maxs, end, player, 268435457);
           return {
             fraction: result.fraction,
             endpos: result.endpos,
@@ -5014,7 +5291,7 @@ function createGame(imports, engine, options) {
             planeNormal: result.plane?.normal
           };
         };
-        const pointContentsAdapter = (point) => imports.pointcontents(point);
+        const pointContentsAdapter = (point) => pointcontents(point);
         const newState = applyPmove(playerState, pcmd, traceAdapter, pointContentsAdapter);
         player.origin = newState.origin;
         player.velocity = newState.velocity;
@@ -5028,6 +5305,7 @@ function createGame(imports, engine, options) {
     centerprintf(entity, message) {
       engine.centerprintf?.(entity, message);
     },
+    trace,
     get time() {
       return levelClock.current.timeSeconds;
     }