quake2ts 0.0.226 → 0.0.228

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

@@ -205,9 +205,6 @@ function lengthVec3(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);
@@ -3918,6 +3915,30 @@ function multiTrigger(self, entities) {
   if (self.nextthink > entities.timeSeconds) {
     return;
   }
+  let noise = "";
+  switch (self.sounds) {
+    case 1:
+      noise = "misc/secret.wav";
+      break;
+    case 2:
+      noise = "misc/talk.wav";
+      break;
+    case 3:
+      noise = "misc/trigger1.wav";
+      break;
+    case 4:
+      noise = "switches/butn2.wav";
+      break;
+  }
+  if (noise) {
+    entities.sound(self, 0, noise, 1, 1, 0);
+  }
+  if (self.message && self.activator && self.activator.client) {
+    entities.engine.centerprintf?.(self.activator, self.message);
+    if (self.sounds === 2) {
+      entities.sound(self.activator, 0, "misc/talk.wav", 1, 1, 0);
+    }
+  }
   entities.useTargets(self, self.activator);
   if (self.wait > 0) {
     self.think = multiWait;
@@ -3957,6 +3978,9 @@ function registerTriggerMultiple(registry) {
     if (entity.wait === 0) {
       entity.wait = 0.2;
     }
+    if (entity.spawnflags & TRIGGER_SPAWNFLAGS.Clip) {
+      entity.solid = 3 /* Bsp */;
+    }
     if (entity.spawnflags & TRIGGER_SPAWNFLAGS.Latched) {
     }
     if (entity.spawnflags & (TRIGGER_SPAWNFLAGS.Triggered | TRIGGER_SPAWNFLAGS.Toggle)) {
@@ -3983,6 +4007,12 @@ function registerTriggerRelay(registry) {
       entity.noise_index = -1;
     }
     entity.use = (self, _other, activator) => {
+      if (!(self.spawnflags & RELAY_SPAWNFLAGS.NoSound)) {
+        context.entities.sound(self, 0, "misc/trigger1.wav", 1, 1, 0);
+      }
+      if (self.message && activator && activator.client) {
+        context.entities.engine.centerprintf?.(activator, self.message);
+      }
       context.entities.useTargets(self, activator ?? self);
     };
   });
@@ -4826,6 +4856,41 @@ function registerItemSpawns(game, registry) {
 }
 
 // src/entities/funcs.ts
+function move_calc(ent, dest, context, done) {
+  const dt = 0.1;
+  const vec = subtractVec3(dest, ent.origin);
+  const dist = lengthVec3(vec);
+  const dir = normalizeVec3(vec);
+  const speed = ent.speed || 100;
+  let currentSpeed = lengthVec3(ent.velocity);
+  if (ent.accel) {
+    currentSpeed += ent.accel * dt;
+  } else {
+    currentSpeed = speed;
+  }
+  if (ent.decel) {
+    const distToStop = currentSpeed * currentSpeed / (2 * ent.decel);
+    if (dist <= distToStop) {
+      currentSpeed -= ent.decel * dt;
+      if (currentSpeed < 10) currentSpeed = 10;
+    }
+  }
+  if (currentSpeed > speed) currentSpeed = speed;
+  const move = currentSpeed * dt;
+  if (dist <= move) {
+    ent.velocity = scaleVec3(dir, dist / dt);
+    ent.think = (e) => {
+      e.velocity = { x: 0, y: 0, z: 0 };
+      e.origin = { ...dest };
+      context.linkentity(e);
+      done(e, context);
+    };
+    context.scheduleThink(ent, context.timeSeconds + dt);
+  } else {
+    ent.velocity = scaleVec3(dir, currentSpeed);
+    context.scheduleThink(ent, context.timeSeconds + dt);
+  }
+}
 function door_blocked(self, other) {
   if (other && other.takedamage) {
     const damage = self.dmg || 2;
@@ -4839,34 +4904,25 @@ function door_blocked(self, other) {
     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 };
+function door_hit_top(ent, context) {
+  ent.state = 0 /* Open */;
+  if (ent.spawnflags & 32) {
     return;
   }
-  const move = distance(door.origin, door.pos1);
-  const speed = Math.min(door.speed, move);
-  door.velocity = scaleVec3(normalizeVec3(subtractVec3(door.pos1, door.origin)), speed);
-  if (move <= door.speed * 0.1) {
-    door.velocity = scaleVec3(subtractVec3(door.pos1, door.origin), 10);
+  if (ent.wait === -1) {
+    return;
   }
-  context?.scheduleThink(door, context.timeSeconds + 0.1);
+  ent.think = door_go_down;
+  context.scheduleThink(ent, context.timeSeconds + ent.wait);
+}
+function door_hit_bottom(ent, context) {
+  ent.state = 2 /* Closed */;
+}
+function door_go_down(door, context) {
+  move_calc(door, door.pos1, context, door_hit_bottom);
 }
 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 = scaleVec3(normalizeVec3(subtractVec3(door.pos2, door.origin)), door.speed);
-  if (move <= door.speed * 0.1) {
-    door.velocity = scaleVec3(subtractVec3(door.pos2, door.origin), 10);
-  }
-  context?.scheduleThink(door, context.timeSeconds + 0.1);
+  move_calc(door, door.pos2, context, door_hit_top);
 }
 var func_door = (entity, context) => {
   entity.movedir = setMovedir(entity.angles);
@@ -5013,35 +5069,21 @@ var func_train = (entity, context) => {
   entity.think = (self) => train_find(self, context.entities);
   context.entities.scheduleThink(entity, context.entities.timeSeconds + 0.1);
 };
-function plat_go_down(ent, context) {
-  if (vec3Equals(ent.origin, ent.pos2)) {
-    ent.state = 1 /* Down */;
-    ent.velocity = { x: 0, y: 0, z: 0 };
-    return;
-  }
-  const move = distance(ent.origin, ent.pos2);
-  ent.velocity = scaleVec3(normalizeVec3(subtractVec3(ent.pos2, ent.origin)), ent.speed);
-  if (move <= ent.speed * 0.1) {
-    ent.velocity = scaleVec3(subtractVec3(ent.pos2, ent.origin), 10);
+function plat_hit_top(ent, context) {
+  ent.state = 0 /* Up */;
+  if (!(ent.spawnflags & 1)) {
+    ent.think = plat_wait_top;
+    context.scheduleThink(ent, context.timeSeconds + ent.wait);
   }
-  context.scheduleThink(ent, context.timeSeconds + 0.1);
+}
+function plat_hit_bottom(ent, context) {
+  ent.state = 1 /* Down */;
+}
+function plat_go_down(ent, context) {
+  move_calc(ent, ent.pos2, context, plat_hit_bottom);
 }
 function plat_go_up(ent, context) {
-  if (vec3Equals(ent.origin, ent.pos1)) {
-    ent.state = 0 /* Up */;
-    ent.velocity = { x: 0, y: 0, z: 0 };
-    if (!(ent.spawnflags & 1)) {
-      ent.think = plat_wait_top;
-      context.scheduleThink(ent, context.timeSeconds + ent.wait);
-    }
-    return;
-  }
-  const move = distance(ent.origin, ent.pos1);
-  ent.velocity = scaleVec3(normalizeVec3(subtractVec3(ent.pos1, ent.origin)), ent.speed);
-  if (move <= ent.speed * 0.1) {
-    ent.velocity = scaleVec3(subtractVec3(ent.pos1, ent.origin), 10);
-  }
-  context.scheduleThink(ent, context.timeSeconds + 0.1);
+  move_calc(ent, ent.pos1, context, plat_hit_top);
 }
 function plat_wait_top(ent, context) {
   ent.state = 3 /* GoingDown */;