quake2ts 0.0.291 → 0.0.293

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

@@ -835,6 +835,7 @@ var init_esm = __esm({
       ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
       ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
       ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+      ConfigStringIndex2[ConfigStringIndex2["HealthBarName"] = 55] = "HealthBarName";
       ConfigStringIndex2[ConfigStringIndex2["CONFIG_N64_PHYSICS"] = 56] = "CONFIG_N64_PHYSICS";
       ConfigStringIndex2[ConfigStringIndex2["CONFIG_CTF_TEAMS"] = 57] = "CONFIG_CTF_TEAMS";
       ConfigStringIndex2[ConfigStringIndex2["CONFIG_COOP_RESPAWN_STRING"] = 58] = "CONFIG_COOP_RESPAWN_STRING";
@@ -2593,6 +2594,7 @@ var Entity = class {
     this.renderfx = 0;
     this.health = 0;
     this.max_health = 0;
+    this.spawn_count = 0;
     this.takedamage = false;
     this.dmg = 0;
     this.radius_dmg = 0;
@@ -2742,6 +2744,7 @@ var Entity = class {
     this.renderfx = 0;
     this.health = 0;
     this.max_health = 0;
+    this.spawn_count = 0;
     this.takedamage = false;
     this.dmg = 0;
     this.speed = 0;
@@ -2835,6 +2838,7 @@ var ENTITY_FIELD_METADATA = [
   { name: "renderfx", type: "int", save: true },
   { name: "health", type: "int", save: true },
   { name: "max_health", type: "int", save: true },
+  { name: "spawn_count", type: "int", save: true },
   { name: "takedamage", type: "boolean", save: true },
   { name: "dmg", type: "int", save: true },
   { name: "speed", type: "float", save: true },
@@ -4024,6 +4028,7 @@ var EntitySystem = class {
     this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
     this.frameNumber = 0;
+    this.spawnCount = 0;
     // Persistent state for cross-level logic
     this.crossLevelFlags = 0;
     this.crossUnitFlags = 0;
@@ -4062,6 +4067,8 @@ var EntitySystem = class {
       unicast: () => {
       },
       configstring: () => {
+      },
+      serverCommand: () => {
       }
     };
     this.imports = { ...defaultImports, ...imports };
@@ -4083,6 +4090,10 @@ var EntitySystem = class {
       sound2EntityFrame: 0,
       sightClient: null
     };
+    this.level = {
+      next_auto_save: 0,
+      health_bar_entities: [null, null, null, null]
+    };
   }
   get rng() {
     return this.random;
@@ -4131,6 +4142,8 @@ var EntitySystem = class {
   }
   spawn() {
     const ent = this.pool.spawn();
+    this.spawnCount++;
+    ent.spawn_count = this.spawnCount;
     ent.timestamp = this.currentTimeSeconds;
     return ent;
   }
@@ -4362,13 +4375,22 @@ var EntitySystem = class {
         sightClientIndex: this.targetAwareness.sightClient?.index ?? null
       },
       crossLevelFlags: this.crossLevelFlags,
-      crossUnitFlags: this.crossUnitFlags
+      crossUnitFlags: this.crossUnitFlags,
+      level: {
+        next_auto_save: this.level.next_auto_save,
+        health_bar_entities: [null, null, null, null]
+        // Transient
+      }
     };
   }
   restore(snapshot, callbackRegistry) {
     this.currentTimeSeconds = snapshot.timeSeconds;
     this.crossLevelFlags = snapshot.crossLevelFlags ?? 0;
     this.crossUnitFlags = snapshot.crossUnitFlags ?? 0;
+    if (snapshot.level) {
+      this.level = { ...snapshot.level };
+      this.level.health_bar_entities = [null, null, null, null];
+    }
     this.pool.restore(snapshot.pool);
     const indexToEntity = /* @__PURE__ */ new Map();
     for (const entity of this.pool) {
@@ -5760,6 +5782,82 @@ function registerTargetSpawns(registry) {
       entity.movedir = { x: start, y: end, z: slope };
     }
   });
+  registry.register("target_music", (entity, { entities, keyValues }) => {
+    entity.sounds = keyValues.sounds ? parseInt(keyValues.sounds) : 0;
+    entity.use = (self) => {
+      entities.imports.configstring(ConfigStringIndex.CdTrack, `${self.sounds}`);
+    };
+  });
+  registry.register("target_autosave", (entity, context) => {
+    entity.use = (self) => {
+      const saveTime = 60;
+      if (context.entities.timeSeconds - context.entities.level.next_auto_save > saveTime) {
+        context.entities.imports.serverCommand("autosave\n");
+        context.entities.level.next_auto_save = context.entities.timeSeconds;
+      }
+    };
+  });
+  registry.register("target_healthbar", (entity, { entities, warn, free }) => {
+    entity.use = (self) => {
+      const target = entities.pickTarget(self.target);
+      if (!target || self.health !== target.spawn_count) {
+        if (target) {
+          warn(`${self.classname}: target ${target.classname} changed from what it used to be`);
+        } else {
+          warn(`${self.classname}: no target`);
+        }
+        entities.free(self);
+        return;
+      }
+      const level = entities.level;
+      let found = false;
+      for (let i = 0; i < 4; i++) {
+        if (!level.health_bar_entities[i]) {
+          self.enemy = target;
+          level.health_bar_entities[i] = self;
+          entities.imports.configstring(ConfigStringIndex.HealthBarName, self.message || "");
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        warn(`${self.classname}: too many health bars`);
+        entities.free(self);
+      }
+    };
+    entity.think = (self) => {
+      const target = entities.pickTarget(self.target);
+      if (!target || !(target.svflags & 4 /* Monster */)) {
+        if (target) {
+          warn(`${self.classname}: target ${target.classname} does not appear to be a monster`);
+        }
+        entities.free(self);
+        return;
+      }
+      const level = entities.level;
+      if (level.health_bar_entities) {
+        let registered = false;
+        for (let i = 0; i < 4; i++) {
+          if (level.health_bar_entities[i] === self) {
+            registered = true;
+            break;
+          }
+        }
+        if (!registered) {
+          for (let i = 0; i < 4; i++) {
+            if (!level.health_bar_entities[i]) {
+              level.health_bar_entities[i] = self;
+              entities.imports.configstring(ConfigStringIndex.HealthBarName, self.message || "");
+              break;
+            }
+          }
+        }
+      }
+      self.health = target.spawn_count;
+      self.nextthink = entities.timeSeconds + 0.1;
+    };
+    entity.nextthink = entities.timeSeconds + 0.1;
+  });
 }
 
 // src/entities/triggers.ts
@@ -7545,40 +7643,80 @@ init_esm();
 // src/entities/gibs.ts
 init_esm();
 var random3 = createRandomGenerator();
+var GIB_ORGANIC = 0;
 var GIB_METALLIC = 1;
 var GIB_DEBRIS = 2;
-function spawnGib(sys, origin, damage, model, type) {
+function velocityForDamage(damage) {
+  let x = 100 * random3.crandom();
+  let y = 100 * random3.crandom();
+  let z = 200 + 100 * random3.frandom();
+  if (damage < 50) {
+    x *= 0.7;
+    y *= 0.7;
+    z *= 0.7;
+  } else {
+    x *= 1.2;
+    y *= 1.2;
+    z *= 1.2;
+  }
+  return { x, y, z };
+}
+function clipGibVelocity(ent) {
+  let { x, y, z } = ent.velocity;
+  if (x < -300) x = -300;
+  else if (x > 300) x = 300;
+  if (y < -300) y = -300;
+  else if (y > 300) y = 300;
+  if (z < 200) z = 200;
+  else if (z > 500) z = 500;
+  ent.velocity = { x, y, z };
+}
+function gib_touch(self, other, plane, surf, sys) {
+  if (!self.groundentity) return;
+  self.touch = void 0;
+  if (plane) {
+    sys.sound(self, 0, "misc/fhit3.wav", 1, 1, 0);
+  }
+}
+function spawnGib(sys, origin, damage, model, type = GIB_ORGANIC) {
   const gib = sys.spawn();
   gib.classname = "gib";
   gib.origin = {
-    x: origin.x + (random3.frandom() - 0.5) * 20,
-    y: origin.y + (random3.frandom() - 0.5) * 20,
-    z: origin.z + (random3.frandom() - 0.5) * 20
-  };
-  gib.velocity = {
-    x: (random3.frandom() - 0.5) * 300,
-    y: (random3.frandom() - 0.5) * 300,
-    z: 200 + random3.frandom() * 100
+    x: origin.x + random3.crandom() * 20,
+    y: origin.y + random3.crandom() * 20,
+    z: origin.z + random3.crandom() * 20
   };
-  gib.movetype = 9 /* Bounce */;
-  gib.solid = 0 /* Not */;
-  gib.clipmask = 1;
-  gib.avelocity = {
-    x: random3.crandom() * 600,
-    y: random3.crandom() * 600,
-    z: random3.crandom() * 600
-  };
-  const defaultModels = [
-    "models/objects/gibs/bone/tris.md2",
-    "models/objects/gibs/meat/tris.md2",
-    "models/objects/gibs/sm_meat/tris.md2"
-  ];
-  const modelName = model || defaultModels[Math.floor(random3.frandom() * defaultModels.length)];
+  const modelName = model || "models/objects/gibs/sm_meat/tris.md2";
   gib.modelindex = sys.modelIndex(modelName);
   gib.mins = { x: -2, y: -2, z: -2 };
   gib.maxs = { x: 2, y: 2, z: 2 };
-  if (type && type & GIB_METALLIC) {
+  gib.solid = 0 /* Not */;
+  gib.takedamage = true;
+  gib.die = (self, inflictor, attacker, dmg, point, mod) => {
+    sys.free(self);
+  };
+  gib.clipmask = 1;
+  let vscale = 1;
+  if (type === GIB_ORGANIC) {
+    gib.movetype = 7 /* Toss */;
+    gib.touch = (self, other, plane, surf) => gib_touch(self, other, plane, surf, sys);
+    vscale = 0.5;
+  } else {
+    gib.movetype = 9 /* Bounce */;
+    vscale = 1;
   }
+  const vd = velocityForDamage(damage);
+  gib.velocity = {
+    x: vd.x * vscale,
+    y: vd.y * vscale,
+    z: vd.z * vscale
+  };
+  clipGibVelocity(gib);
+  gib.avelocity = {
+    x: random3.frandom() * 600,
+    y: random3.frandom() * 600,
+    z: random3.frandom() * 600
+  };
   gib.think = (self) => {
     sys.free(self);
   };
@@ -7586,13 +7724,58 @@ function spawnGib(sys, origin, damage, model, type) {
   sys.finalizeSpawn(gib);
   return gib;
 }
+function spawnHead(sys, origin, damage) {
+  const head = sys.spawn();
+  let gibname;
+  if (random3.irandom(2) === 1) {
+    gibname = "models/objects/gibs/head2/tris.md2";
+    head.skin = 1;
+  } else {
+    gibname = "models/objects/gibs/skull/tris.md2";
+    head.skin = 0;
+  }
+  head.frame = 0;
+  head.modelindex = sys.modelIndex(gibname);
+  head.mins = { x: -16, y: -16, z: 0 };
+  head.maxs = { x: 16, y: 16, z: 16 };
+  head.origin = {
+    x: origin.x,
+    y: origin.y,
+    z: origin.z + 32
+  };
+  head.solid = 0 /* Not */;
+  head.takedamage = true;
+  head.die = (self, inflictor, attacker, dmg, point, mod) => {
+    sys.free(self);
+  };
+  let vscale = 0.5;
+  head.movetype = 7 /* Toss */;
+  head.touch = (self, other, plane, surf) => gib_touch(self, other, plane, surf, sys);
+  const vd = velocityForDamage(damage);
+  head.velocity = {
+    x: vd.x * vscale,
+    y: vd.y * vscale,
+    z: vd.z * vscale
+  };
+  clipGibVelocity(head);
+  head.avelocity = { x: 0, y: random3.crandom() * 600, z: 0 };
+  head.think = (self) => {
+    sys.free(self);
+  };
+  sys.scheduleThink(head, sys.timeSeconds + 10 + random3.frandom() * 10);
+  sys.finalizeSpawn(head);
+  return head;
+}
 function throwGibs(sys, origin, damageOrDefs) {
   if (typeof damageOrDefs === "number") {
     const damage = damageOrDefs;
-    const count = 4 + Math.floor(random3.frandom() * 4);
-    for (let i = 0; i < count; i++) {
-      spawnGib(sys, origin, damage);
-    }
+    spawnGib(sys, origin, damage, "models/objects/gibs/sm_meat/tris.md2", GIB_ORGANIC);
+    spawnGib(sys, origin, damage, "models/objects/gibs/sm_meat/tris.md2", GIB_ORGANIC);
+    spawnGib(sys, origin, damage, "models/objects/gibs/sm_meat/tris.md2", GIB_ORGANIC);
+    spawnGib(sys, origin, damage, "models/objects/gibs/sm_meat/tris.md2", GIB_ORGANIC);
+    spawnGib(sys, origin, damage, "models/objects/gibs/meat/tris.md2", GIB_ORGANIC);
+    spawnGib(sys, origin, damage, "models/objects/gibs/bone/tris.md2", GIB_ORGANIC);
+    spawnHead(sys, origin, damage);
   } else {
     const defs = damageOrDefs;
     for (const def of defs) {
@@ -18009,7 +18192,11 @@ function parseEntitySnapshot(raw) {
     thinks: parseThinkEntries(snapshot.thinks),
     awareness: parseAwareness(snapshot.awareness),
     crossLevelFlags: ensureNumberOrDefault(snapshot.crossLevelFlags, "entities.crossLevelFlags", 0),
-    crossUnitFlags: ensureNumberOrDefault(snapshot.crossUnitFlags, "entities.crossUnitFlags", 0)
+    crossUnitFlags: ensureNumberOrDefault(snapshot.crossUnitFlags, "entities.crossUnitFlags", 0),
+    level: {
+      next_auto_save: 0,
+      health_bar_entities: [null, null, null, null]
+    }
   };
 }
 function parseCvars(raw) {
@@ -18373,7 +18560,11 @@ function buildEntitySnapshot(entities, levelTimeSeconds, capacityHint) {
     thinks: [],
     awareness: dummyAwareness,
     crossLevelFlags: 0,
-    crossUnitFlags: 0
+    crossUnitFlags: 0,
+    level: {
+      next_auto_save: 0,
+      health_bar_entities: [null, null, null, null]
+    }
   };
 }
 function buildLevelState(level) {
@@ -19284,6 +19475,8 @@ function createGame(imports, engine, options) {
   });
   const configstring = imports.configstring || (() => {
   });
+  const serverCommand = imports.serverCommand || (() => {
+  });
   const linkentity = imports.linkentity;
   const wrappedLinkEntity = (ent) => {
     ent.absmin = {
@@ -19307,7 +19500,8 @@ function createGame(imports, engine, options) {
     linkentity: wrappedLinkEntity,
     multicast,
     unicast,
-    configstring
+    configstring,
+    serverCommand
   };
   const entities = new EntitySystem(engine, systemImports, gravity, void 0, void 0, deathmatch);
   entities._game = {
@@ -19575,6 +19769,9 @@ function createGame(imports, engine, options) {
     configstring(index, value) {
       configstring(index, value);
     },
+    serverCommand(cmd) {
+      serverCommand(cmd);
+    },
     get time() {
       return levelClock.current.timeSeconds;
     },