463 lines
16 KiB
TypeScript
463 lines
16 KiB
TypeScript
import { describe, it, expect, beforeAll } from 'vitest'
|
|
import * as fs from 'fs'
|
|
import { MountedArchives } from '../src/mpq/mount.ts'
|
|
import { MpqArchive } from '../src/mpq/archive.ts'
|
|
import { fileSource } from '../src/mpq/file-source.ts'
|
|
import type { D2Table } from '../src/game/acts.ts'
|
|
import { cell, parseTable } from '../src/game/acts.ts'
|
|
import {
|
|
parseMiscTable,
|
|
loadMisc,
|
|
MISC_TABLE_PATH,
|
|
type MiscTable,
|
|
type MiscBase,
|
|
} from '../src/game/misc-items.ts'
|
|
|
|
const hasD2 = fs.existsSync('samples/d2/d2data.mpq')
|
|
|
|
describe('Misc.txt loader & MiscBase mapping (Issue #93)', () => {
|
|
let table: MiscTable
|
|
let rawTable: D2Table | undefined
|
|
|
|
beforeAll(async () => {
|
|
if (hasD2) {
|
|
const archives = new MountedArchives()
|
|
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
|
|
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
|
|
}
|
|
const bytes = await archives.read(MISC_TABLE_PATH)
|
|
rawTable = parseTable(bytes)
|
|
table = parseMiscTable(rawTable)
|
|
} else {
|
|
rawTable = createMinimalFallbackTable()
|
|
table = parseMiscTable(rawTable)
|
|
}
|
|
})
|
|
|
|
it('uses the canonical MPQ table path data\\global\\excel\\Misc.txt', () => {
|
|
expect(MISC_TABLE_PATH).toBe('data\\global\\excel\\Misc.txt')
|
|
})
|
|
|
|
it('loads misc items via loadMisc with MountedArchives', async () => {
|
|
if (hasD2) {
|
|
const archives = new MountedArchives()
|
|
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
|
|
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
|
|
}
|
|
const loaded = await loadMisc(archives)
|
|
expect(loaded.all.length).toBe(151)
|
|
expect(loaded.byCode.size).toBe(151)
|
|
expect(loaded.get('hp1')?.name).toBe('Lesser Healing Potion')
|
|
}
|
|
})
|
|
|
|
it('verifies 152 raw rows in original file - 1 Expansion row = 151 real data rows with 0 duplicate codes', () => {
|
|
if (hasD2 && rawTable) {
|
|
expect(rawTable.rows.length).toBe(152)
|
|
|
|
// Verify Expansion row at index 94
|
|
const expRow = rawTable.rows[94]!
|
|
expect(cell(rawTable, expRow, 'name')).toBe('Expansion')
|
|
expect(cell(rawTable, expRow, 'code')).toBe('')
|
|
|
|
expect(table.all.length).toBe(151)
|
|
expect(table.byCode.size).toBe(151)
|
|
|
|
// Verify 0 duplicate codes
|
|
const seenCodes = new Set<string>()
|
|
for (const item of table.all) {
|
|
expect(seenCodes.has(item.code)).toBe(false)
|
|
seenCodes.add(item.code)
|
|
}
|
|
expect(seenCodes.size).toBe(151)
|
|
}
|
|
|
|
// Verify Expansion row is excluded
|
|
expect(table.byCode.has('Expansion')).toBe(false)
|
|
expect(table.byCode.has('')).toBe(false)
|
|
})
|
|
|
|
it('loads ALL 151 rows including exactly 98 spawnable rows', () => {
|
|
if (hasD2) {
|
|
const spawnableCount = table.all.filter(i => i.spawnable).length
|
|
expect(spawnableCount).toBe(98)
|
|
|
|
const nonSpawnableCount = table.all.filter(i => !i.spawnable).length
|
|
expect(nonSpawnableCount).toBe(53)
|
|
expect(spawnableCount + nonSpawnableCount).toBe(151)
|
|
}
|
|
})
|
|
|
|
it('verifies gld is recognized as gold (isGold === true, type === "gold")', () => {
|
|
const gold = table.get('gld')
|
|
expect(gold).toBeDefined()
|
|
expect(gold?.isGold).toBe(true)
|
|
expect(gold?.type).toBe('gold')
|
|
expect(gold?.name).toBe('gold')
|
|
expect(gold?.stackable).toBe(true)
|
|
expect(gold?.maxstack).toBe(5000)
|
|
|
|
// All other items must not be gold
|
|
const nonGold = table.all.filter(i => i.code !== 'gld')
|
|
for (const item of nonGold) {
|
|
expect(item.isGold).toBe(false)
|
|
}
|
|
})
|
|
|
|
it('verifies 33 runes r01..r33 are accessible by number 1..33 and have isRune === true', () => {
|
|
if (hasD2) {
|
|
const runes = table.all.filter(i => i.isRune)
|
|
expect(runes.length).toBe(33)
|
|
|
|
for (let num = 1; num <= 33; num++) {
|
|
const rune = table.getRune(num)
|
|
expect(rune).toBeDefined()
|
|
expect(rune?.isRune).toBe(true)
|
|
expect(rune?.runeNumber).toBe(num)
|
|
|
|
const expectedCode = `r${String(num).padStart(2, '0')}`
|
|
expect(rune?.code).toBe(expectedCode)
|
|
expect(rune?.type).toBe('rune')
|
|
expect(rune?.tags).toEqual(['rune'])
|
|
}
|
|
|
|
// Check specific first and last rune details
|
|
const elRune = table.getRune(1)!
|
|
expect(elRune.name).toBe('El Rune')
|
|
expect(elRune.level).toBe(11)
|
|
expect(elRune.cost).toBe(560)
|
|
|
|
const zodRune = table.getRune(33)!
|
|
expect(zodRune.name).toBe('Zod Rune')
|
|
expect(zodRune.level).toBe(69)
|
|
expect(zodRune.cost).toBe(134540)
|
|
}
|
|
|
|
// Boundary check for getRune
|
|
expect(table.getRune(0)).toBeUndefined()
|
|
expect(table.getRune(34)).toBeUndefined()
|
|
expect(table.getRune(-1)).toBeUndefined()
|
|
|
|
// Non-rune items starting with 'r' (e.g. rin, rvs, rvl, rps, rpl)
|
|
for (const nonRuneCode of ['rin', 'rvs', 'rvl', 'rps', 'rpl']) {
|
|
const item = table.get(nonRuneCode)
|
|
if (item) {
|
|
expect(item.isRune).toBe(false)
|
|
expect(item.runeNumber).toBeUndefined()
|
|
}
|
|
}
|
|
})
|
|
|
|
describe('Sample item checks (hp1, rin, cm1)', () => {
|
|
it('accurately parses Lesser Healing Potion (hp1)', () => {
|
|
const hp1 = table.get('hp1')!
|
|
expect(hp1).toBeDefined()
|
|
expect(hp1.id).toBe('hp1')
|
|
expect(hp1.code).toBe('hp1')
|
|
expect(hp1.name).toBe('Lesser Healing Potion')
|
|
expect(hp1.namestr).toBe('hp1')
|
|
expect(hp1.version).toBe(0)
|
|
expect(hp1.kind).toBe('misc')
|
|
expect(hp1.spawnable).toBe(true)
|
|
expect(hp1.rarity).toBe(1)
|
|
expect(hp1.level).toBe(0)
|
|
expect(hp1.type).toBe('hpot')
|
|
expect(hp1.type2).toBeUndefined()
|
|
expect(hp1.cost).toBe(30)
|
|
expect(hp1.gambleCost).toBe(0)
|
|
expect(hp1.invWidth).toBe(1)
|
|
expect(hp1.invHeight).toBe(1)
|
|
expect(hp1.stackable).toBe(false)
|
|
expect(hp1.minstack).toBeUndefined()
|
|
expect(hp1.maxstack).toBeUndefined()
|
|
expect(hp1.spawnstack).toBeUndefined()
|
|
expect(hp1.autobelt).toBe(true)
|
|
expect(hp1.pSpell).toBe(3)
|
|
expect(hp1.transmogrify).toBe(false)
|
|
expect(hp1.tags).toEqual(['hpot'])
|
|
expect(hp1.isGold).toBe(false)
|
|
expect(hp1.isRune).toBe(false)
|
|
expect(hp1.runeNumber).toBeUndefined()
|
|
|
|
// ItemBase conformance
|
|
expect(hp1.maxStack).toBe(1)
|
|
expect(hp1.value).toBe(30)
|
|
expect(hp1.damage).toBe(0)
|
|
expect(hp1.defense).toBe(0)
|
|
})
|
|
|
|
it('accurately parses Ring (rin)', () => {
|
|
const rin = table.get('rin')!
|
|
expect(rin).toBeDefined()
|
|
expect(rin.id).toBe('rin')
|
|
expect(rin.code).toBe('rin')
|
|
expect(rin.name).toBe('ring')
|
|
expect(rin.namestr).toBe('rin')
|
|
expect(rin.version).toBe(0)
|
|
expect(rin.kind).toBe('misc')
|
|
expect(rin.spawnable).toBe(true)
|
|
expect(rin.rarity).toBe(4)
|
|
expect(rin.level).toBe(1)
|
|
expect(rin.type).toBe('ring')
|
|
expect(rin.type2).toBeUndefined()
|
|
expect(rin.cost).toBe(1800)
|
|
expect(rin.gambleCost).toBe(50000)
|
|
expect(rin.invWidth).toBe(1)
|
|
expect(rin.invHeight).toBe(1)
|
|
expect(rin.stackable).toBe(false)
|
|
expect(rin.autobelt).toBe(false)
|
|
expect(rin.pSpell).toBeUndefined()
|
|
expect(rin.transmogrify).toBe(false)
|
|
expect(rin.tags).toEqual(['ring'])
|
|
expect(rin.isGold).toBe(false)
|
|
expect(rin.isRune).toBe(false)
|
|
})
|
|
|
|
it('accurately parses Small Charm (cm1)', () => {
|
|
const cm1 = table.get('cm1')!
|
|
expect(cm1).toBeDefined()
|
|
expect(cm1.id).toBe('cm1')
|
|
expect(cm1.code).toBe('cm1')
|
|
expect(cm1.name).toBe('Charm Small')
|
|
expect(cm1.namestr).toBe('cm1')
|
|
expect(cm1.version).toBe(100)
|
|
expect(cm1.kind).toBe('misc')
|
|
expect(cm1.spawnable).toBe(true)
|
|
expect(cm1.rarity).toBe(4)
|
|
expect(cm1.level).toBe(28)
|
|
expect(cm1.type).toBe('scha')
|
|
expect(cm1.type2).toBeUndefined()
|
|
expect(cm1.cost).toBe(2000)
|
|
expect(cm1.gambleCost).toBe(45000)
|
|
expect(cm1.invWidth).toBe(1)
|
|
expect(cm1.invHeight).toBe(1)
|
|
expect(cm1.stackable).toBe(false)
|
|
expect(cm1.autobelt).toBe(false)
|
|
expect(cm1.pSpell).toBeUndefined()
|
|
expect(cm1.transmogrify).toBe(false)
|
|
expect(cm1.tags).toEqual(['scha'])
|
|
expect(cm1.isGold).toBe(false)
|
|
expect(cm1.isRune).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('Caution item categories', () => {
|
|
it('potions (hp1..hp5, mp1..mp5, rvs, rvl, vps)', () => {
|
|
for (const code of ['hp1', 'hp2', 'hp3', 'hp4', 'hp5']) {
|
|
const item = table.get(code)
|
|
if (item) {
|
|
expect(item.type).toBe('hpot')
|
|
expect(item.autobelt).toBe(true)
|
|
}
|
|
}
|
|
for (const code of ['mp1', 'mp2', 'mp3', 'mp4', 'mp5']) {
|
|
const item = table.get(code)
|
|
if (item) {
|
|
expect(item.type).toBe('mpot')
|
|
expect(item.autobelt).toBe(true)
|
|
}
|
|
}
|
|
for (const code of ['rvs', 'rvl']) {
|
|
const item = table.get(code)
|
|
if (item) {
|
|
expect(item.type).toBe('rpot')
|
|
expect(item.autobelt).toBe(true)
|
|
}
|
|
}
|
|
const vps = table.get('vps')
|
|
if (vps) {
|
|
expect(vps.type).toBe('spot')
|
|
expect(vps.autobelt).toBe(false)
|
|
}
|
|
})
|
|
|
|
it('scrolls (tsc, isc)', () => {
|
|
const tsc = table.get('tsc')
|
|
if (tsc) {
|
|
expect(tsc.name).toBe('Town Portal Scroll')
|
|
expect(tsc.type).toBe('scro')
|
|
}
|
|
|
|
const isc = table.get('isc')
|
|
if (isc) {
|
|
expect(isc.name).toBe('Identify Scroll')
|
|
expect(isc.type).toBe('scro')
|
|
}
|
|
})
|
|
|
|
it('charms (cm1..cm3)', () => {
|
|
const cm1 = table.get('cm1')
|
|
const cm2 = table.get('cm2')
|
|
const cm3 = table.get('cm3')
|
|
if (cm1) expect(cm1.type).toBe('scha')
|
|
if (cm2) expect(cm2.type).toBe('mcha')
|
|
if (cm3) expect(cm3.type).toBe('lcha')
|
|
})
|
|
|
|
it('jewels (jew)', () => {
|
|
const jew = table.get('jew')
|
|
if (jew) {
|
|
expect(jew.name).toBe('Jewel')
|
|
expect(jew.type).toBe('jewl')
|
|
}
|
|
})
|
|
|
|
it('rings and amulets (rin, amu)', () => {
|
|
const rin = table.get('rin')
|
|
const amu = table.get('amu')
|
|
if (rin) expect(rin.type).toBe('ring')
|
|
if (amu) expect(amu.type).toBe('amul')
|
|
})
|
|
|
|
it('quivers (aqv, cqv)', () => {
|
|
const aqv = table.get('aqv')
|
|
if (aqv) {
|
|
expect(aqv.type).toBe('bowq')
|
|
expect(aqv.stackable).toBe(true)
|
|
expect(aqv.minstack).toBe(100)
|
|
expect(aqv.maxstack).toBe(350)
|
|
expect(aqv.spawnstack).toBe(200)
|
|
}
|
|
|
|
const cqv = table.get('cqv')
|
|
if (cqv) {
|
|
expect(cqv.type).toBe('xboq')
|
|
expect(cqv.stackable).toBe(true)
|
|
expect(cqv.minstack).toBe(60)
|
|
expect(cqv.maxstack).toBe(250)
|
|
expect(cqv.spawnstack).toBe(150)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('Items with type2 and tags', () => {
|
|
it('maps type and type2 into tags for chipped/perfect gems and skulls', () => {
|
|
const gcv = table.get('gcv')
|
|
if (gcv) {
|
|
expect(gcv.name).toBe('Chipped Amethyst')
|
|
expect(gcv.type).toBe('gema')
|
|
expect(gcv.type2).toBe('gem0')
|
|
expect(gcv.tags).toEqual(['gema', 'gem0'])
|
|
}
|
|
|
|
const gpw = table.get('gpw')
|
|
if (gpw) {
|
|
expect(gpw.name).toBe('Perfect Diamond')
|
|
expect(gpw.type).toBe('gemd')
|
|
expect(gpw.type2).toBe('gem4')
|
|
expect(gpw.tags).toEqual(['gemd', 'gem4'])
|
|
}
|
|
|
|
const skz = table.get('skz')
|
|
if (skz) {
|
|
expect(skz.name).toBe('Perfect Skull')
|
|
expect(skz.type).toBe('gemz')
|
|
expect(skz.type2).toBe('gem4')
|
|
expect(skz.tags).toEqual(['gemz', 'gem4'])
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('Transmogrify flag', () => {
|
|
it('sets transmogrify === true for horadric quest transmogrify items', () => {
|
|
if (hasD2) {
|
|
for (const code of ['hrt', 'brz', 'jaw', 'eyz', 'hrn', 'tal', 'fng', 'qll', 'sol', 'scz', 'spe']) {
|
|
const item = table.get(code)!
|
|
expect(item).toBeDefined()
|
|
expect(item.transmogrify).toBe(true)
|
|
}
|
|
}
|
|
expect(table.get('hp1')?.transmogrify).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('Lookup & indexing flexibility', () => {
|
|
it('supports case-insensitive and whitespace-tolerant get and byCode lookups', () => {
|
|
const hp1 = table.get('hp1')!
|
|
expect(table.get('HP1')).toBe(hp1)
|
|
expect(table.get(' hp1 ')).toBe(hp1)
|
|
expect(table.get('Hp1')).toBe(hp1)
|
|
|
|
expect(table.byCode.get('HP1')).toBe(hp1)
|
|
expect(table.byCode.get(' hp1 ')).toBe(hp1)
|
|
expect(table.byCode.has('HP1')).toBe(true)
|
|
expect(table.byCode.has('nonexistent')).toBe(false)
|
|
expect(table.get('nonexistent')).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('parseMiscTable overloads & standalone parsing', () => {
|
|
it('parses directly from a TSV string with Expansion row filtering', () => {
|
|
const tsv = [
|
|
'name\tcode\tnamestr\tversion\tspawnable\trarity\tlevel\ttype\ttype2\tcost\tgamble cost\tinvwidth\tinvheight\tstackable\tminstack\tmaxstack\tspawnstack\tautobelt\tpSpell\tTransmogrify',
|
|
'Lesser Healing Potion\thp1\thp1\t0\t1\t1\t0\thpot\t\t30\t\t1\t1\t0\t0\t0\t0\t1\t3\t0',
|
|
'Expansion\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t',
|
|
'El Rune\tr01\tr01\t100\t1\t1\t11\trune\t\t560\t\t1\t1\t0\t0\t0\t0\t0\t\t0',
|
|
'gold\tgld\tgld\t0\t1\t0\t0\tgold\t\t1\t\t1\t1\t1\t0\t5000\t0\t0\t\t0',
|
|
'Chipped Amethyst\tgcv\tgcv\t0\t1\t1\t1\tgema\tgem0\t240\t\t1\t1\t0\t0\t0\t0\t0\t\t0',
|
|
].join('\n')
|
|
|
|
const parsed = parseMiscTable(tsv)
|
|
expect(parsed.all.length).toBe(4)
|
|
expect(parsed.byCode.size).toBe(4)
|
|
expect(parsed.get('Expansion')).toBeUndefined()
|
|
|
|
const hp1 = parsed.get('hp1')!
|
|
expect(hp1).toBeDefined()
|
|
expect(hp1.name).toBe('Lesser Healing Potion')
|
|
expect(hp1.pSpell).toBe(3)
|
|
expect(hp1.autobelt).toBe(true)
|
|
|
|
const rune = parsed.getRune(1)!
|
|
expect(rune).toBeDefined()
|
|
expect(rune.code).toBe('r01')
|
|
expect(rune.isRune).toBe(true)
|
|
expect(rune.runeNumber).toBe(1)
|
|
|
|
const gold = parsed.get('gld')!
|
|
expect(gold.isGold).toBe(true)
|
|
expect(gold.stackable).toBe(true)
|
|
expect(gold.maxstack).toBe(5000)
|
|
|
|
const gem = parsed.get('gcv')!
|
|
expect(gem.tags).toEqual(['gema', 'gem0'])
|
|
})
|
|
|
|
it('parses directly from Uint8Array bytes', () => {
|
|
const tsv = [
|
|
'name\tcode\tnamestr\tversion\tspawnable\trarity\tlevel\ttype\ttype2\tcost\tgamble cost\tinvwidth\tinvheight\tstackable\tminstack\tmaxstack\tspawnstack\tautobelt\tpSpell\tTransmogrify',
|
|
'Zod Rune\tr33\tr33\t100\t1\t30\t69\trune\t\t134540\t\t1\t1\t0\t0\t0\t0\t0\t\t0',
|
|
].join('\n')
|
|
|
|
const bytes = new TextEncoder().encode(tsv)
|
|
const parsed = parseMiscTable(bytes)
|
|
expect(parsed.all.length).toBe(1)
|
|
expect(parsed.getRune(33)?.name).toBe('Zod Rune')
|
|
})
|
|
})
|
|
})
|
|
|
|
/**
|
|
* Minimal fallback D2Table for environments without MPQ assets.
|
|
*/
|
|
function createMinimalFallbackTable(): D2Table {
|
|
const header = [
|
|
'name', 'code', 'namestr', 'version', 'spawnable', 'rarity', 'level',
|
|
'type', 'type2', 'cost', 'gamble cost', 'invwidth', 'invheight',
|
|
'stackable', 'minstack', 'maxstack', 'spawnstack', 'autobelt', 'pSpell',
|
|
'Transmogrify',
|
|
]
|
|
|
|
const rows = [
|
|
['Lesser Healing Potion', 'hp1', 'hp1', '0', '1', '1', '0', 'hpot', '', '30', '', '1', '1', '0', '0', '0', '0', '1', '3', '0'],
|
|
['ring', 'rin', 'rin', '0', '1', '4', '1', 'ring', '', '1800', '50000', '1', '1', '0', '0', '0', '0', '0', '', '0'],
|
|
['Charm Small', 'cm1', 'cm1', '100', '1', '4', '28', 'scha', '', '2000', '45000', '1', '1', '0', '0', '0', '0', '0', '', '0'],
|
|
['gold', 'gld', 'gld', '0', '1', '0', '0', 'gold', '', '1', '', '1', '1', '1', '0', '5000', '0', '0', '', '0'],
|
|
['Expansion', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', ''],
|
|
['El Rune', 'r01', 'r01', '100', '1', '1', '11', 'rune', '', '560', '', '1', '1', '0', '0', '0', '0', '0', '', '0'],
|
|
['Zod Rune', 'r33', 'r33', '100', '1', '30', '69', 'rune', '', '134540', '', '1', '1', '0', '0', '0', '0', '0', '', '0'],
|
|
]
|
|
|
|
return { header, rows }
|
|
}
|