313 lines
16 KiB
JavaScript
313 lines
16 KiB
JavaScript
#!/usr/bin/env node
|
|
import { createHash } from "node:crypto";
|
|
import { readFile, readdir, writeFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { projectRoot, readJson, sourceRootFor } from "./lib/recipe.mjs";
|
|
|
|
const DATA_START = 140;
|
|
const NPC_SIZE = 2224;
|
|
const TABLE_SIZE = 408;
|
|
const NPC_TYPE = 1;
|
|
const NPC_RACE = 176;
|
|
const NPC_SPELL_START = 568;
|
|
const NPC_SPELL_SIZE = 28;
|
|
const NPC_RESIST_START = 888;
|
|
const NPC_BOW_EQUIPMENT = 1260;
|
|
const NPC_ORNAMENT_EQUIPMENT = 1648;
|
|
const SPELL_COUNT = 8;
|
|
const FIX_FIELDS = [
|
|
"damageAttackCoefficient", "magicalDamageAttackCoefficient", "criticalLevelCoefficient", "damageLevelCoefficient",
|
|
"missLevelCoefficient", "secondHandMissCoefficient", "secondHandDamageCoefficient", "basePhysicalCritical",
|
|
"basePhysicalCriticalPower", "baseMagicalCritical", "baseMagicalCriticalPower", "magicDamageCoefficient",
|
|
"magicMagicalDamageCoefficient", "dotMagicalDamageCoefficient", "healingMagicalDamageCoefficient",
|
|
"healingDotMagicalDamageCoefficient", "baseRateCoefficient", "baseResistCoefficient", "levelRateCoefficient",
|
|
"levelResistCoefficient", "physicalHitBase", "physicalHitRange", "physicalHitAgility", "physicalDodgeAgility",
|
|
"magicalHitBase", "magicalHitRange", "magicalHitWisdom", "magicalDodgeAgility", "magicalDodgeWisdom",
|
|
"phantomRankCoefficient", "phantomLevelCoefficient",
|
|
];
|
|
const CLASS_IDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
const NPC_CLASS_IDS = [0, ...CLASS_IDS];
|
|
const STAT_NAMES = ["strength", "stamina", "intellect", "wisdom", "agility", "health", "mana"];
|
|
const GROWTH_NAMES = [
|
|
"baseStrengthLevelOne", "baseStaminaLevelOne", "baseIntellectLevelOne", "baseWisdomLevelOne",
|
|
"baseAgilityLevelOne", "baseHealthLevelOne", "baseManaLevelOne", "baseStrengthFlatGrowth",
|
|
"baseStaminaFlatGrowth", "baseIntellectFlatGrowth", "baseWisdomFlatGrowth", "baseAgilityFlatGrowth",
|
|
"baseHealthFlatGrowth", "baseManaFlatGrowth", "strengthGrowthRate", "staminaGrowthRate", "intellectGrowthRate",
|
|
"wisdomGrowthRate", "agilityGrowthRate", "healthGrowthRate", "manaGrowthRate", "hpStrength", "hpStamina",
|
|
"mpIntellect", "mpWisdom", "attackStrength", "attackIntellect", "attackAgility", "defenseStamina",
|
|
"baseHealthRecovery", "baseManaRecovery", "healthRecoveryStamina", "manaRecoveryWisdom",
|
|
"magicalAttackIntellect", "magicalDefenseWisdom",
|
|
];
|
|
|
|
const recipeDirectory = path.join(projectRoot, "scripts/runewaker-pipeline/recipes");
|
|
const recipes = await Promise.all((await readdir(recipeDirectory))
|
|
.filter((name) => name.endsWith("-population.json"))
|
|
.sort()
|
|
.map((name) => readJson(path.join(recipeDirectory, name))));
|
|
if (!recipes.length) throw new Error("No population recipes found.");
|
|
const sourceRoot = sourceRootFor(recipes[0]);
|
|
const dataRoot = path.join(sourceRoot, recipes[0].source.resourceRoot ?? "Resource", "data");
|
|
const readSource = (name) => readFile(path.join(dataRoot, name));
|
|
const [npcDb, collectDb, magicDb, vocDb, raceDb, sexDb, fixDb, skillBaseDb, jobSkillDb] = await Promise.all([
|
|
readSource("npcobject.db"), readSource("magiccollectobject.db"), readSource("magicobject.db"),
|
|
readSource("voctable.db"), readSource("racetable.db"), readSource("sextable.db"), readSource("fixtable.db"),
|
|
readSource("skillbasetable.db"), readSource("jobskill.db"),
|
|
]);
|
|
const sha256 = (buffer) => createHash("sha256").update(buffer).digest("hex");
|
|
const int32 = (buffer, offset) => buffer.readInt32LE(offset);
|
|
const float32 = (buffer, offset) => {
|
|
const value = buffer.readFloatLE(offset);
|
|
if (!Number.isFinite(value)) throw new Error(`Non-finite native source float at ${offset}.`);
|
|
return Number(value.toFixed(6));
|
|
};
|
|
function fixedRecords(buffer, size, type, label) {
|
|
const count = int32(buffer, 132);
|
|
if (count <= 0 || DATA_START + count * size > buffer.length) throw new Error(`${label} fixed record layout changed.`);
|
|
if (type !== null) {
|
|
for (const i of [0, Math.floor(count / 2), count - 1]) {
|
|
if (int32(buffer, DATA_START + i * size + 4) !== type) throw new Error(`${label} type sentinel drifted.`);
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
function indexById(buffer, size, count) {
|
|
const result = new Map();
|
|
for (let i = 0; i < count; i += 1) {
|
|
const offset = DATA_START + i * size;
|
|
const id = int32(buffer, offset);
|
|
if (id > 0) result.set(id, offset);
|
|
}
|
|
return result;
|
|
}
|
|
const npcCount = fixedRecords(npcDb, NPC_SIZE, NPC_TYPE, "NPCObjectDB");
|
|
const collectCount = fixedRecords(collectDb, 1032, 21, "MagicCollectObjectDB");
|
|
const magicCount = fixedRecords(magicDb, 992, 3, "MagicObjectDB");
|
|
const npcOffsets = indexById(npcDb, NPC_SIZE, npcCount);
|
|
const collectOffsets = indexById(collectDb, 1032, collectCount);
|
|
const magicOffsets = indexById(magicDb, 992, magicCount);
|
|
|
|
function npcRow(id) {
|
|
const offset = npcOffsets.get(id);
|
|
if (offset === undefined || int32(npcDb, offset + 4) !== NPC_TYPE) throw new Error(`Missing NPCObjectDB row ${id}.`);
|
|
const int = (delta) => int32(npcDb, offset + delta);
|
|
const spells = [];
|
|
for (let slot = 0; slot < SPELL_COUNT; slot += 1) {
|
|
const start = offset + NPC_SPELL_START + slot * NPC_SPELL_SIZE;
|
|
const sourceSkillId = int32(npcDb, start + 12);
|
|
const magicLevel = int32(npcDb, start + 16);
|
|
if (sourceSkillId <= 0 || !collectOffsets.has(sourceSkillId)) continue;
|
|
spells.push({ slot, rightTime: int32(npcDb, start), targetType: int32(npcDb, start + 4), rate: int32(npcDb, start + 8), sourceSkillId, magicLevel });
|
|
}
|
|
return {
|
|
npcId: id,
|
|
raceId: int(NPC_RACE),
|
|
vocationId: int(NPC_RACE + 4),
|
|
vocationSubId: int(NPC_RACE + 8),
|
|
sexId: int(NPC_RACE + 12),
|
|
level: int(NPC_RACE + 24),
|
|
levelRange: int(NPC_RACE + 28),
|
|
authoredAttributes: {
|
|
strength: int(NPC_RACE + 32), stamina: int(NPC_RACE + 36), intellect: int(NPC_RACE + 40),
|
|
wisdom: int(NPC_RACE + 44), agility: int(NPC_RACE + 48),
|
|
},
|
|
nativeMagicResistances: Array.from({ length: 6 }, (_, type) => float32(npcDb, offset + NPC_RESIST_START + type * 4)),
|
|
// RD_Setting chooses rand()%5: keep zero rows and duplicates so later
|
|
// equipment resolution can preserve the source candidate distribution.
|
|
mainHandEquipmentIds: Array.from({ length: 5 }, (_, i) => int(412 + i * 4)),
|
|
offHandEquipmentIds: Array.from({ length: 5 }, (_, i) => int(432 + i * 4)),
|
|
bowEquipmentId: int(NPC_BOW_EQUIPMENT),
|
|
ornamentEquipmentId: int(NPC_ORNAMENT_EQUIPMENT),
|
|
spellBindings: spells.map((spell) => ({ ...spell, ...collectBinding(spell.sourceSkillId) })),
|
|
};
|
|
}
|
|
|
|
function componentDescriptor(componentId) {
|
|
const offset = magicOffsets.get(componentId);
|
|
if (offset === undefined) return null;
|
|
const settingFlags = int32(magicDb, offset + 0xd8);
|
|
const settingExFlags = int32(magicDb, offset + 988);
|
|
return {
|
|
componentId,
|
|
magicFunc: int32(magicDb, offset + 0xb0),
|
|
magicType: int32(magicDb, offset + 0xb4),
|
|
effectType: int32(magicDb, offset + 0xb8),
|
|
effectTimeSeconds: float32(magicDb, offset + 0xbc),
|
|
levelDeltaEffectTime: float32(magicDb, offset + 0xc0),
|
|
effectTimeSkillLevelArg: float32(magicDb, offset + 0xc4),
|
|
maxBuffLevelBase: int32(magicDb, offset + 0xcc),
|
|
maxBuffLevelSkillArg: float32(magicDb, offset + 0xd0),
|
|
settingFlags,
|
|
isDotMagic: (settingFlags & (1 << 3)) !== 0,
|
|
isShowPowerLv: (settingFlags & (1 << 14)) !== 0,
|
|
isNoKill: (settingFlags & (1 << 15)) !== 0,
|
|
isTargetBound: (settingFlags & (1 << 17)) !== 0,
|
|
isFixDotPower: (settingFlags & (1 << 20)) !== 0,
|
|
dotTimeSeconds: int32(magicDb, offset + 0x184),
|
|
dotType: int32(magicDb, offset + 0x188),
|
|
dotBase: int32(magicDb, offset + 0x18c),
|
|
dotSkillLevelArg: float32(magicDb, offset + 0x190),
|
|
attackType: int32(magicDb, offset + 0x194),
|
|
damagePower: float32(magicDb, offset + 0x198),
|
|
damagePowerSkillLevelArg: float32(magicDb, offset + 0x19c),
|
|
fixedValue: float32(magicDb, offset + 0x1a0),
|
|
fixedType: int32(magicDb, offset + 0x1a4),
|
|
fixedDamageSkillLevelArg: float32(magicDb, offset + 0x1a8),
|
|
randomRange: float32(magicDb, offset + 0x1ac),
|
|
criticalRate: int32(magicDb, offset + 0x1b0),
|
|
calculationType: int32(magicDb, offset + 0x2d4),
|
|
buffMaxLevel: int32(magicDb, offset + 0x3b4),
|
|
ignoreMagicAbsorb: (settingExFlags & 1) !== 0,
|
|
rawSettingExFlags: settingExFlags,
|
|
isFixDmgEffect: false,
|
|
};
|
|
}
|
|
|
|
function collectBinding(sourceSkillId) {
|
|
const offset = collectOffsets.get(sourceSkillId);
|
|
if (offset === undefined) return { missingSource: true, components: [] };
|
|
const componentIds = new Set();
|
|
for (let field = 0x180; field <= 0x2c0; field += 4) {
|
|
const id = int32(collectDb, offset + field);
|
|
if (magicOffsets.has(id)) componentIds.add(id);
|
|
}
|
|
const rawCollectMode = int32(collectDb, offset + 0x368);
|
|
return {
|
|
magicCollect: {
|
|
effectType: int32(collectDb, offset + 0xb4),
|
|
rangeType: int32(collectDb, offset + 0xc4),
|
|
decreaseArg: int32(collectDb, offset + 0xcc),
|
|
hitRateFunc: int32(collectDb, offset + 0xd4),
|
|
hitRateArgs: [float32(collectDb, offset + 0xd8), float32(collectDb, offset + 0xdc)],
|
|
spellTimeSeconds: float32(collectDb, offset + 0x114),
|
|
rawSettingExFlags: int32(collectDb, offset + 0x110),
|
|
rawCollectMode,
|
|
isFixDmgEffect: (rawCollectMode & (1 << 16)) !== 0,
|
|
isShareDamage: (rawCollectMode & (1 << 18)) !== 0,
|
|
},
|
|
components: [...componentIds].sort((a, b) => a - b).map(componentDescriptor).filter(Boolean),
|
|
};
|
|
}
|
|
|
|
const entityIdToNpcId = {};
|
|
const npcIds = new Set();
|
|
for (const recipe of recipes) {
|
|
const generatedPath = path.join(projectRoot, recipe.files.generatedSource);
|
|
const generated = await readFile(generatedPath, "utf8");
|
|
const runtimePrefix = recipe.runtimeIdPrefix ?? `rw-${recipe.dungeonId}`;
|
|
const entityPattern = new RegExp(`"(${runtimePrefix}-([0-9]+))"\\s*:`, "g");
|
|
for (const match of generated.matchAll(entityPattern)) {
|
|
const entityId = match[1];
|
|
const npcId = Number(match[2]);
|
|
if (!Number.isSafeInteger(npcId) || npcId <= 0) throw new Error(`Invalid Runewaker NPC id in ${entityId}.`);
|
|
if (entityIdToNpcId[entityId] !== undefined && entityIdToNpcId[entityId] !== npcId) throw new Error(`Entity mapping collision for ${entityId}.`);
|
|
entityIdToNpcId[entityId] = npcId;
|
|
npcIds.add(npcId);
|
|
}
|
|
}
|
|
if (!npcIds.size) throw new Error("No generated population entity to NPC mappings were found.");
|
|
const npcs = [...npcIds].sort((a, b) => a - b).map(npcRow);
|
|
|
|
// Combat hit bindings are exported only for source rows already used by the
|
|
// native damage/periodic helpers. This preserves the bound skill/component
|
|
// pair without attempting to infer player hit rules from an ability label.
|
|
const playerDamageCatalog = await readJson(path.join(projectRoot, "src/game/generated/romNativeHolyHealBindings.generated.json"));
|
|
const playerPeriodicCatalog = await readJson(path.join(projectRoot, "src/game/generated/romNativePeriodicDamageBindings.generated.json"));
|
|
const playerSkillIds = new Set();
|
|
for (const ability of [...(playerDamageCatalog.attackBindings ?? []), ...(playerDamageCatalog.holyHealBindings ?? [])]) {
|
|
for (const rank of ability.ranks ?? []) if (Number.isSafeInteger(rank.sourceSkillId)) playerSkillIds.add(rank.sourceSkillId);
|
|
}
|
|
for (const ability of playerPeriodicCatalog.activeDamageBindings ?? []) {
|
|
for (const rank of ability.ranks ?? []) if (Number.isSafeInteger(rank.sourceSkillId)) playerSkillIds.add(rank.sourceSkillId);
|
|
}
|
|
const playerSpellBindings = [...playerSkillIds].sort((a, b) => a - b).map((sourceSkillId) => {
|
|
const binding = collectBinding(sourceSkillId);
|
|
return binding.missingSource ? null : { sourceSkillId, ...binding };
|
|
}).filter(Boolean);
|
|
|
|
const growthTable = (buffer, rowSize, count, expectedBase) => {
|
|
const rows = new Map();
|
|
for (let i = 0; i < count; i += 1) {
|
|
const offset = DATA_START + i * rowSize;
|
|
const id = int32(buffer, offset);
|
|
if (id < expectedBase) continue;
|
|
rows.set(id, Array.from({ length: 100 }, (_, index) => float32(buffer, offset + 8 + index * 4)));
|
|
}
|
|
return rows;
|
|
};
|
|
fixedRecords(vocDb, TABLE_SIZE, null, "VocationTable");
|
|
fixedRecords(raceDb, TABLE_SIZE, null, "RaceTable");
|
|
fixedRecords(sexDb, TABLE_SIZE, null, "SexTable");
|
|
fixedRecords(fixDb, TABLE_SIZE, null, "FixTable");
|
|
const vocCount = (vocDb.length - DATA_START) / TABLE_SIZE;
|
|
const raceCount = (raceDb.length - DATA_START) / TABLE_SIZE;
|
|
const sexCount = (sexDb.length - DATA_START) / TABLE_SIZE;
|
|
const fixCount = (fixDb.length - DATA_START) / TABLE_SIZE;
|
|
const vocRows = growthTable(vocDb, TABLE_SIZE, vocCount, 301000);
|
|
const raceRows = growthTable(raceDb, TABLE_SIZE, raceCount, 300000);
|
|
const sexRows = growthTable(sexDb, TABLE_SIZE, sexCount, 302000);
|
|
const fixRows = growthTable(fixDb, TABLE_SIZE, fixCount, 303000);
|
|
const growthFields = (values) => ({
|
|
growth: Object.fromEntries(STAT_NAMES.map((name, i) => [name, {
|
|
levelOne: values[i], flat: values[i + 7], percent: values[i + 14],
|
|
}])),
|
|
coefficients: Object.fromEntries(GROWTH_NAMES.slice(21).map((name, i) => [name, values[21 + i]])),
|
|
damageRate: values[43],
|
|
});
|
|
const npcClasses = Object.fromEntries(NPC_CLASS_IDS.map((id) => {
|
|
const values = vocRows.get(301000 + id * 2);
|
|
if (!values) throw new Error(`Missing NPC vocation row ${301000 + id * 2}.`);
|
|
return [id, { sourceRecordId: 301000 + id * 2, ...growthFields(values) }];
|
|
}));
|
|
const raceGrowth = Object.fromEntries([...raceRows].filter(([id]) => id >= 300000 && id <= 300031).map(([id, values]) => [id, growthFields(values)]));
|
|
const sexGrowth = Object.fromEntries([...sexRows].filter(([id]) => id >= 302000 && id <= 302004).map(([id, values]) => [id, growthFields(values)]));
|
|
const fix = (recordId) => {
|
|
const values = fixRows.get(recordId);
|
|
if (!values) throw new Error(`Missing FIX row ${recordId}.`);
|
|
return Object.fromEntries(FIX_FIELDS.map((name, i) => [name, values[i]]));
|
|
};
|
|
|
|
const skillBaseCount = int32(skillBaseDb, 132);
|
|
const jobSkillCount = int32(jobSkillDb, 132);
|
|
if (skillBaseCount !== 100 || jobSkillCount < 15) throw new Error("Skill table count drifted.");
|
|
const skillBaseRows = Array.from({ length: skillBaseCount }, (_, i) => {
|
|
const offset = DATA_START + i * 88;
|
|
if (int32(skillBaseDb, offset) !== 305000 + i) throw new Error(`SkillValueBase row ${i} drifted.`);
|
|
return Array.from({ length: 20 }, (_, j) => int32(skillBaseDb, offset + 8 + j * 4));
|
|
});
|
|
const jobSkillRows = Array.from({ length: jobSkillCount }, (_, i) => {
|
|
const offset = DATA_START + i * 136;
|
|
if (int32(jobSkillDb, offset) !== 306000 + i) throw new Error(`JobSkillValue row ${i} drifted.`);
|
|
return Array.from({ length: 32 }, (_, j) => int32(jobSkillDb, offset + 8 + j * 4));
|
|
});
|
|
const maxSkillByClass = Object.fromEntries(NPC_CLASS_IDS.map((classId) => [classId,
|
|
Array.from({ length: skillBaseCount }, (_, levelIndex) => Array.from({ length: 15 }, (_, skillId) => {
|
|
const skillType = jobSkillRows[skillId][classId];
|
|
if (!Number.isInteger(skillType) || skillType < 0 || skillType >= 20) throw new Error(`Invalid skill type ${skillType}.`);
|
|
return skillBaseRows[levelIndex][skillType];
|
|
})),
|
|
]));
|
|
|
|
const output = {
|
|
schemaVersion: 1,
|
|
source: {
|
|
npcObjectSha256: sha256(npcDb), magicCollectSha256: sha256(collectDb), magicObjectSha256: sha256(magicDb),
|
|
vocationTableSha256: sha256(vocDb), raceTableSha256: sha256(raceDb), sexTableSha256: sha256(sexDb),
|
|
fixTableSha256: sha256(fixDb), skillBaseTableSha256: sha256(skillBaseDb), jobSkillTableSha256: sha256(jobSkillDb),
|
|
npcRecordSize: NPC_SIZE, npcRaceOffset: NPC_RACE, npcSpellStartOffset: NPC_SPELL_START,
|
|
npcSpellStride: NPC_SPELL_SIZE, npcEquipmentOffsets: { mainHand: 412, offHand: 432 },
|
|
npcMagicResistanceOffset: NPC_RESIST_START,
|
|
npcFixedEquipmentOffsets: { bow: NPC_BOW_EQUIPMENT, ornament: NPC_ORNAMENT_EQUIPMENT },
|
|
npcClassFixTable: 0, playerFixTable: 1, playerSkillPolicy: "simulator-max-trained-by-source-tables",
|
|
playerBindingCatalogs: ["romNativeHolyHealBindings.generated.json", "romNativePeriodicDamageBindings.generated.json"],
|
|
},
|
|
sourceRules: {
|
|
npcClasses, raceGrowth, sexGrowth, npcFix: fix(303000), playerFix: fix(303001), maxSkillByClass,
|
|
npcLevelClamp: 200, growthFormulaMaxSourceLevel: 200, maxSkillTableLevel: skillBaseCount,
|
|
},
|
|
entityIdToNpcId,
|
|
npcs,
|
|
playerSpellBindings,
|
|
};
|
|
await writeFile(path.join(projectRoot, "src/game/generated/romNativeCombatData.generated.json"), `${JSON.stringify(output)}\n`);
|
|
console.log(`Exported ${npcs.length} NPC rows and ${Object.keys(entityIdToNpcId).length} exact population entity→NPC mappings.`);
|