499 lines
25 KiB
TypeScript
499 lines
25 KiB
TypeScript
/**
|
||
* Read every monster row out of the real archives and check it survives the
|
||
* trip into the simulation's own shapes.
|
||
*
|
||
* The failure this exists to catch is silent, not loud. `MonStats.txt` has 255
|
||
* columns and a reader that misspells one gets `''` back rather than an error,
|
||
* so a wrong column name produces a monster with zero health and no damage
|
||
* instead of a crash. Counting rows is therefore not enough: the script asserts
|
||
* that the numbers are *present and plausible* for all 735 rows, and it spot
|
||
* checks seven monsters against values read by hand out of the table so that a
|
||
* column rename cannot pass unnoticed.
|
||
*
|
||
* Usage:
|
||
* npx tsx scripts/verify-monsters.ts [directory]
|
||
*/
|
||
import { MountedArchives } from '../src/mpq/mount.ts'
|
||
import { MpqArchive } from '../src/mpq/archive.ts'
|
||
import { fileSource } from '../src/mpq/file-source.ts'
|
||
import { cell, loadActTables } from '../src/game/acts.ts'
|
||
import {
|
||
monsterBudget,
|
||
monsterStatsOf,
|
||
planMonsterGroups,
|
||
readEliteModifiers,
|
||
readLevelMonsterPlan,
|
||
readMonsterKinds,
|
||
readMonsterArt,
|
||
readMonsterScaling,
|
||
monsterScaleFor,
|
||
readSuperUniques,
|
||
selectLevelTypes,
|
||
} from '../src/game/monsters.ts'
|
||
import type { Difficulty, MonsterKind } from '../src/game/monsters.ts'
|
||
import { Rng } from '../src/game/rng.ts'
|
||
|
||
const dir = process.argv[2] ?? 'samples/d2'
|
||
/** Mount order: later archives override earlier ones, exactly as the game loads them. */
|
||
const MOUNTS = ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']
|
||
|
||
let checks = 0
|
||
let failures = 0
|
||
|
||
/**
|
||
* Assert one expectation.
|
||
*
|
||
* @param ok - whether it held.
|
||
* @param message - what was checked.
|
||
*/
|
||
function check(ok: boolean, message: string): void {
|
||
checks += 1
|
||
if (!ok) failures += 1
|
||
console.log(` ${ok ? 'ok ' : 'FAIL'} ${message}`)
|
||
}
|
||
|
||
const archives = new MountedArchives()
|
||
for (const name of MOUNTS) {
|
||
try {
|
||
archives.add(name, await MpqArchive.open(await fileSource(`${dir}/${name}`)))
|
||
} catch (err) {
|
||
console.log(`skip ${name}: ${String(err)}`)
|
||
}
|
||
}
|
||
if (archives.size === 0) {
|
||
console.log(`no archives found in ${dir}`)
|
||
process.exit(2)
|
||
}
|
||
console.log(`== mounted ${String(archives.size)} archives ==`)
|
||
|
||
const tables = await loadActTables(archives)
|
||
console.log(`\n== tables ==`)
|
||
console.log(` MonStats.txt ${String(tables.monstats.rows.length)} rows, ${String(tables.monstats.header.length)} columns`)
|
||
console.log(` MonStats2.txt ${String(tables.monstats2.rows.length)} rows`)
|
||
console.log(` MonLvl.txt ${String(tables.monlvl.rows.length)} rows`)
|
||
console.log(` MonType.txt ${String(tables.montype.rows.length)} rows`)
|
||
console.log(` MonUMod.txt ${String(tables.monumod.rows.length)} rows`)
|
||
console.log(` SuperUniques.txt ${String(tables.superuniques.rows.length)} rows`)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Every column the reader names must exist in the header.
|
||
// ---------------------------------------------------------------------------
|
||
//
|
||
// This is the check that turns a typo from a silent zero into a failure. The
|
||
// list is the union of every column `readMonsterKinds` reads on any difficulty.
|
||
console.log(`\n== MonStats.txt columns present ==`)
|
||
const REQUIRED_COLUMNS = [
|
||
'Id', 'BaseId', 'NameStr', 'Code', 'MonType', 'AI',
|
||
'enabled', 'isSpawn', 'isMelee', 'rangedtype', 'npc', 'interact', 'inTown', 'boss', 'killable',
|
||
'Rarity', 'MinGrp', 'MaxGrp', 'Level', 'Level(N)', 'Level(H)',
|
||
'Velocity', 'Run', 'threat', 'aidist',
|
||
'minHP', 'maxHP', 'MinHP(N)', 'MaxHP(N)', 'MinHP(H)', 'MaxHP(H)',
|
||
'AC', 'AC(N)', 'AC(H)', 'Exp', 'Exp(N)', 'Exp(H)',
|
||
'A1MinD', 'A1MaxD', 'A1TH', 'A2MinD', 'A2MaxD', 'A2TH',
|
||
'ResDm', 'ResMa', 'ResFi', 'ResLi', 'ResCo', 'ResPo',
|
||
'TreasureClass1', 'TreasureClass2', 'TreasureClass3', 'TreasureClass4',
|
||
'minion1', 'minion2', 'SetBoss',
|
||
]
|
||
const missing = REQUIRED_COLUMNS.filter(name => !tables.monstats.header.includes(name))
|
||
check(missing.length === 0, `all ${String(REQUIRED_COLUMNS.length)} named columns exist${missing.length === 0 ? '' : `; missing ${missing.join(', ')}`}`)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Full-table mapping: every row becomes a kind, and every kind becomes stats.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== MonStats.txt → MonsterKind → MonsterStats ==`)
|
||
const ids = tables.monstats.rows.map(row => cell(tables.monstats, row, 'Id').trim()).filter(id => id !== '')
|
||
const kinds = readMonsterKinds(tables.monstats)
|
||
|
||
// `MonStats.txt` ships one duplicated row: `cr_lancer8` appears twice in 1.13c.
|
||
// Keying by `Id` therefore loses exactly one row, and that is correct — the
|
||
// duplicate is redundant, not a second monster. Naming it here means a *new*
|
||
// duplicate, which would be a real data problem, still fails this check.
|
||
const KNOWN_DUPLICATE_IDS = ['cr_lancer8']
|
||
const seen = new Map<string, number>()
|
||
for (const id of ids) seen.set(id, (seen.get(id) ?? 0) + 1)
|
||
const duplicates = [...seen].filter(([, count]) => count > 1).map(([id]) => id).sort()
|
||
check(
|
||
duplicates.join(',') === KNOWN_DUPLICATE_IDS.join(','),
|
||
`the only duplicated Id is the known ${KNOWN_DUPLICATE_IDS.join(', ')}${duplicates.join(',') === KNOWN_DUPLICATE_IDS.join(',') ? '' : `; found ${duplicates.join(', ')}`}`,
|
||
)
|
||
check(
|
||
kinds.size === ids.length - duplicates.length,
|
||
`every distinct Id became a kind (${String(kinds.size)} kinds from ${String(ids.length)} rows)`,
|
||
)
|
||
|
||
/** The player's walking speed in scene pixels, matching `act-scene.ts`. */
|
||
const WALK_SPEED = 170
|
||
|
||
let statFailures = 0
|
||
let spawnable = 0
|
||
let withHealth = 0
|
||
let withDamage = 0
|
||
const statRng = new Rng(1)
|
||
for (const kind of kinds.values()) {
|
||
const stats = monsterStatsOf(kind, statRng, WALK_SPEED, monsterScaleFor(readMonsterScaling(tables.monlvl), kind))
|
||
if (kind.enabled && kind.isSpawn && !kind.npc && !kind.inTown) spawnable += 1
|
||
if (kind.maxHp > 0) withHealth += 1
|
||
if (kind.attack1.maxDamage > 0) withDamage += 1
|
||
const sane =
|
||
stats.id === kind.id &&
|
||
stats.name !== '' &&
|
||
Number.isInteger(stats.hp) && stats.hp >= 1 &&
|
||
Number.isInteger(stats.damage) && stats.damage >= 1 &&
|
||
Number.isInteger(stats.speed) && stats.speed >= 1 &&
|
||
stats.cooldownTicks > 0 && stats.reach > 0 && stats.aggroRadius > 0 &&
|
||
stats.xp >= 0 &&
|
||
stats.hp <= Math.max(1, Math.max(kind.minHp, kind.maxHp) * 400)
|
||
if (!sane) {
|
||
statFailures += 1
|
||
if (statFailures <= 5) console.log(` ${kind.id}: ${JSON.stringify(stats)}`)
|
||
}
|
||
}
|
||
check(statFailures === 0, `all ${String(kinds.size)} kinds produce finite, in-range stats (${String(statFailures)} bad)`)
|
||
console.log(` info ${String(spawnable)} spawnable, ${String(withHealth)} with health, ${String(withDamage)} with A1 damage`)
|
||
|
||
// A table read with the wrong column names still yields rows — they are just
|
||
// all identical. Distinct health ranges prove the numbers are really being read.
|
||
const healthRanges = new Set([...kinds.values()].map(kind => `${String(kind.minHp)}-${String(kind.maxHp)}`))
|
||
check(healthRanges.size > 100, `health ranges are distinct per monster, not a shared default (${String(healthRanges.size)} distinct)`)
|
||
const codes = new Set([...kinds.values()].map(kind => kind.code).filter(code => code !== ''))
|
||
check(codes.size > 100, `art codes are distinct (${String(codes.size)} distinct)`)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Spot checks against values read by hand out of the 1.13c table.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== spot checks (hand-read from the 1.13c table) ==`)
|
||
interface Expected {
|
||
readonly id: string
|
||
readonly nameKey: string
|
||
readonly code: string
|
||
readonly monType: string
|
||
readonly ai: string
|
||
readonly minGroup: number
|
||
readonly maxGroup: number
|
||
readonly velocity: number
|
||
readonly minHp: number
|
||
readonly maxHp: number
|
||
readonly experience: number
|
||
}
|
||
const EXPECTED: readonly Expected[] = [
|
||
{ id: 'fallen1', nameKey: 'Fallen', code: 'FA', monType: 'fallen', ai: 'Fallen', minGroup: 2, maxGroup: 3, velocity: 5, minHp: 21, maxHp: 61, experience: 61 },
|
||
{ id: 'zombie1', nameKey: 'Zombie', code: 'ZM', monType: 'zombie', ai: 'Zombie', minGroup: 1, maxGroup: 2, velocity: 1, minHp: 101, maxHp: 181, experience: 111 },
|
||
{ id: 'skeleton1', nameKey: 'Skeleton', code: 'SK', monType: 'skeleton', ai: 'Skeleton', minGroup: 1, maxGroup: 3, velocity: 3, minHp: 86, maxHp: 129, experience: 86 },
|
||
{ id: 'quillrat1', nameKey: 'QuillRat', code: 'SI', monType: 'quillrat', ai: 'QuillRat', minGroup: 1, maxGroup: 2, velocity: 3, minHp: 21, maxHp: 81, experience: 71 },
|
||
{ id: 'foulcrow1', nameKey: 'FoulCrow', code: 'BK', monType: 'foulcrow', ai: 'BloodHawk', minGroup: 2, maxGroup: 4, velocity: 4, minHp: 19, maxHp: 46, experience: 37 },
|
||
{ id: 'corruptrogue1', nameKey: 'DarkHunter', code: 'CR', monType: 'corruptrogue', ai: 'CorruptRogue', minGroup: 2, maxGroup: 3, velocity: 5, minHp: 58, maxHp: 101, experience: 78 },
|
||
{ id: 'hellbovine', nameKey: 'Hell Bovine', code: 'EC', monType: 'bovine', ai: 'Skeleton', minGroup: 5, maxGroup: 10, velocity: 5, minHp: 133, maxHp: 285, experience: 140 },
|
||
]
|
||
for (const want of EXPECTED) {
|
||
const got = kinds.get(want.id)
|
||
if (got === undefined) {
|
||
check(false, `${want.id} exists`)
|
||
continue
|
||
}
|
||
const mismatches: string[] = []
|
||
const compare = (field: string, a: unknown, b: unknown): void => {
|
||
if (a !== b) mismatches.push(`${field} ${String(a)} ≠ ${String(b)}`)
|
||
}
|
||
compare('nameKey', got.nameKey, want.nameKey)
|
||
compare('code', got.code, want.code)
|
||
compare('monType', got.monType, want.monType)
|
||
compare('ai', got.ai, want.ai)
|
||
compare('minGroup', got.minGroup, want.minGroup)
|
||
compare('maxGroup', got.maxGroup, want.maxGroup)
|
||
compare('velocity', got.velocity, want.velocity)
|
||
compare('minHp', got.minHp, want.minHp)
|
||
compare('maxHp', got.maxHp, want.maxHp)
|
||
compare('experience', got.experience, want.experience)
|
||
check(mismatches.length === 0, `${want.id}${mismatches.length === 0 ? '' : `: ${mismatches.join('; ')}`}`)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Difficulty columns: the capitalisation trap.
|
||
// ---------------------------------------------------------------------------
|
||
//
|
||
// Normal is `minHP`; Nightmare and Hell are `MinHP(N)` and `MinHP(H)`. Reading
|
||
// the lower-case form on Nightmare returns nothing, which would show up as a
|
||
// Fallen with the same health on every difficulty.
|
||
console.log(`\n== difficulty columns are read, and are not a scaling ==`)
|
||
//
|
||
// The obvious assertion — "Nightmare health is higher" — is false in the data.
|
||
// `fallen1` is 21–61 on Normal and 25–55 on Nightmare, and 426 of the rows with
|
||
// health have a *lower* `MaxHP(N)` than `maxHP`. The difficulty columns are a
|
||
// boss-only override; ordinary monsters are scaled by `MonLvl.txt` instead.
|
||
// What can be asserted is that the columns are being read at all, rather than
|
||
// silently falling back to the Normal ones through a misspelling.
|
||
{
|
||
const normal = kinds.get('fallen1')
|
||
const nightmare = readMonsterKinds(tables.monstats, 'nightmare').get('fallen1')
|
||
const hell = readMonsterKinds(tables.monstats, 'hell').get('fallen1')
|
||
check(
|
||
normal !== undefined && nightmare !== undefined && hell !== undefined,
|
||
'fallen1 reads on all three difficulties',
|
||
)
|
||
check(
|
||
nightmare !== undefined && normal !== undefined && (nightmare.minHp !== normal.minHp || nightmare.maxHp !== normal.maxHp),
|
||
`fallen1 Nightmare health differs from Normal (${String(nightmare?.minHp)}-${String(nightmare?.maxHp)} vs ${String(normal?.minHp)}-${String(normal?.maxHp)}), so MinHP(N) is really being read`,
|
||
)
|
||
check(
|
||
nightmare !== undefined && normal !== undefined && nightmare.experience !== normal.experience,
|
||
`fallen1 Nightmare experience differs (${String(nightmare?.experience)} vs ${String(normal?.experience)})`,
|
||
)
|
||
}
|
||
|
||
// The documented oddity, asserted so that a future "fix" that quietly inverts
|
||
// it has to confront the data first.
|
||
{
|
||
let lower = 0
|
||
let total = 0
|
||
for (const row of tables.monstats.rows) {
|
||
const normalHp = Number(cell(tables.monstats, row, 'maxHP'))
|
||
const nightmareHp = Number(cell(tables.monstats, row, 'MaxHP(N)'))
|
||
if (!Number.isFinite(normalHp) || !Number.isFinite(nightmareHp) || normalHp === 0) continue
|
||
total += 1
|
||
if (nightmareHp < normalHp) lower += 1
|
||
}
|
||
check(
|
||
lower > total / 2,
|
||
`most rows have a lower MaxHP(N) than maxHP (${String(lower)} of ${String(total)}) — these columns are not a difficulty scaling`,
|
||
)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Levels.txt monster columns.
|
||
// ---------------------------------------------------------------------------
|
||
// ---------------------------------------------------------------------------
|
||
// MonLvl.txt scaling — the reconciliation that justifies applying it.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== MonLvl.txt scaling reconciles the table with the game ==`)
|
||
const scaling = readMonsterScaling(tables.monlvl)
|
||
check(scaling.size > 90, `${String(scaling.size)} monster levels have multipliers`)
|
||
|
||
// Every level any monster claims must have a row, or that monster would be
|
||
// silently left unscaled and arrive with hundreds of health.
|
||
const unscaled: number[] = []
|
||
for (const kind of kinds.values()) {
|
||
for (const level of kind.level) {
|
||
if (level > 0 && !scaling.has(level)) unscaled.push(level)
|
||
}
|
||
}
|
||
check(unscaled.length === 0, `every monster level has a MonLvl row (${String(new Set(unscaled).size)} missing)`)
|
||
|
||
// The five independent columns that pinned the formula down. If a future change
|
||
// breaks one of these, the scaling has stopped being the game's.
|
||
interface Reconciliation {
|
||
readonly id: string
|
||
readonly what: string
|
||
readonly expected: number
|
||
readonly raw: (kind: MonsterKind) => number
|
||
readonly read: (kind: MonsterKind, scale: { armour: number; toHit: number; experience: number }) => number
|
||
}
|
||
const RECONCILE: readonly Reconciliation[] = [
|
||
{ id: 'fallen1', what: 'Exp', expected: 18, raw: k => k.experience, read: (k, s2) => (k.experience * s2.experience) / 100 },
|
||
{ id: 'zombie1', what: 'Exp', expected: 33, raw: k => k.experience, read: (k, s2) => (k.experience * s2.experience) / 100 },
|
||
{ id: 'quillrat1', what: 'Exp', expected: 21, raw: k => k.experience, read: (k, s2) => (k.experience * s2.experience) / 100 },
|
||
{ id: 'fallen1', what: 'AC', expected: 5, raw: k => k.armour, read: (k, s2) => (k.armour * s2.armour) / 100 },
|
||
{ id: 'fallen1', what: 'A1TH', expected: 8, raw: k => k.attack1.toHit, read: (k, s2) => (k.attack1.toHit * s2.toHit) / 100 },
|
||
]
|
||
for (const want of RECONCILE) {
|
||
const kind = kinds.get(want.id)!
|
||
const got = want.read(kind, monsterScaleFor(scaling, kind))
|
||
check(
|
||
Math.round(got) === want.expected || Math.floor(got) === want.expected,
|
||
`${want.id} ${want.what} ${String(want.raw(kind))} → ${got.toFixed(1)}, the game shows ${String(want.expected)}`,
|
||
)
|
||
}
|
||
|
||
// The scaled numbers have to be playable, which the raw ones are not: a level-1
|
||
// Fallen straight off the table hits for 76, and the player has 60 health.
|
||
{
|
||
const fallen = kinds.get('fallen1')!
|
||
const raw = monsterStatsOf(fallen, new Rng(1), WALK_SPEED)
|
||
const scaled = monsterStatsOf(fallen, new Rng(1), WALK_SPEED, monsterScaleFor(scaling, fallen))
|
||
check(raw.damage > 50, `unscaled fallen1 hits for ${String(raw.damage)}, which would one-shot the player`)
|
||
check(scaled.damage <= 3, `scaled fallen1 hits for ${String(scaled.damage)}`)
|
||
check(scaled.hp <= 6, `scaled fallen1 has ${String(scaled.hp)} health`)
|
||
check(scaled.xp === 18, `scaled fallen1 awards ${String(scaled.xp)} experience`)
|
||
}
|
||
|
||
// Difficulty raises the monster's level, and the level raises everything else.
|
||
{
|
||
const fallen = kinds.get('fallen1')!
|
||
const hell = readMonsterKinds(tables.monstats, 'hell').get('fallen1')!
|
||
const hellScale = monsterScaleFor(readMonsterScaling(tables.monlvl, 'hell'), hell, 'hell')
|
||
const normal = monsterStatsOf(fallen, new Rng(1), WALK_SPEED, monsterScaleFor(scaling, fallen))
|
||
const scaledHell = monsterStatsOf(hell, new Rng(1), WALK_SPEED, hellScale)
|
||
check(
|
||
scaledHell.hp > normal.hp * 50,
|
||
`a Hell Fallen (level ${String(hell.level[2])}) has ${String(scaledHell.hp)} health against a Normal one's ${String(normal.hp)}`,
|
||
)
|
||
check(scaledHell.xp > normal.xp * 50, `and awards ${String(scaledHell.xp)} experience against ${String(normal.xp)}`)
|
||
}
|
||
|
||
console.log(`\n== Levels.txt monster plans ==`)
|
||
interface LevelExpectation {
|
||
readonly id: number
|
||
readonly name: string
|
||
readonly density: number
|
||
readonly typeCount: number
|
||
readonly pool: readonly string[]
|
||
}
|
||
const LEVELS: readonly LevelExpectation[] = [
|
||
{ id: 1, name: 'Act 1 - Town', density: 0, typeCount: 0, pool: [] },
|
||
{ id: 2, name: 'Act 1 - Wilderness 1', density: 520, typeCount: 3, pool: ['zombie1', 'fallen1', 'quillrat1'] },
|
||
{ id: 8, name: 'Act 1 - Cave 1', density: 600, typeCount: 3, pool: ['zombie1', 'brute1', 'fallenshaman1'] },
|
||
]
|
||
for (const want of LEVELS) {
|
||
const plan = readLevelMonsterPlan(tables.levels, want.id)
|
||
if (plan === null) {
|
||
check(false, `level ${String(want.id)} has a row`)
|
||
continue
|
||
}
|
||
check(plan.levelName === want.name, `level ${String(want.id)} is ${plan.levelName}`)
|
||
check(plan.density === want.density, `${plan.levelName} MonDen ${String(plan.density)} (want ${String(want.density)})`)
|
||
check(plan.typeCount === want.typeCount, `${plan.levelName} NumMon ${String(plan.typeCount)} (want ${String(want.typeCount)})`)
|
||
check(
|
||
plan.pool.join(',') === want.pool.join(','),
|
||
`${plan.levelName} pool [${plan.pool.join(', ')}]${plan.pool.join(',') === want.pool.join(',') ? '' : ` (want [${want.pool.join(', ')}])`}`,
|
||
)
|
||
}
|
||
|
||
// Every monster any level names must exist in MonStats.txt, or the populator
|
||
// would be asked to place something it cannot build.
|
||
let danglingPool = 0
|
||
let levelsWithMonsters = 0
|
||
for (const row of tables.levels.rows) {
|
||
const levelId = Number(cell(tables.levels, row, 'Id'))
|
||
if (!Number.isFinite(levelId)) continue
|
||
const plan = readLevelMonsterPlan(tables.levels, levelId)
|
||
if (plan === null) continue
|
||
if (plan.pool.length > 0) levelsWithMonsters += 1
|
||
for (const name of [...plan.pool, ...plan.nightmarePool, ...plan.elitePool]) {
|
||
if (!kinds.has(name)) {
|
||
danglingPool += 1
|
||
if (danglingPool <= 5) console.log(` ${plan.levelName}: unknown monster "${name}"`)
|
||
}
|
||
}
|
||
}
|
||
check(danglingPool === 0, `every level's monster pool resolves (${String(danglingPool)} dangling across ${String(levelsWithMonsters)} populated levels)`)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// SuperUniques.txt and MonUMod.txt.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== SuperUniques.txt ==`)
|
||
const superUniques = readSuperUniques(tables.superuniques)
|
||
check(superUniques.length > 60, `${String(superUniques.length)} super uniques read`)
|
||
const danglingClass = superUniques.filter(entry => !kinds.has(entry.monsterId))
|
||
check(danglingClass.length === 0, `every super unique's Class resolves${danglingClass.length === 0 ? '' : `: ${danglingClass.map(e => `${e.id}→${e.monsterId}`).join(', ')}`}`)
|
||
const bishibosh = superUniques.find(entry => entry.id === 'Bishibosh')
|
||
check(
|
||
bishibosh !== undefined && bishibosh.monsterId === 'fallenshaman1' && bishibosh.minMinions === 2 && bishibosh.maxMinions === 2,
|
||
`Bishibosh is a fallenshaman1 with 2 minions (${String(bishibosh?.monsterId)}, ${String(bishibosh?.minMinions)}-${String(bishibosh?.maxMinions)})`,
|
||
)
|
||
const rakanishu = superUniques.find(entry => entry.id === 'Rakanishu')
|
||
check(
|
||
rakanishu !== undefined && rakanishu.monsterId === 'fallen2' && rakanishu.maxMinions === 8,
|
||
`Rakanishu is a fallen2 with 8 minions (${String(rakanishu?.monsterId)}, ${String(rakanishu?.maxMinions)})`,
|
||
)
|
||
|
||
console.log(`\n== MonUMod.txt ==`)
|
||
const modifiers = readEliteModifiers(tables.monumod)
|
||
check(modifiers.length > 20, `${String(modifiers.length)} elite modifiers read`)
|
||
const modifierIds = new Set(modifiers.map(entry => entry.id))
|
||
const danglingMod = superUniques.flatMap(entry => entry.modifiers).filter(id => !modifierIds.has(id))
|
||
check(danglingMod.length === 0, `every super unique modifier id exists (${String(danglingMod.length)} dangling)`)
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Population: density, type selection, packs.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== populating Act 1 - Wilderness 1 ==`)
|
||
const bloodMoor = readLevelMonsterPlan(tables.levels, 2)
|
||
if (bloodMoor === null) {
|
||
check(false, 'Blood Moor has a plan')
|
||
} else {
|
||
/** A wilderness level is roughly 50×50 cells. */
|
||
const CELLS = 50 * 50
|
||
const budget = monsterBudget(bloodMoor, CELLS)
|
||
check(budget >= 10 && budget <= 60, `budget for a ${String(CELLS)}-cell level is ${String(budget)}, in the 10..60 range the real level holds`)
|
||
|
||
const town = readLevelMonsterPlan(tables.levels, 1)
|
||
check(town !== null && monsterBudget(town, CELLS) === 0, 'a town has a budget of zero')
|
||
|
||
const types = selectLevelTypes(bloodMoor, kinds, new Rng(2))
|
||
check(types.length === bloodMoor.typeCount, `selected ${String(types.length)} types, NumMon is ${String(bloodMoor.typeCount)}`)
|
||
check(new Set(types.map(t => t.id)).size === types.length, `selected types are distinct: ${types.map(t => t.id).join(', ')}`)
|
||
check(types.every(t => bloodMoor.pool.includes(t.id)), 'selected types all come from the level pool')
|
||
|
||
const groups = planMonsterGroups(bloodMoor, types, kinds, budget, new Rng(3))
|
||
const placed = groups.reduce((sum, group) => sum + group.count, 0)
|
||
check(placed === budget, `packs account for the whole budget (${String(placed)} of ${String(budget)})`)
|
||
check(groups.every(group => group.count >= 1), 'no empty packs')
|
||
check(
|
||
groups.every(group => group.count <= Math.max(1, group.kind.maxGroup)),
|
||
'no pack exceeds its monster\'s MaxGrp',
|
||
)
|
||
const ranks = new Map<string, number>()
|
||
for (const group of groups) ranks.set(group.rank, (ranks.get(group.rank) ?? 0) + 1)
|
||
console.log(` info ${String(groups.length)} packs: ${[...ranks].map(([rank, n]) => `${String(n)} ${rank}`).join(', ')}`)
|
||
|
||
// Determinism: the same seed must produce the same level, or a save cannot be
|
||
// reloaded and a co-op session cannot agree on what it is fighting.
|
||
const again = planMonsterGroups(bloodMoor, selectLevelTypes(bloodMoor, kinds, new Rng(2)), kinds, budget, new Rng(3))
|
||
const encode = (list: readonly { kind: MonsterKind; count: number; rank: string }[]): string =>
|
||
list.map(group => `${group.kind.id}:${String(group.count)}:${group.rank}`).join('|')
|
||
check(encode(groups) === encode(again), 'the same seed produces the same packs')
|
||
const different = planMonsterGroups(bloodMoor, selectLevelTypes(bloodMoor, kinds, new Rng(99)), kinds, budget, new Rng(98))
|
||
check(encode(groups) !== encode(different), 'a different seed produces different packs')
|
||
}
|
||
|
||
// Density ratios between levels must follow the table, since the absolute
|
||
// count is a calibration but the ratios are data.
|
||
console.log(`\n== density ratios follow MonDen ==`)
|
||
const cow = readLevelMonsterPlan(tables.levels, 39)
|
||
if (bloodMoor !== null && cow !== null) {
|
||
const ratio = cow.density / bloodMoor.density
|
||
const budgetRatio = monsterBudget(cow, 10_000) / monsterBudget(bloodMoor, 10_000)
|
||
check(
|
||
Math.abs(ratio - budgetRatio) < 0.05,
|
||
`Cow Level is ${ratio.toFixed(2)}× the Blood Moor's density and ${budgetRatio.toFixed(2)}× its budget`,
|
||
)
|
||
} else {
|
||
check(false, 'Cow Level and Blood Moor both have plans')
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// MonStats2.txt covers the monsters that spawn.
|
||
// ---------------------------------------------------------------------------
|
||
console.log(`\n== MonStats2.txt covers spawnable monsters ==`)
|
||
const art = readMonsterArt(tables.monstats2, kinds)
|
||
const uncovered: string[] = []
|
||
let viaBaseId = 0
|
||
for (const kind of kinds.values()) {
|
||
if (!kind.enabled || !kind.isSpawn || kind.npc) continue
|
||
const entry = art.get(kind.id)
|
||
if (entry === undefined) { uncovered.push(kind.id); continue }
|
||
if (entry.rowId !== kind.id) viaBaseId += 1
|
||
}
|
||
check(uncovered.length === 0, `every spawnable monster resolves art${uncovered.length === 0 ? '' : `; missing ${uncovered.slice(0, 10).join(', ')}`}`)
|
||
check(viaBaseId > 0, `${String(viaBaseId)} spawnable monsters reach their art through BaseId, as the game does`)
|
||
const fallenArt = art.get('fallen1')
|
||
check(
|
||
fallenArt !== undefined && fallenArt.sizeX === 2 && fallenArt.sizeY === 2 && fallenArt.totalPieces === 6 && fallenArt.directions === 8,
|
||
`fallen1 art is 2×2, 6 COF pieces, 8 directions (${String(fallenArt?.sizeX)}×${String(fallenArt?.sizeY)}, ${String(fallenArt?.totalPieces)}, ${String(fallenArt?.directions)})`,
|
||
)
|
||
const variantArt = art.get('quillrat6')
|
||
check(
|
||
variantArt !== undefined && variantArt.rowId === 'quillrat1',
|
||
`quillrat6 borrows quillrat1's art (${String(variantArt?.rowId)})`,
|
||
)
|
||
const flat = [...art.values()]
|
||
check(
|
||
new Set(flat.map(entry => `${String(entry.sizeX)}x${String(entry.sizeY)}`)).size > 3,
|
||
`body sizes vary rather than defaulting (${String(new Set(flat.map(e => `${String(e.sizeX)}x${String(e.sizeY)}`)).size)} distinct)`,
|
||
)
|
||
|
||
console.log(`\n== summary ==`)
|
||
console.log(` ${String(checks - failures)}/${String(checks)} checks passed`)
|
||
const difficulties: readonly Difficulty[] = ['normal', 'nightmare', 'hell']
|
||
console.log(` difficulties read: ${difficulties.join(', ')}`)
|
||
if (failures > 0) process.exit(1)
|