quake2ts 0.0.43 → 0.0.45

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

@@ -2625,6 +2625,150 @@ function summarizeRereleaseSave(raw) {
     highestEntityIndex: highestEntityIndex >= 0 ? highestEntityIndex : void 0
   };
 }
+var SERIALIZABLE_FIELD_NAMES = new Set(
+  ENTITY_FIELD_METADATA.filter((field) => field.save).map((field) => field.name)
+);
+function toVec3(value, label) {
+  if (!Array.isArray(value) || value.length !== 3) {
+    throw new Error(`${label} must be a vec3 array`);
+  }
+  const [x, y, z] = value;
+  return [ensureNumber2(x, `${label}[0]`), ensureNumber2(y, `${label}[1]`), ensureNumber2(z, `${label}[2]`)];
+}
+function normalizeEntityFields(raw, label) {
+  const fields = {};
+  for (const [rawName, value] of Object.entries(raw)) {
+    const name = rawName;
+    if (!SERIALIZABLE_FIELD_NAMES.has(name)) {
+      continue;
+    }
+    if (value === null) {
+      fields[name] = null;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      fields[name] = toVec3(value, `${label}.${name}`);
+      continue;
+    }
+    switch (typeof value) {
+      case "number":
+      case "string":
+      case "boolean":
+        fields[name] = value;
+        break;
+      default:
+        throw new Error(`Unsupported field type for ${label}.${name}`);
+    }
+  }
+  return fields;
+}
+function buildEntitySnapshot(entities, levelTimeSeconds, capacityHint) {
+  let highestIndex = 0;
+  const active = /* @__PURE__ */ new Set();
+  const activeOrder = [];
+  const serialized = [];
+  for (const [index, entry] of entities.entries()) {
+    if (index > highestIndex) {
+      highestIndex = index;
+    }
+    const inUse = entry.inuse !== false;
+    if (!inUse) {
+      continue;
+    }
+    if (!active.has(index)) {
+      activeOrder.push(index);
+    }
+    active.add(index);
+    serialized.push({ index, fields: normalizeEntityFields(entry, `entities[${index}]`) });
+  }
+  if (!active.has(0)) {
+    active.add(0);
+    activeOrder.unshift(0);
+    serialized.unshift({ index: 0, fields: { classname: "worldspawn" } });
+  }
+  const capacity = Math.max(capacityHint ?? 0, highestIndex + 1, Math.max(...active) + 1);
+  const freeList = [];
+  for (let i = 0; i < capacity; i += 1) {
+    if (!active.has(i)) {
+      freeList.push(i);
+    }
+  }
+  return {
+    timeSeconds: levelTimeSeconds,
+    pool: { capacity, activeOrder, freeList, pendingFree: [] },
+    entities: serialized,
+    thinks: []
+  };
+}
+function buildLevelState(level) {
+  const timeSeconds = typeof level.time === "number" ? level.time : 0;
+  const frameNumber = typeof level.framenum === "number" ? level.framenum : 0;
+  const deltaSeconds = typeof level.frametime === "number" ? level.frametime : 0;
+  const previousTimeSeconds = timeSeconds - deltaSeconds;
+  return { frameNumber, timeSeconds, previousTimeSeconds, deltaSeconds };
+}
+function convertRereleaseLevelToGameSave(save, options = {}) {
+  const { timestamp = Date.now(), defaultDifficulty = 1, defaultPlaytimeSeconds, rngState, configstrings = [] } = options;
+  const levelName = save.level.mapname ?? "unknown";
+  const level = buildLevelState(save.level);
+  const playtimeSeconds = defaultPlaytimeSeconds ?? level.timeSeconds;
+  return {
+    version: SAVE_FORMAT_VERSION,
+    timestamp,
+    map: levelName,
+    difficulty: defaultDifficulty,
+    playtimeSeconds,
+    gameState: { ...options.gameState ?? {}, rereleaseVersion: save.saveVersion },
+    level,
+    rng: rngState ? { mt: { index: rngState.mt.index, state: [...rngState.mt.state] } } : new RandomGenerator().getState(),
+    entities: buildEntitySnapshot(save.entities, level.timeSeconds, save.level.maxentities ?? void 0),
+    cvars: [],
+    configstrings: [...configstrings]
+  };
+}
+function convertRereleaseSaveToGameSave(save, options = {}) {
+  if ("game" in save) {
+    throw new Error("Game-wide rerelease saves are not currently supported for conversion");
+  }
+  return convertRereleaseLevelToGameSave(save, options);
+}
+function convertGameSaveToRereleaseLevel(save) {
+  const active = new Set(save.entities.pool.activeOrder);
+  const entities = /* @__PURE__ */ new Map();
+  for (const entity of save.entities.entities) {
+    if (!active.has(entity.index)) {
+      continue;
+    }
+    const fields = { inuse: true };
+    for (const [name, value] of Object.entries(entity.fields)) {
+      if (value === void 0) {
+        continue;
+      }
+      fields[name] = value;
+    }
+    entities.set(entity.index, fields);
+  }
+  return {
+    saveVersion: save.version,
+    level: {
+      mapname: save.map,
+      time: save.level.timeSeconds,
+      framenum: save.level.frameNumber,
+      frametime: save.level.deltaSeconds
+    },
+    entities
+  };
+}
+function serializeRereleaseSave(save) {
+  if ("game" in save) {
+    return { save_version: save.saveVersion, game: save.game, clients: save.clients };
+  }
+  const entities = {};
+  for (const [index, entity] of save.entities.entries()) {
+    entities[index.toString(10)] = entity;
+  }
+  return { save_version: save.saveVersion, level: save.level, entities };
+}
 
 // src/save/storage.ts
 var TEXT_ENCODER_CTOR = globalThis.TextEncoder;
@@ -3594,6 +3738,9 @@ export {
   clampAmmoCounts,
   classifyRange,
   clearExpiredPowerups,
+  convertGameSaveToRereleaseLevel,
+  convertRereleaseLevelToGameSave,
+  convertRereleaseSaveToGameSave,
   createAmmoInventory,
   createBaseAmmoCaps,
   createDefaultSpawnRegistry,
@@ -3622,6 +3769,7 @@ export {
   rangeTo,
   registerDefaultSpawns,
   selectWeapon,
+  serializeRereleaseSave,
   setMovedir,
   spawnEntitiesFromText,
   spawnEntityFromDictionary,