quake2ts 0.0.70 → 0.0.72

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

@@ -634,6 +634,9 @@ var Entity = class {
     this.takedamage = false;
     this.dmg = 0;
     this.speed = 0;
+    this.accel = 0;
+    this.decel = 0;
+    this.height = 0;
     this.deadflag = 0 /* Alive */;
     this.count = 0;
     this.wait = 0;
@@ -714,6 +717,9 @@ var Entity = class {
     this.takedamage = false;
     this.dmg = 0;
     this.speed = 0;
+    this.accel = 0;
+    this.decel = 0;
+    this.height = 0;
     this.deadflag = 0 /* Alive */;
     this.count = 0;
     this.wait = 0;
@@ -795,6 +801,9 @@ var ENTITY_FIELD_METADATA = [
   { name: "takedamage", type: "boolean", save: true },
   { name: "dmg", type: "int", save: true },
   { name: "speed", type: "float", save: true },
+  { name: "accel", type: "float", save: true },
+  { name: "decel", type: "float", save: true },
+  { name: "height", type: "float", save: true },
   { name: "deadflag", type: "int", save: true },
   { name: "count", type: "int", save: true },
   { name: "wait", type: "float", save: true },
@@ -3032,17 +3041,9 @@ function door_go_down(door, context) {
   }
   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
-  };
+  door.velocity = scaleVec3(normalizeVec3(subtractVec3(door.pos1, door.origin)), 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
-    };
+    door.velocity = scaleVec3(subtractVec3(door.pos1, door.origin), 10);
   }
   context?.scheduleThink(door, context.timeSeconds + 0.1);
 }
@@ -3055,48 +3056,26 @@ function door_go_up(door, context) {
     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
-  };
+  door.velocity = scaleVec3(normalizeVec3(subtractVec3(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
-    };
+    door.velocity = scaleVec3(subtractVec3(door.pos2, door.origin), 10);
   }
   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;
-  }
+  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.pos2 = addVec3(entity.pos1, scaleVec3(entity.movedir, move));
   entity.use = (self) => {
     if (self.state !== 2 /* Closed */) return;
     self.state = 1 /* Opening */;
@@ -3111,9 +3090,247 @@ var func_button = (entity, context) => {
     context.entities.useTargets(self, self);
   };
 };
