quake2ts 0.0.49 → 0.0.50

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

@@ -81,11 +81,13 @@ __export(index_exports, {
   convertRereleaseSaveToGameSave: () => convertRereleaseSaveToGameSave,
   createAmmoInventory: () => createAmmoInventory,
   createBaseAmmoCaps: () => createBaseAmmoCaps,
+  createCallbackRegistry: () => createCallbackRegistry,
   createDefaultSpawnRegistry: () => createDefaultSpawnRegistry,
   createGame: () => createGame,
   createPlayerInventory: () => createPlayerInventory,
   createSaveFile: () => createSaveFile,
   damageModName: () => damageModName,
+  deserializePlayerInventory: () => deserializePlayerInventory,
   equipArmor: () => equipArmor,
   facingIdeal: () => facingIdeal,
   findTarget: () => findTarget,
@@ -108,8 +110,10 @@ __export(index_exports, {
   parseSaveFile: () => parseSaveFile,
   pickupAmmo: () => pickupAmmo,
   rangeTo: () => rangeTo,
+  registerCallback: () => registerCallback,
   registerDefaultSpawns: () => registerDefaultSpawns,
   selectWeapon: () => selectWeapon,
+  serializePlayerInventory: () => serializePlayerInventory,
   serializeRereleaseSave: () => serializeRereleaseSave,
   setMovedir: () => setMovedir,
   spawnEntitiesFromText: () => spawnEntitiesFromText,
@@ -999,7 +1003,7 @@ function boundsIntersect(a, b) {
   return !(a.min.x > b.max.x || a.max.x < b.min.x || a.min.y > b.max.y || a.max.y < b.min.y || a.min.z > b.max.z || a.max.z < b.min.z);
 }
 var SERIALIZABLE_FIELDS = ENTITY_FIELD_METADATA.filter(
-  (field) => field.save
+  (field) => field.save || field.type === "callback"
 );
 var DESCRIPTORS = new Map(SERIALIZABLE_FIELDS.map((descriptor) => [descriptor.name, descriptor]));
 function serializeVec3(vec) {
@@ -1030,12 +1034,18 @@ function deserializeInventory(value) {
   return parsed;
 }
 var EntitySystem = class {
-  constructor(maxEntities) {
+  constructor(maxEntities, callbackRegistry) {
     this.targetNameIndex = /* @__PURE__ */ new Map();
     this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
     this.pool = new EntityPool(maxEntities);
     this.thinkScheduler = new ThinkScheduler();
+    this.callbackToName = /* @__PURE__ */ new Map();
+    if (callbackRegistry) {
+      for (const [name, fn] of callbackRegistry.entries()) {
+        this.callbackToName.set(fn, name);
+      }
+    }
   }
   get world() {
     return this.pool.world;
@@ -1160,6 +1170,9 @@ var EntitySystem = class {
           case "inventory":
             fields[descriptor.name] = serializeInventory(value);
             break;
+          case "callback":
+            fields[descriptor.name] = value ? this.callbackToName.get(value) ?? null : null;
+            break;
           default:
             fields[descriptor.name] = value ?? null;
             break;
@@ -1177,7 +1190,7 @@ var EntitySystem = class {
       thinks: this.thinkScheduler.snapshot()
     };
   }
-  restore(snapshot) {
+  restore(snapshot, callbackRegistry) {
     this.currentTimeSeconds = snapshot.timeSeconds;
     this.pool.restore(snapshot.pool);
     const indexToEntity = /* @__PURE__ */ new Map();
@@ -1212,6 +1225,14 @@ var EntitySystem = class {
           case "boolean":
             assignField(entity, name, Boolean(value));
             break;
+          case "callback":
+            if (value) {
+              const callback = callbackRegistry?.get(value);
+              if (callback) {
+                assignField(entity, name, callback);
+              }
+            }
+            break;
           default:
             assignField(entity, name, value);
             break;
@@ -2053,6 +2074,17 @@ function createDefaultSpawnRegistry() {
   return registry;
 }
 
+// src/entities/callbacks.ts
+function createCallbackRegistry() {
+  return /* @__PURE__ */ new Map();
+}
+function registerCallback(registry, name, fn) {
+  if (registry.has(name)) {
+    return;
+  }
+  registry.set(name, fn);
+}
+
 // src/loop.ts
 var orderedStageNames = [
   "prep",
@@ -2565,126 +2597,430 @@ function hashGameState(state) {
   return hash >>> 0;
 }
 
-// src/save/save.ts
-var SAVE_FORMAT_VERSION = 1;
-var MIN_SUPPORTED_VERSION = 1;
-function ensureObject(value, label) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${label} must be an object`);
-  }
-  return value;
+// src/inventory/ammo.ts
+var AmmoType = /* @__PURE__ */ ((AmmoType3) => {
+  AmmoType3[AmmoType3["Bullets"] = 0] = "Bullets";
+  AmmoType3[AmmoType3["Shells"] = 1] = "Shells";
+  AmmoType3[AmmoType3["Rockets"] = 2] = "Rockets";
+  AmmoType3[AmmoType3["Grenades"] = 3] = "Grenades";
+  AmmoType3[AmmoType3["Cells"] = 4] = "Cells";
+  AmmoType3[AmmoType3["Slugs"] = 5] = "Slugs";
+  return AmmoType3;
+})(AmmoType || {});
+var AMMO_TYPE_COUNT = Object.keys(AmmoType).length / 2;
+var AmmoItemId = /* @__PURE__ */ ((AmmoItemId3) => {
+  AmmoItemId3["Shells"] = "ammo_shells";
+  AmmoItemId3["Bullets"] = "ammo_bullets";
+  AmmoItemId3["Rockets"] = "ammo_rockets";
+  AmmoItemId3["Grenades"] = "ammo_grenades";
+  AmmoItemId3["Cells"] = "ammo_cells";
+  AmmoItemId3["Slugs"] = "ammo_slugs";
+  return AmmoItemId3;
+})(AmmoItemId || {});
+var AMMO_ITEM_DEFINITIONS = {
+  ["ammo_shells" /* Shells */]: { id: "ammo_shells" /* Shells */, ammoType: 1 /* Shells */, quantity: 10, weaponAmmo: false },
+  ["ammo_bullets" /* Bullets */]: { id: "ammo_bullets" /* Bullets */, ammoType: 0 /* Bullets */, quantity: 50, weaponAmmo: false },
+  ["ammo_rockets" /* Rockets */]: { id: "ammo_rockets" /* Rockets */, ammoType: 2 /* Rockets */, quantity: 5, weaponAmmo: false },
+  ["ammo_grenades" /* Grenades */]: { id: "ammo_grenades" /* Grenades */, ammoType: 3 /* Grenades */, quantity: 5, weaponAmmo: true },
+  ["ammo_cells" /* Cells */]: { id: "ammo_cells" /* Cells */, ammoType: 4 /* Cells */, quantity: 50, weaponAmmo: false },
+  ["ammo_slugs" /* Slugs */]: { id: "ammo_slugs" /* Slugs */, ammoType: 5 /* Slugs */, quantity: 10, weaponAmmo: false }
+};
+function getAmmoItemDefinition(id) {
+  return AMMO_ITEM_DEFINITIONS[id];
 }
-function ensureNumber(value, label) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error(`${label} must be a finite number`);
-  }
-  return value;
+function createAmmoInventory(caps = createBaseAmmoCaps()) {
+  return { caps: caps.slice(), counts: Array(AMMO_TYPE_COUNT).fill(0) };
 }
-function ensureNumberOrDefault(value, label, defaultValue) {
-  if (value === void 0) {
-    return defaultValue;
+function createBaseAmmoCaps() {
+  const caps = Array(AMMO_TYPE_COUNT).fill(50);
+  caps[0 /* Bullets */] = 200;
+  caps[1 /* Shells */] = 100;
+  caps[4 /* Cells */] = 200;
+  return caps;
+}
+function clampAmmoCounts(counts, caps) {
+  const limit = Math.min(counts.length, caps.length);
+  const clamped = counts.slice(0, limit);
+  for (let i = 0; i < limit; i++) {
+    const cap = caps[i];
+    if (cap !== void 0) {
+      clamped[i] = Math.min(counts[i], cap);
+    }
   }
-  return ensureNumber(value, label);
+  return clamped;
 }
-function ensureString(value, label) {
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a string`);
+function addAmmo(inventory, ammoType, amount) {
+  const cap = inventory.caps[ammoType];
+  const current = inventory.counts[ammoType] ?? 0;
+  if (cap !== void 0 && current >= cap) {
+    return { ammoType, added: 0, newCount: current, capped: cap, pickedUp: false };
   }
-  return value;
+  const uncapped = current + amount;
+  const newCount = cap === void 0 ? uncapped : Math.min(uncapped, cap);
+  const added = newCount - current;
+  inventory.counts[ammoType] = newCount;
+  return { ammoType, added, newCount, capped: cap ?? Number.POSITIVE_INFINITY, pickedUp: added > 0 };
 }
-function ensureNumberArray(value, label) {
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array`);
+function pickupAmmo(inventory, itemId, options = {}) {
+  const def = getAmmoItemDefinition(itemId);
+  const amount = options.countOverride ?? def.quantity;
+  return addAmmo(inventory, def.ammoType, amount);
+}
+
+// src/combat/damageFlags.ts
+var DamageFlags = /* @__PURE__ */ ((DamageFlags2) => {
+  DamageFlags2[DamageFlags2["NONE"] = 0] = "NONE";
+  DamageFlags2[DamageFlags2["RADIUS"] = 1] = "RADIUS";
+  DamageFlags2[DamageFlags2["NO_ARMOR"] = 2] = "NO_ARMOR";
+  DamageFlags2[DamageFlags2["ENERGY"] = 4] = "ENERGY";
+  DamageFlags2[DamageFlags2["NO_KNOCKBACK"] = 8] = "NO_KNOCKBACK";
+  DamageFlags2[DamageFlags2["BULLET"] = 16] = "BULLET";
+  DamageFlags2[DamageFlags2["NO_PROTECTION"] = 32] = "NO_PROTECTION";
+  DamageFlags2[DamageFlags2["DESTROY_ARMOR"] = 64] = "DESTROY_ARMOR";
+  DamageFlags2[DamageFlags2["NO_REG_ARMOR"] = 128] = "NO_REG_ARMOR";
+  DamageFlags2[DamageFlags2["NO_POWER_ARMOR"] = 256] = "NO_POWER_ARMOR";
+  DamageFlags2[DamageFlags2["NO_INDICATOR"] = 512] = "NO_INDICATOR";
+  return DamageFlags2;
+})(DamageFlags || {});
+function hasAnyDamageFlag(flags, mask) {
+  return (flags & mask) !== 0;
+}
+
+// src/combat/armor.ts
+var ArmorType = /* @__PURE__ */ ((ArmorType3) => {
+  ArmorType3["BODY"] = "body";
+  ArmorType3["COMBAT"] = "combat";
+  ArmorType3["JACKET"] = "jacket";
+  return ArmorType3;
+})(ArmorType || {});
+var ARMOR_INFO = {
+  ["jacket" /* JACKET */]: {
+    baseCount: 25,
+    maxCount: 50,
+    normalProtection: 0.3,
+    energyProtection: 0
+  },
+  ["combat" /* COMBAT */]: {
+    baseCount: 50,
+    maxCount: 100,
+    normalProtection: 0.6,
+    energyProtection: 0.3
+  },
+  ["body" /* BODY */]: {
+    baseCount: 100,
+    maxCount: 200,
+    normalProtection: 0.8,
+    energyProtection: 0.6
   }
-  for (const element of value) {
-    ensureNumber(element, `${label} element`);
+};
+function applyRegularArmor(damage, flags, state) {
+  if (damage <= 0 || hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 128 /* NO_REG_ARMOR */) || !state.armorType || state.armorCount <= 0) {
+    return { saved: 0, remainingArmor: state.armorCount };
   }
-  return value;
-}
-function parseLevelState(raw) {
-  if (raw === void 0) {
-    return { frameNumber: 0, timeSeconds: 0, previousTimeSeconds: 0, deltaSeconds: 0 };
+  const info = ARMOR_INFO[state.armorType];
+  const protection = hasAnyDamageFlag(flags, 4 /* ENERGY */) ? info.energyProtection : info.normalProtection;
+  let saved = Math.ceil(protection * damage);
+  if (saved >= state.armorCount) {
+    saved = state.armorCount;
   }
-  const level = ensureObject(raw, "level");
-  return {
-    frameNumber: ensureNumberOrDefault(level.frameNumber, "level.frameNumber", 0),
-    timeSeconds: ensureNumberOrDefault(level.timeSeconds, "level.timeSeconds", 0),
-    previousTimeSeconds: ensureNumberOrDefault(level.previousTimeSeconds, "level.previousTimeSeconds", 0),
-    deltaSeconds: ensureNumberOrDefault(level.deltaSeconds, "level.deltaSeconds", 0)
-  };
-}
-function parseRngState(raw) {
-  if (raw === void 0) {
-    return new RandomGenerator().getState();
+  if (saved <= 0) {
+    return { saved: 0, remainingArmor: state.armorCount };
   }
-  const rng = ensureObject(raw, "rng");
-  const mt = ensureObject(rng.mt, "rng.mt");
-  const state = ensureNumberArray(mt.state, "rng.mt.state");
-  return {
-    mt: {
-      index: ensureNumber(mt.index, "rng.mt.index"),
-      state
-    }
-  };
+  return { saved, remainingArmor: state.armorCount - saved };
 }
-function parseThinkEntries(raw) {
-  if (raw === void 0) {
-    return [];
+function applyPowerArmor(damage, flags, hitPoint, _hitNormal, state, options = {}) {
+  if (state.health <= 0 || damage <= 0) {
+    return { saved: 0, remainingCells: state.cellCount };
   }
-  if (!Array.isArray(raw)) {
-    throw new Error("thinks must be an array");
+  if (hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 256 /* NO_POWER_ARMOR */)) {
+    return { saved: 0, remainingCells: state.cellCount };
   }
-  return raw.map((entry, idx) => {
-    const think = ensureObject(entry, `thinks[${idx}]`);
-    return {
-      time: ensureNumber(think.time, `thinks[${idx}].time`),
-      entityIndex: ensureNumber(think.entityIndex, `thinks[${idx}].entityIndex`)
-    };
-  });
-}
-function parseEntityFields(raw) {
-  if (raw === void 0) {
-    return {};
+  if (!state.type || state.cellCount <= 0) {
+    return { saved: 0, remainingCells: state.cellCount };
   }
-  const fields = ensureObject(raw, "entity.fields");
-  const parsed = {};
-  for (const [name, value] of Object.entries(fields)) {
-    if (value === null) {
-      parsed[name] = null;
-      continue;
-    }
-    switch (typeof value) {
-      case "number":
-      case "string":
-      case "boolean":
-        parsed[name] = value;
-        break;
-      default: {
-        if (!Array.isArray(value)) {
-          const object = ensureObject(value, name);
-          const inventory = {};
-          for (const [entryName, entryValue] of Object.entries(object)) {
-            inventory[entryName] = ensureNumber(entryValue, `${name}.${entryName}`);
-          }
-          parsed[name] = inventory;
-          break;
-        }
-        if (Array.isArray(value) && value.length === 3) {
-          const [x, y, z] = value;
-          parsed[name] = [
-            ensureNumber(x, `${name}[0]`),
-            ensureNumber(y, `${name}[1]`),
-            ensureNumber(z, `${name}[2]`)
-          ];
-          break;
-        }
-        throw new Error(`Unsupported entity field value for ${name}`);
-      }
+  const { forward } = angleVectors(state.angles);
+  const toImpact = {
+    x: hitPoint.x - state.origin.x,
+    y: hitPoint.y - state.origin.y,
+    z: hitPoint.z - state.origin.z
+  };
+  const toImpactLength = Math.hypot(toImpact.x, toImpact.y, toImpact.z);
+  if (state.type === "screen" && toImpactLength > 0) {
+    const dir = {
+      x: toImpact.x / toImpactLength,
+      y: toImpact.y / toImpactLength,
+      z: toImpact.z / toImpactLength
+    };
+    const dot = dir.x * forward.x + dir.y * forward.y + dir.z * forward.z;
+    if (dot <= 0.3) {
+      return { saved: 0, remainingCells: state.cellCount };
     }
   }
-  return parsed;
-}
-function parseEntities(raw) {
+  const ctfMode = options.ctfMode ?? false;
+  const damagePerCell = state.type === "screen" ? 1 : ctfMode ? 1 : 2;
+  let adjustedDamage = state.type === "screen" ? damage / 3 : 2 * damage / 3;
+  adjustedDamage = Math.max(1, adjustedDamage);
+  let saved = state.cellCount * damagePerCell;
+  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
+    saved = Math.max(1, Math.floor(saved / 2));
+  }
+  if (saved > adjustedDamage) {
+    saved = Math.floor(adjustedDamage);
+  }
+  let powerUsed = saved / damagePerCell;
+  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
+    powerUsed *= 2;
+  }
+  powerUsed = Math.max(1, Math.floor(powerUsed));
+  const cellsSpent = Math.max(damagePerCell, powerUsed);
+  const remainingCells = Math.max(0, state.cellCount - cellsSpent);
+  return { saved, remainingCells };
+}
+
+// src/inventory/playerInventory.ts
+var WeaponId = /* @__PURE__ */ ((WeaponId2) => {
+  WeaponId2["Blaster"] = "blaster";
+  WeaponId2["Shotgun"] = "shotgun";
+  WeaponId2["SuperShotgun"] = "super_shotgun";
+  WeaponId2["Machinegun"] = "machinegun";
+  WeaponId2["Chaingun"] = "chaingun";
+  WeaponId2["GrenadeLauncher"] = "grenade_launcher";
+  WeaponId2["RocketLauncher"] = "rocket_launcher";
+  WeaponId2["HyperBlaster"] = "hyperblaster";
+  WeaponId2["Railgun"] = "railgun";
+  WeaponId2["BFG10K"] = "bfg10k";
+  return WeaponId2;
+})(WeaponId || {});
+var PowerupId = /* @__PURE__ */ ((PowerupId2) => {
+  PowerupId2["QuadDamage"] = "quad";
+  PowerupId2["Invulnerability"] = "invulnerability";
+  PowerupId2["EnviroSuit"] = "enviro_suit";
+  PowerupId2["Rebreather"] = "rebreather";
+  PowerupId2["Silencer"] = "silencer";
+  return PowerupId2;
+})(PowerupId || {});
+var KeyId = /* @__PURE__ */ ((KeyId2) => {
+  KeyId2["Blue"] = "blue";
+  KeyId2["Red"] = "red";
+  KeyId2["Green"] = "green";
+  KeyId2["Yellow"] = "yellow";
+  return KeyId2;
+})(KeyId || {});
+function createPlayerInventory(options = {}) {
+  const ammo = createAmmoInventory(options.ammoCaps);
+  const ownedWeapons = new Set(options.weapons ?? []);
+  const powerups = new Map(options.powerups ?? []);
+  const keys = new Set(options.keys ?? []);
+  return {
+    ammo,
+    ownedWeapons,
+    currentWeapon: options.currentWeapon,
+    armor: options.armor ?? null,
+    powerups,
+    keys
+  };
+}
+function giveAmmo(inventory, ammoType, amount) {
+  return addAmmo(inventory.ammo, ammoType, amount);
+}
+function giveAmmoItem(inventory, itemId, options) {
+  return pickupAmmo(inventory.ammo, itemId, options);
+}
+function giveWeapon(inventory, weapon, select = false) {
+  const hadWeapon = inventory.ownedWeapons.has(weapon);
+  inventory.ownedWeapons.add(weapon);
+  if (select || !inventory.currentWeapon) {
+    inventory.currentWeapon = weapon;
+  }
+  return !hadWeapon;
+}
+function hasWeapon(inventory, weapon) {
+  return inventory.ownedWeapons.has(weapon);
+}
+function selectWeapon(inventory, weapon) {
+  if (!inventory.ownedWeapons.has(weapon)) {
+    return false;
+  }
+  inventory.currentWeapon = weapon;
+  return true;
+}
+function equipArmor(inventory, armorType, amount) {
+  if (!armorType || amount <= 0) {
+    inventory.armor = null;
+    return null;
+  }
+  const info = ARMOR_INFO[armorType];
+  const armorCount = Math.min(amount, info.maxCount);
+  inventory.armor = { armorType, armorCount };
+  return inventory.armor;
+}
+function addPowerup(inventory, powerup, expiresAt) {
+  inventory.powerups.set(powerup, expiresAt);
+}
+function hasPowerup(inventory, powerup) {
+  return inventory.powerups.has(powerup);
+}
+function clearExpiredPowerups(inventory, nowMs) {
+  for (const [id, expiresAt] of inventory.powerups.entries()) {
+    if (expiresAt !== null && expiresAt <= nowMs) {
+      inventory.powerups.delete(id);
+    }
+  }
+}
+function addKey(inventory, key) {
+  const before = inventory.keys.size;
+  inventory.keys.add(key);
+  return inventory.keys.size > before;
+}
+function hasKey(inventory, key) {
+  return inventory.keys.has(key);
+}
+function serializePlayerInventory(inventory) {
+  return {
+    ammo: inventory.ammo.counts,
+    ownedWeapons: [...inventory.ownedWeapons],
+    currentWeapon: inventory.currentWeapon,
+    armor: inventory.armor ? { ...inventory.armor } : null,
+    powerups: [...inventory.powerups.entries()],
+    keys: [...inventory.keys]
+  };
+}
+function deserializePlayerInventory(serialized, options = {}) {
+  const ammo = createAmmoInventory(options.ammoCaps);
+  const limit = Math.min(ammo.counts.length, serialized.ammo.length);
+  for (let i = 0; i < limit; i++) {
+    ammo.counts[i] = serialized.ammo[i];
+  }
+  return {
+    ammo,
+    ownedWeapons: new Set(serialized.ownedWeapons),
+    currentWeapon: serialized.currentWeapon,
+    armor: serialized.armor ? { ...serialized.armor } : null,
+    powerups: new Map(serialized.powerups),
+    keys: new Set(serialized.keys)
+  };
+}
+
+// src/save/save.ts
+var SAVE_FORMAT_VERSION = 2;
+var MIN_SUPPORTED_VERSION = 1;
+function ensureObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  return value;
+}
+function ensureNumberOrDefault(value, label, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return ensureNumber(value, label);
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureNumberArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const element of value) {
+    ensureNumber(element, `${label} element`);
+  }
+  return value;
+}
+function parseLevelState(raw) {
+  if (raw === void 0) {
+    return { frameNumber: 0, timeSeconds: 0, previousTimeSeconds: 0, deltaSeconds: 0 };
+  }
+  const level = ensureObject(raw, "level");
+  return {
+    frameNumber: ensureNumberOrDefault(level.frameNumber, "level.frameNumber", 0),
+    timeSeconds: ensureNumberOrDefault(level.timeSeconds, "level.timeSeconds", 0),
+    previousTimeSeconds: ensureNumberOrDefault(level.previousTimeSeconds, "level.previousTimeSeconds", 0),
+    deltaSeconds: ensureNumberOrDefault(level.deltaSeconds, "level.deltaSeconds", 0)
+  };
+}
+function parseRngState(raw) {
+  if (raw === void 0) {
+    return new RandomGenerator().getState();
+  }
+  const rng = ensureObject(raw, "rng");
+  const mt = ensureObject(rng.mt, "rng.mt");
+  const state = ensureNumberArray(mt.state, "rng.mt.state");
+  return {
+    mt: {
+      index: ensureNumber(mt.index, "rng.mt.index"),
+      state
+    }
+  };
+}
+function parseThinkEntries(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("thinks must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const think = ensureObject(entry, `thinks[${idx}]`);
+    return {
+      time: ensureNumber(think.time, `thinks[${idx}].time`),
+      entityIndex: ensureNumber(think.entityIndex, `thinks[${idx}].entityIndex`)
+    };
+  });
+}
+function parseEntityFields(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  const fields = ensureObject(raw, "entity.fields");
+  const parsed = {};
+  for (const [name, value] of Object.entries(fields)) {
+    if (value === null) {
+      parsed[name] = null;
+      continue;
+    }
+    switch (typeof value) {
+      case "number":
+      case "string":
+      case "boolean":
+        parsed[name] = value;
+        break;
+      default: {
+        if (!Array.isArray(value)) {
+          const object = ensureObject(value, name);
+          const inventory = {};
+          for (const [entryName, entryValue] of Object.entries(object)) {
+            inventory[entryName] = ensureNumber(entryValue, `${name}.${entryName}`);
+          }
+          parsed[name] = inventory;
+          break;
+        }
+        if (Array.isArray(value) && value.length === 3) {
+          const [x, y, z] = value;
+          parsed[name] = [
+            ensureNumber(x, `${name}[0]`),
+            ensureNumber(y, `${name}[1]`),
+            ensureNumber(z, `${name}[2]`)
+          ];
+          break;
+        }
+        throw new Error(`Unsupported entity field value for ${name}`);
+      }
+    }
+  }
+  return parsed;
+}
+function parseEntities(raw) {
   if (!Array.isArray(raw)) {
     throw new Error("entities must be an array");
   }
@@ -2783,7 +3119,8 @@ function createSaveFile(options) {
     configstrings = [],
     cvars,
     gameState = {},
-    timestamp = Date.now()
+    timestamp = Date.now(),
+    player
   } = options;
   return {
     version: SAVE_FORMAT_VERSION,
@@ -2796,7 +3133,8 @@ function createSaveFile(options) {
     rng: cloneRngState(rngState),
     entities: entitySystem.createSnapshot(),
     cvars: serializeCvars(cvars),
-    configstrings: [...configstrings]
+    configstrings: [...configstrings],
+    player: player ? serializePlayerInventory(player) : void 0
   };
 }
 function parseSaveFile(serialized, options = {}) {
@@ -2822,14 +3160,19 @@ function parseSaveFile(serialized, options = {}) {
     rng: parseRngState(save.rng),
     entities: parseEntitySnapshot(save.entities),
     cvars: parseCvars(save.cvars),
-    configstrings: parseConfigstrings(save.configstrings)
+    configstrings: parseConfigstrings(save.configstrings),
+    player: save.player ? save.player : void 0
   };
 }
 function applySaveFile(save, targets) {
   targets.levelClock.restore(save.level);
-  targets.entitySystem.restore(save.entities);
+  targets.entitySystem.restore(save.entities, targets.callbackRegistry);
   targets.rng.setState(save.rng);
   applyCvars(save.cvars, targets.cvars);
+  if (save.player && targets.player) {
+    const deserialized = deserializePlayerInventory(save.player);
+    Object.assign(targets.player, deserialized);
+  }
 }
 
 // src/save/rerelease.ts
@@ -3221,116 +3564,6 @@ _SaveStorage.DEFAULT_STORE = "saves";
 _SaveStorage.QUICK_SLOT = "quicksave";
 var SaveStorage = _SaveStorage;
 
-// src/combat/damageFlags.ts
-var DamageFlags = /* @__PURE__ */ ((DamageFlags2) => {
-  DamageFlags2[DamageFlags2["NONE"] = 0] = "NONE";
-  DamageFlags2[DamageFlags2["RADIUS"] = 1] = "RADIUS";
-  DamageFlags2[DamageFlags2["NO_ARMOR"] = 2] = "NO_ARMOR";
-  DamageFlags2[DamageFlags2["ENERGY"] = 4] = "ENERGY";
-  DamageFlags2[DamageFlags2["NO_KNOCKBACK"] = 8] = "NO_KNOCKBACK";
-  DamageFlags2[DamageFlags2["BULLET"] = 16] = "BULLET";
-  DamageFlags2[DamageFlags2["NO_PROTECTION"] = 32] = "NO_PROTECTION";
-  DamageFlags2[DamageFlags2["DESTROY_ARMOR"] = 64] = "DESTROY_ARMOR";
-  DamageFlags2[DamageFlags2["NO_REG_ARMOR"] = 128] = "NO_REG_ARMOR";
-  DamageFlags2[DamageFlags2["NO_POWER_ARMOR"] = 256] = "NO_POWER_ARMOR";
-  DamageFlags2[DamageFlags2["NO_INDICATOR"] = 512] = "NO_INDICATOR";
-  return DamageFlags2;
-})(DamageFlags || {});
-function hasAnyDamageFlag(flags, mask) {
-  return (flags & mask) !== 0;
-}
-
-// src/combat/armor.ts
-var ArmorType = /* @__PURE__ */ ((ArmorType3) => {
-  ArmorType3["BODY"] = "body";
-  ArmorType3["COMBAT"] = "combat";
-  ArmorType3["JACKET"] = "jacket";
-  return ArmorType3;
-})(ArmorType || {});
-var ARMOR_INFO = {
-  ["jacket" /* JACKET */]: {
-    baseCount: 25,
-    maxCount: 50,
-    normalProtection: 0.3,
-    energyProtection: 0
-  },
-  ["combat" /* COMBAT */]: {
-    baseCount: 50,
-    maxCount: 100,
-    normalProtection: 0.6,
-    energyProtection: 0.3
-  },
-  ["body" /* BODY */]: {
-    baseCount: 100,
-    maxCount: 200,
-    normalProtection: 0.8,
-    energyProtection: 0.6
-  }
-};
-function applyRegularArmor(damage, flags, state) {
-  if (damage <= 0 || hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 128 /* NO_REG_ARMOR */) || !state.armorType || state.armorCount <= 0) {
-    return { saved: 0, remainingArmor: state.armorCount };
-  }
-  const info = ARMOR_INFO[state.armorType];
-  const protection = hasAnyDamageFlag(flags, 4 /* ENERGY */) ? info.energyProtection : info.normalProtection;
-  let saved = Math.ceil(protection * damage);
-  if (saved >= state.armorCount) {
-    saved = state.armorCount;
-  }
-  if (saved <= 0) {
-    return { saved: 0, remainingArmor: state.armorCount };
-  }
-  return { saved, remainingArmor: state.armorCount - saved };
-}
-function applyPowerArmor(damage, flags, hitPoint, _hitNormal, state, options = {}) {
-  if (state.health <= 0 || damage <= 0) {
-    return { saved: 0, remainingCells: state.cellCount };
-  }
-  if (hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 256 /* NO_POWER_ARMOR */)) {
-    return { saved: 0, remainingCells: state.cellCount };
-  }
-  if (!state.type || state.cellCount <= 0) {
-    return { saved: 0, remainingCells: state.cellCount };
-  }
-  const { forward } = angleVectors(state.angles);
-  const toImpact = {
-    x: hitPoint.x - state.origin.x,
-    y: hitPoint.y - state.origin.y,
-    z: hitPoint.z - state.origin.z
-  };
-  const toImpactLength = Math.hypot(toImpact.x, toImpact.y, toImpact.z);
-  if (state.type === "screen" && toImpactLength > 0) {
-    const dir = {
-      x: toImpact.x / toImpactLength,
-      y: toImpact.y / toImpactLength,
-      z: toImpact.z / toImpactLength
-    };
-    const dot = dir.x * forward.x + dir.y * forward.y + dir.z * forward.z;
-    if (dot <= 0.3) {
-      return { saved: 0, remainingCells: state.cellCount };
-    }
-  }
-  const ctfMode = options.ctfMode ?? false;
-  const damagePerCell = state.type === "screen" ? 1 : ctfMode ? 1 : 2;
-  let adjustedDamage = state.type === "screen" ? damage / 3 : 2 * damage / 3;
-  adjustedDamage = Math.max(1, adjustedDamage);
-  let saved = state.cellCount * damagePerCell;
-  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
-    saved = Math.max(1, Math.floor(saved / 2));
-  }
-  if (saved > adjustedDamage) {
-    saved = Math.floor(adjustedDamage);
-  }
-  let powerUsed = saved / damagePerCell;
-  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
-    powerUsed *= 2;
-  }
-  powerUsed = Math.max(1, Math.floor(powerUsed));
-  const cellsSpent = Math.max(damagePerCell, powerUsed);
-  const remainingCells = Math.max(0, state.cellCount - cellsSpent);
-  return { saved, remainingCells };
-}
-
 // src/combat/damage.ts
 var EntityDamageFlags = /* @__PURE__ */ ((EntityDamageFlags2) => {
   EntityDamageFlags2[EntityDamageFlags2["GODMODE"] = 1] = "GODMODE";
@@ -3733,175 +3966,6 @@ function killBox(teleporter, targets, options = {}) {
   return { events, cleared };
 }
 
-// src/inventory/ammo.ts
-var AmmoType = /* @__PURE__ */ ((AmmoType3) => {
-  AmmoType3[AmmoType3["Bullets"] = 0] = "Bullets";
-  AmmoType3[AmmoType3["Shells"] = 1] = "Shells";
-  AmmoType3[AmmoType3["Rockets"] = 2] = "Rockets";
-  AmmoType3[AmmoType3["Grenades"] = 3] = "Grenades";
-  AmmoType3[AmmoType3["Cells"] = 4] = "Cells";
-  AmmoType3[AmmoType3["Slugs"] = 5] = "Slugs";
-  return AmmoType3;
-})(AmmoType || {});
-var AMMO_TYPE_COUNT = Object.keys(AmmoType).length / 2;
-var AmmoItemId = /* @__PURE__ */ ((AmmoItemId3) => {
-  AmmoItemId3["Shells"] = "ammo_shells";
-  AmmoItemId3["Bullets"] = "ammo_bullets";
-  AmmoItemId3["Rockets"] = "ammo_rockets";
-  AmmoItemId3["Grenades"] = "ammo_grenades";
-  AmmoItemId3["Cells"] = "ammo_cells";
-  AmmoItemId3["Slugs"] = "ammo_slugs";
-  return AmmoItemId3;
-})(AmmoItemId || {});
-var AMMO_ITEM_DEFINITIONS = {
-  ["ammo_shells" /* Shells */]: { id: "ammo_shells" /* Shells */, ammoType: 1 /* Shells */, quantity: 10, weaponAmmo: false },
-  ["ammo_bullets" /* Bullets */]: { id: "ammo_bullets" /* Bullets */, ammoType: 0 /* Bullets */, quantity: 50, weaponAmmo: false },
-  ["ammo_rockets" /* Rockets */]: { id: "ammo_rockets" /* Rockets */, ammoType: 2 /* Rockets */, quantity: 5, weaponAmmo: false },
-  ["ammo_grenades" /* Grenades */]: { id: "ammo_grenades" /* Grenades */, ammoType: 3 /* Grenades */, quantity: 5, weaponAmmo: true },
-  ["ammo_cells" /* Cells */]: { id: "ammo_cells" /* Cells */, ammoType: 4 /* Cells */, quantity: 50, weaponAmmo: false },
-  ["ammo_slugs" /* Slugs */]: { id: "ammo_slugs" /* Slugs */, ammoType: 5 /* Slugs */, quantity: 10, weaponAmmo: false }
-};
-function getAmmoItemDefinition(id) {
-  return AMMO_ITEM_DEFINITIONS[id];
-}
-function createAmmoInventory(caps = createBaseAmmoCaps()) {
-  return { caps: caps.slice(), counts: Array(AMMO_TYPE_COUNT).fill(0) };
-}
-function createBaseAmmoCaps() {
-  const caps = Array(AMMO_TYPE_COUNT).fill(50);
-  caps[0 /* Bullets */] = 200;
-  caps[1 /* Shells */] = 100;
-  caps[4 /* Cells */] = 200;
-  return caps;
-}
-function clampAmmoCounts(counts, caps) {
-  const limit = Math.min(counts.length, caps.length);
-  const clamped = counts.slice(0, limit);
-  for (let i = 0; i < limit; i++) {
-    const cap = caps[i];
-    if (cap !== void 0) {
-      clamped[i] = Math.min(counts[i], cap);
-    }
-  }
-  return clamped;
-}
-function addAmmo(inventory, ammoType, amount) {
-  const cap = inventory.caps[ammoType];
-  const current = inventory.counts[ammoType] ?? 0;
-  if (cap !== void 0 && current >= cap) {
-    return { ammoType, added: 0, newCount: current, capped: cap, pickedUp: false };
-  }
-  const uncapped = current + amount;
-  const newCount = cap === void 0 ? uncapped : Math.min(uncapped, cap);
-  const added = newCount - current;
-  inventory.counts[ammoType] = newCount;
-  return { ammoType, added, newCount, capped: cap ?? Number.POSITIVE_INFINITY, pickedUp: added > 0 };
-}
-function pickupAmmo(inventory, itemId, options = {}) {
-  const def = getAmmoItemDefinition(itemId);
-  const amount = options.countOverride ?? def.quantity;
-  return addAmmo(inventory, def.ammoType, amount);
-}
-
-// src/inventory/playerInventory.ts
-var WeaponId = /* @__PURE__ */ ((WeaponId2) => {
-  WeaponId2["Blaster"] = "blaster";
-  WeaponId2["Shotgun"] = "shotgun";
-  WeaponId2["SuperShotgun"] = "super_shotgun";
-  WeaponId2["Machinegun"] = "machinegun";
-  WeaponId2["Chaingun"] = "chaingun";
-  WeaponId2["GrenadeLauncher"] = "grenade_launcher";
-  WeaponId2["RocketLauncher"] = "rocket_launcher";
-  WeaponId2["HyperBlaster"] = "hyperblaster";
-  WeaponId2["Railgun"] = "railgun";
-  WeaponId2["BFG10K"] = "bfg10k";
-  return WeaponId2;
-})(WeaponId || {});
-var PowerupId = /* @__PURE__ */ ((PowerupId2) => {
-  PowerupId2["QuadDamage"] = "quad";
-  PowerupId2["Invulnerability"] = "invulnerability";
-  PowerupId2["EnviroSuit"] = "enviro_suit";
-  PowerupId2["Rebreather"] = "rebreather";
-  PowerupId2["Silencer"] = "silencer";
-  return PowerupId2;
-})(PowerupId || {});
-var KeyId = /* @__PURE__ */ ((KeyId2) => {
-  KeyId2["Blue"] = "blue";
-  KeyId2["Red"] = "red";
-  KeyId2["Green"] = "green";
-  KeyId2["Yellow"] = "yellow";
-  return KeyId2;
-})(KeyId || {});
-function createPlayerInventory(options = {}) {
-  const ammo = createAmmoInventory(options.ammoCaps);
-  const ownedWeapons = new Set(options.weapons ?? []);
-  const powerups = new Map(options.powerups ?? []);
-  const keys = new Set(options.keys ?? []);
-  return {
-    ammo,
-    ownedWeapons,
-    currentWeapon: options.currentWeapon,
-    armor: options.armor ?? null,
-    powerups,
-    keys
-  };
-}
-function giveAmmo(inventory, ammoType, amount) {
-  return addAmmo(inventory.ammo, ammoType, amount);
-}
-function giveAmmoItem(inventory, itemId, options) {
-  return pickupAmmo(inventory.ammo, itemId, options);
-}
-function giveWeapon(inventory, weapon, select = false) {
-  const hadWeapon = inventory.ownedWeapons.has(weapon);
-  inventory.ownedWeapons.add(weapon);
-  if (select || !inventory.currentWeapon) {
-    inventory.currentWeapon = weapon;
-  }
-  return !hadWeapon;
-}
-function hasWeapon(inventory, weapon) {
-  return inventory.ownedWeapons.has(weapon);
-}
-function selectWeapon(inventory, weapon) {
-  if (!inventory.ownedWeapons.has(weapon)) {
-    return false;
-  }
-  inventory.currentWeapon = weapon;
-  return true;
-}
-function equipArmor(inventory, armorType, amount) {
-  if (!armorType || amount <= 0) {
-    inventory.armor = null;
-    return null;
-  }
-  const info = ARMOR_INFO[armorType];
-  const armorCount = Math.min(amount, info.maxCount);
-  inventory.armor = { armorType, armorCount };
-  return inventory.armor;
-}
-function addPowerup(inventory, powerup, expiresAt) {
-  inventory.powerups.set(powerup, expiresAt);
-}
-function hasPowerup(inventory, powerup) {
-  return inventory.powerups.has(powerup);
-}
-function clearExpiredPowerups(inventory, nowMs) {
-  for (const [id, expiresAt] of inventory.powerups.entries()) {
-    if (expiresAt !== null && expiresAt <= nowMs) {
-      inventory.powerups.delete(id);
-    }
-  }
-}
-function addKey(inventory, key) {
-  const before = inventory.keys.size;
-  inventory.keys.add(key);
-  return inventory.keys.size > before;
-}
-function hasKey(inventory, key) {
-  return inventory.keys.has(key);
-}
-
 // src/index.ts
 var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
 function createGame(engine, options) {
@@ -4030,11 +4094,13 @@ function createGame(engine, options) {
   convertRereleaseSaveToGameSave,
   createAmmoInventory,
   createBaseAmmoCaps,
+  createCallbackRegistry,
   createDefaultSpawnRegistry,
   createGame,
   createPlayerInventory,
   createSaveFile,
   damageModName,
+  deserializePlayerInventory,
   equipArmor,
   facingIdeal,
   findTarget,
@@ -4057,8 +4123,10 @@ function createGame(engine, options) {
   parseSaveFile,
   pickupAmmo,
   rangeTo,
+  registerCallback,
   registerDefaultSpawns,
   selectWeapon,
+  serializePlayerInventory,
   serializeRereleaseSave,
   setMovedir,
   spawnEntitiesFromText,