Release Healer Man 0.1.6

2026-08-20 14:05:50 -04:00
parent 55cfd43d66
commit b12fb84859
96 changed files with 10874 additions and 609 deletions
@@ -0,0 +1,194 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const projectRoot = path.resolve(import.meta.dirname, "..");
+const clientRoot = path.resolve(projectRoot, "..", "LadiksMPQEditor", "client-current");
+const spellPath = path.join(clientRoot, "area-52", "patch-D", "DBFilesClient", "Spell.dbc");
+const supportRoot = path.join(clientRoot, "patch-S", "DBFilesClient");
+const runtimePath = path.join(projectRoot, "src", "game", "generated", "coaAbilityRuntimeCatalog.json");
+const outputPath = path.join(projectRoot, "src", "game", "generated", "coaTriggeredSpellCatalog.json");
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function dbcNumberTable(filePath, valueField, floating = false) {
+  const buffer = fs.readFileSync(filePath);
+  assert(buffer.toString("ascii", 0, 4) === "WDBC", `${path.basename(filePath)} is not a WDBC file`);
+  const recordCount = buffer.readUInt32LE(4);
+  const recordSize = buffer.readUInt32LE(12);
+  return new Map(Array.from({ length: recordCount }, (_, index) => {
+    const base = 20 + index * recordSize;
+    return [
+      buffer.readUInt32LE(base),
+      floating ? buffer.readFloatLE(base + valueField * 4) : buffer.readInt32LE(base + valueField * 4),
+    ];
+  }));
+}
+
+function dbcRangeTable(filePath) {
+  const buffer = fs.readFileSync(filePath);
+  assert(buffer.toString("ascii", 0, 4) === "WDBC", `${path.basename(filePath)} is not a WDBC file`);
+  const recordCount = buffer.readUInt32LE(4);
+  const recordSize = buffer.readUInt32LE(12);
+  return new Map(Array.from({ length: recordCount }, (_, index) => {
+    const base = 20 + index * recordSize;
+    return [buffer.readUInt32LE(base), {
+      min: Math.max(0, buffer.readFloatLE(base + 4), buffer.readFloatLE(base + 8)),
+      max: Math.max(0, buffer.readFloatLE(base + 12), buffer.readFloatLE(base + 16)),
+    }];
+  }));
+}
+
+function referencedSpellIds(runtime) {
+  const ids = new Set();
+  const inspectEffects = (effects) => {
+    for (const effect of effects ?? []) {
+      if (effect.kind === "trigger-spell" && effect.spellId > 0) ids.add(effect.spellId);
+      if (effect.kind !== "apply-aura") continue;
+      for (const proc of effect.aura?.procs ?? []) {
+        const spellId = proc.action?.kind === "custom" ? proc.action.data?.spellId : 0;
+        if (typeof spellId === "number" && spellId > 0) ids.add(spellId);
+      }
+    }
+  };
+  for (const abilities of Object.values(runtime.abilitiesByClass)) {
+    for (const ability of abilities) {
+      inspectEffects(ability.effects);
+      for (const rank of ability.ranks ?? []) inspectEffects(rank.effects);
+    }
+  }
+  return ids;
+}
+
+function cleanText(value) {
+  return value.replace(/\r/g, "").replace(/\s+/g, " ").trim();
+}
+
+function spellParser(buffer, castTimes, durations, radii, ranges) {
+  assert(buffer.toString("ascii", 0, 4) === "WDBC", "Spell.dbc is not a WDBC file");
+  const recordCount = buffer.readUInt32LE(4);
+  const fieldCount = buffer.readUInt32LE(8);
+  const recordSize = buffer.readUInt32LE(12);
+  const stringSize = buffer.readUInt32LE(16);
+  assert(fieldCount >= 234 && recordSize >= fieldCount * 4, "Unexpected Spell.dbc schema");
+  const stringsOffset = 20 + recordCount * recordSize;
+  const offsets = new Map(Array.from({ length: recordCount }, (_, index) => {
+    const base = 20 + index * recordSize;
+    return [buffer.readUInt32LE(base), base];
+  }));
+  const readString = (offset) => {
+    if (!offset || offset >= stringSize) return "";
+    const start = stringsOffset + offset;
+    const end = buffer.indexOf(0, start);
+    return buffer.toString("utf8", start, end < 0 ? buffer.length : end);
+  };
+  return (id) => {
+    const base = offsets.get(id);
+    if (base === undefined) return null;
+    const unsigned = (field) => buffer.readUInt32LE(base + field * 4);
+    const signed = (field) => buffer.readInt32LE(base + field * 4);
+    const float = (field) => buffer.readFloatLE(base + field * 4);
+    const localized = (firstField) => {
+      for (let locale = 0; locale < 16; locale += 1) {
+        const value = readString(unsigned(firstField + locale));
+        if (value) return cleanText(value);
+      }
+      return "";
+    };
+    const effects = Array.from({ length: 3 }, (_, effectIndex) => ({
+      index: effectIndex,
+      effectType: unsigned(71 + effectIndex),
+      auraType: unsigned(95 + effectIndex),
+      basePoints: signed(80 + effectIndex) + 1,
+      dieSides: signed(74 + effectIndex),
+      pointsPerLevel: float(77 + effectIndex),
+      mechanic: unsigned(83 + effectIndex),
+      implicitTargetA: unsigned(86 + effectIndex),
+      implicitTargetB: unsigned(89 + effectIndex),
+      radiusIndex: unsigned(92 + effectIndex),
+      radius: radii.get(unsigned(92 + effectIndex)) ?? 0,
+      periodMs: unsigned(98 + effectIndex),
+      valueMultiplier: float(101 + effectIndex),
+      chainTargets: unsigned(104 + effectIndex),
+      itemType: unsigned(107 + effectIndex),
+      miscValue: signed(110 + effectIndex),
+      miscValueB: signed(113 + effectIndex),
+      triggerSpellId: unsigned(116 + effectIndex),
+      pointsPerCombo: float(119 + effectIndex),
+      coefficient: float(229 + effectIndex),
+    })).filter((effect) => effect.effectType || effect.auraType || effect.basePoints !== 1 || effect.triggerSpellId);
+    return {
+      id,
+      name: localized(136),
+      rankText: localized(153),
+      description: localized(170) || localized(187),
+      categoryId: unsigned(1),
+      dispelType: unsigned(2),
+      mechanic: unsigned(3),
+      attributes: Array.from({ length: 8 }, (_, index) => unsigned(4 + index)),
+      castTimeIndex: unsigned(28),
+      castTimeMs: Math.max(0, castTimes.get(unsigned(28)) ?? 0),
+      recoveryTimeMs: unsigned(29),
+      categoryRecoveryTimeMs: unsigned(30),
+      interruptFlags: unsigned(31),
+      auraInterruptFlags: unsigned(32),
+      channelInterruptFlags: unsigned(33),
+      procFlags: unsigned(34),
+      procChance: unsigned(35),
+      procCharges: unsigned(36),
+      maxLevel: unsigned(37),
+      baseLevel: unsigned(38),
+      spellLevel: unsigned(39),
+      durationIndex: unsigned(40),
+      durationMs: durations.get(unsigned(40)) ?? 0,
+      powerType: signed(41),
+      powerCost: unsigned(42),
+      powerCostPerLevel: unsigned(43),
+      powerCostPerSecond: unsigned(44),
+      powerCostPerSecondPerLevel: unsigned(45),
+      rangeIndex: unsigned(46),
+      rangeMin: ranges.get(unsigned(46))?.min ?? 0,
+      rangeMax: ranges.get(unsigned(46))?.max ?? 0,
+      projectileSpeed: float(47),
+      stackAmount: unsigned(49),
+      equippedItemClass: signed(67),
+      equippedItemSubclassMask: signed(68),
+      equippedItemInventoryMask: signed(69),
+      iconId: unsigned(133),
+      powerCostPercentage: unsigned(204),
+      startRecoveryCategory: unsigned(205),
+      startRecoveryTimeMs: unsigned(206),
+      maximumTargets: unsigned(212),
+      damageClass: unsigned(213),
+      preventionType: unsigned(214),
+      schoolMask: unsigned(225),
+      runeCostId: unsigned(226),
+      powerDisplayId: unsigned(228),
+      effects,
+    };
+  };
+}
+
+assert(fs.existsSync(spellPath), `CoA Spell.dbc was not found at ${spellPath}`);
+const runtime = JSON.parse(fs.readFileSync(runtimePath, "utf8"));
+const castTimes = dbcNumberTable(path.join(supportRoot, "SpellCastTimes.dbc"), 1);
+const durations = dbcNumberTable(path.join(supportRoot, "SpellDuration.dbc"), 3);
+const radii = dbcNumberTable(path.join(supportRoot, "SpellRadius.dbc"), 3, true);
+const ranges = dbcRangeTable(path.join(supportRoot, "SpellRange.dbc"));
+const parseSpell = spellParser(fs.readFileSync(spellPath), castTimes, durations, radii, ranges);
+const pending = [...referencedSpellIds(runtime)];
+const spells = new Map();
+while (pending.length) {
+  const id = pending.shift();
+  if (spells.has(id)) continue;
+  const spell = parseSpell(id);
+  if (!spell) continue;
+  spells.set(id, spell);
+  for (const effect of spell.effects) {
+    if (effect.triggerSpellId > 0 && !spells.has(effect.triggerSpellId)) pending.push(effect.triggerSpellId);
+  }
+}
+
+fs.writeFileSync(outputPath, `${JSON.stringify({ schemaVersion: 1, spells: [...spells.values()] })}\n`, "utf8");
+console.log(`Wrote ${outputPath} with ${spells.size} triggered spell records.`);