+var TRAIN_START_ON = 1;
+var TRAIN_BLOCK_STOPS = 4;
+function train_blocked(self, other) {
+  if (other && other.takedamage) {
+    other.health -= self.dmg || 0;
+  }
+  if (!(self.spawnflags & TRAIN_BLOCK_STOPS)) {
+    return;
+  }
+  self.velocity = { x: 0, y: 0, z: 0 };
+  self.nextthink = 0;
+}
+function train_wait(self, context) {
+  if (self.target_ent && self.target_ent.pathtarget) {
+    context.useTargets(self.target_ent, self);
+  }
+  if (self.target_ent && self.target_ent.target) {
+    const next = context.pickTarget(self.target_ent.target);
+    if (!next) return;
+    self.target_ent = next;
+    const dist = distance(self.origin, next.origin);
+    const speed = self.speed || 100;
+    const time = dist / speed;
+    const dir = normalizeVec3(subtractVec3(next.origin, self.origin));
+    self.velocity = scaleVec3(dir, speed);
+    self.think = train_next;
+    context.scheduleThink(self, context.timeSeconds + time);
+  }
+}
+function train_next(self, context) {
+  self.velocity = { x: 0, y: 0, z: 0 };
+  if (self.target_ent) {
+    self.origin = { ...self.target_ent.origin };
+  }
+  const wait = self.wait || 0;
+  if (wait > 0) {
+    self.think = train_wait;
+    context.scheduleThink(self, context.timeSeconds + wait);
+  } else {
+    train_wait(self, context);
+  }
+}
+function train_find(self, context) {
+  const target = context.pickTarget(self.target);
+  if (!target) return;
+  self.target_ent = target;
+  self.origin = { ...target.origin };
+  if (self.spawnflags & TRAIN_START_ON) {
+    train_wait(self, context);
+  } else {
+    self.use = (ent) => {
+      if (ent.velocity.x !== 0 || ent.velocity.y !== 0 || ent.velocity.z !== 0) return;
+      train_wait(ent, context);
+    };
+  }
+}
+var func_train = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  entity.blocked = train_blocked;
+  if (!entity.speed) entity.speed = 100;
+  if (!entity.dmg) entity.dmg = 2;
+  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);
+  }
+  context.scheduleThink(ent, context.timeSeconds + 0.1);
+}
+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);
+}
+function plat_wait_top(ent, context) {
+  ent.state = 3 /* GoingDown */;
+  ent.think = plat_go_down;
+  plat_go_down(ent, context);
+}
+var func_plat = (entity, context) => {
+  entity.movedir = setMovedir(entity.angles);
+  if (!entity.speed) entity.speed = 200;
+  if (!entity.accel) entity.accel = 500;
+  if (!entity.decel) entity.decel = 500;
+  if (!entity.wait) entity.wait = 3;
+  if (!entity.lip) entity.lip = 8;
+  if (!entity.height) entity.height = entity.size.z - entity.lip;
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  entity.pos1 = { ...entity.origin };
+  entity.pos2 = {
+    x: entity.origin.x,
+    y: entity.origin.y,
+    z: entity.origin.z - entity.height
+  };
+  entity.origin = { ...entity.pos2 };
+  entity.state = 1 /* Down */;
+  entity.blocked = (self, other) => {
+    if (other && other.takedamage) {
+      other.health -= self.dmg || 2;
+    }
+    if (self.state === 2 /* GoingUp */) {
+      self.state = 3 /* GoingDown */;
+      self.think = (e) => plat_go_down(e, context.entities);
+    } else if (self.state === 3 /* GoingDown */) {
+      self.state = 2 /* GoingUp */;
+      self.think = (e) => plat_go_up(e, context.entities);
+    }
+  };
+  entity.use = (self) => {
+    if (self.state === 1 /* Down */) {
+      self.state = 2 /* GoingUp */;
+      self.think = (e) => plat_go_up(e, context.entities);
+      context.entities.scheduleThink(self, context.entities.timeSeconds + 0.1);
+    }
+  };
+  const trigger = context.entities.spawn();
+  trigger.classname = "plat_trigger";
+  trigger.movetype = 0 /* None */;
+  trigger.solid = 1 /* Trigger */;
+  trigger.mins = { x: entity.mins.x + 25, y: entity.mins.y + 25, z: entity.maxs.z };
+  trigger.maxs = { x: entity.maxs.x - 25, y: entity.maxs.y - 25, z: entity.maxs.z + 8 };
+  trigger.touch = (t, other) => {
+    if (entity.state === 1 /* Down */) {
+      entity.use?.(entity, other, other);
+    }
+  };
+};
+var func_rotating = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  if (!entity.speed) {
+    entity.speed = 100;
+  }
+  if (entity.spawnflags & 4) {
+    entity.avelocity = { x: entity.speed, y: 0, z: 0 };
+  } else if (entity.spawnflags & 8) {
+    entity.avelocity = { x: 0, y: entity.speed, z: 0 };
+  } else {
+    entity.avelocity = { x: 0, y: 0, z: entity.speed };
+  }
+  if (entity.dmg) {
+    entity.blocked = (self, other) => {
+      if (other && other.takedamage) {
+        other.health -= self.dmg;
+      }
+    };
+  }
+};
+var func_conveyor = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  if (!entity.speed) entity.speed = 100;
+  entity.movetype = 0 /* None */;
+};
+var func_water = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+};
+var func_explosive = (entity, context) => {
+  entity.solid = 3 /* Bsp */;
+  entity.movetype = 2 /* Push */;
+  if (!entity.health) entity.health = 100;
+  if (!entity.dmg) entity.dmg = 120;
+  entity.takedamage = true;
+  entity.die = (self, inflictor, attacker, damage) => {
+    context.entities.free(self);
+  };
+};
+var func_killbox = (entity, context) => {
+  entity.solid = 0 /* Not */;
+  entity.movetype = 0 /* None */;
+  entity.use = (self) => {
+    context.entities.killBox(self);
+  };
+};
+var func_areaportal = (entity, context) => {
+  entity.use = (self, other, activator) => {
+    entity.state = entity.state === 0 /* Open */ ? 2 /* Closed */ : 0 /* Open */;
+  };
+};
 function registerFuncSpawns(registry) {
   registry.register("func_door", func_door);
   registry.register("func_button", func_button);
+  registry.register("func_train", func_train);
+  registry.register("func_plat", func_plat);
+  registry.register("func_rotating", func_rotating);
+  registry.register("func_conveyor", func_conveyor);
+  registry.register("func_water", func_water);
+  registry.register("func_explosive", func_explosive);
+  registry.register("func_killbox", func_killbox);
+  registry.register("func_areaportal", func_areaportal);
+}
+
+// src/entities/paths.ts
+function pathCornerTouch(self, other) {
+  if (other !== self.owner) {
+    return;
+  }
+}
+function registerPathSpawns(registry) {
+  registry.register("path_corner", (entity) => {
+    entity.solid = 0 /* Not */;
+    entity.touch = pathCornerTouch;
+  });
+}
+
+// src/entities/lights.ts
+function registerLightSpawns(registry) {
+  registry.register("light", (entity) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 0 /* Not */;
+  });
+  registry.register("light_mine1", (entity) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 0 /* Not */;
+  });
+  registry.register("light_mine2", (entity) => {
+    entity.movetype = 0 /* None */;
+    entity.solid = 0 /* Not */;
+  });
 }
 
 // src/entities/spawn.ts
@@ -3328,6 +3545,8 @@ function registerDefaultSpawns(game, registry) {
   registerMiscSpawns(registry);
   registerItemSpawns(game, registry);
   registerFuncSpawns(registry);
+  registerPathSpawns(registry);
+  registerLightSpawns(registry);
 }
 function createDefaultSpawnRegistry(game) {
   const registry = new SpawnRegistry();