738 lines
24 KiB
TypeScript
738 lines
24 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 { loadItemTypes, type ItemTypeTable, type ItemTypeDefinition } from '../src/game/item-types.ts'
|
|
import { loadArmor, ArmorTable, type ArmorBase } from '../src/game/armor.ts'
|
|
import { loadWeapons, type WeaponTable, type WeaponBase } from '../src/game/weapons.ts'
|
|
import {
|
|
loadTreasureClasses,
|
|
type TreasureClassTable,
|
|
} from '../src/game/treasure-class.ts'
|
|
import {
|
|
AUTO_TC_NAMES,
|
|
AUTO_TC_SERIES,
|
|
AUTO_TC_TOTAL_NODES,
|
|
isAutoTcName,
|
|
parseAutoTcName,
|
|
generateAutoTreasureClasses,
|
|
autoTcToTreasureClassNode,
|
|
mergeAutoTreasureClasses,
|
|
queryTreasureClass,
|
|
queryAutoTreasureClass,
|
|
type AutoTcNode,
|
|
} from '../src/game/auto-tc.ts'
|
|
|
|
const hasD2 = fs.existsSync('samples/d2/d2data.mpq')
|
|
|
|
describe('Auto-TC Runtime Generation (Issue #100)', () => {
|
|
describe('Constants and Specifications', () => {
|
|
it('defines exactly 100 auto-TC nodes across 4 series', () => {
|
|
expect(AUTO_TC_TOTAL_NODES).toBe(100)
|
|
expect(AUTO_TC_NAMES.size).toBe(100)
|
|
|
|
const weapSeries = AUTO_TC_SERIES.find(s => s.typeCode === 'weap')!
|
|
expect(weapSeries).toBeDefined()
|
|
expect(weapSeries.count).toBe(29)
|
|
expect(weapSeries.minTier).toBe(3)
|
|
expect(weapSeries.maxTier).toBe(87)
|
|
|
|
const armoSeries = AUTO_TC_SERIES.find(s => s.typeCode === 'armo')!
|
|
expect(armoSeries).toBeDefined()
|
|
expect(armoSeries.count).toBe(29)
|
|
expect(armoSeries.minTier).toBe(3)
|
|
expect(armoSeries.maxTier).toBe(87)
|
|
|
|
const bowSeries = AUTO_TC_SERIES.find(s => s.typeCode === 'bow')!
|
|
expect(bowSeries).toBeDefined()
|
|
expect(bowSeries.count).toBe(29)
|
|
expect(bowSeries.minTier).toBe(3)
|
|
expect(bowSeries.maxTier).toBe(87)
|
|
|
|
const meleSeries = AUTO_TC_SERIES.find(s => s.typeCode === 'mele')!
|
|
expect(meleSeries).toBeDefined()
|
|
expect(meleSeries.count).toBe(13)
|
|
expect(meleSeries.minTier).toBe(3)
|
|
expect(meleSeries.maxTier).toBe(39)
|
|
|
|
// Total count across all series: 29 + 29 + 29 + 13 = 100
|
|
const totalCount = AUTO_TC_SERIES.reduce((sum, s) => sum + s.count, 0)
|
|
expect(totalCount).toBe(100)
|
|
})
|
|
|
|
it('contains all expected 100 canonical names', () => {
|
|
// Boundaries
|
|
expect(AUTO_TC_NAMES.has('weap3')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('weap87')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('armo3')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('armo87')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('bow3')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('bow87')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('mele3')).toBe(true)
|
|
expect(AUTO_TC_NAMES.has('mele39')).toBe(true)
|
|
|
|
// Excluded / Out of bounds
|
|
expect(AUTO_TC_NAMES.has('mele42')).toBe(false)
|
|
expect(AUTO_TC_NAMES.has('armo90')).toBe(false)
|
|
expect(AUTO_TC_NAMES.has('weap90')).toBe(false)
|
|
expect(AUTO_TC_NAMES.has('abow3')).toBe(false)
|
|
expect(AUTO_TC_NAMES.has('weap0')).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('isAutoTcName & parseAutoTcName APIs', () => {
|
|
it('correctly parses valid auto-TC names', () => {
|
|
expect(parseAutoTcName('weap3')).toEqual({ typeCode: 'weap', tier: 3 })
|
|
expect(parseAutoTcName('weap87')).toEqual({ typeCode: 'weap', tier: 87 })
|
|
expect(parseAutoTcName('armo3')).toEqual({ typeCode: 'armo', tier: 3 })
|
|
expect(parseAutoTcName('armo87')).toEqual({ typeCode: 'armo', tier: 87 })
|
|
expect(parseAutoTcName('bow15')).toEqual({ typeCode: 'bow', tier: 15 })
|
|
expect(parseAutoTcName('bow87')).toEqual({ typeCode: 'bow', tier: 87 })
|
|
expect(parseAutoTcName('mele3')).toEqual({ typeCode: 'mele', tier: 3 })
|
|
expect(parseAutoTcName('mele39')).toEqual({ typeCode: 'mele', tier: 39 })
|
|
})
|
|
|
|
it('supports case-insensitivity and whitespace padding', () => {
|
|
expect(parseAutoTcName('ARMO3')).toEqual({ typeCode: 'armo', tier: 3 })
|
|
expect(parseAutoTcName(' weap6 ')).toEqual({ typeCode: 'weap', tier: 6 })
|
|
expect(parseAutoTcName('MeLe39')).toEqual({ typeCode: 'mele', tier: 39 })
|
|
expect(isAutoTcName(' ARMO87 ')).toBe(true)
|
|
expect(isAutoTcName('BoW3')).toBe(true)
|
|
})
|
|
|
|
it('rejects invalid or non-auto-TC names', () => {
|
|
// Non-existent prefixes or item codes
|
|
expect(parseAutoTcName('abow3')).toBeUndefined()
|
|
expect(parseAutoTcName('cap')).toBeUndefined()
|
|
expect(parseAutoTcName('hax')).toBeUndefined()
|
|
expect(parseAutoTcName('Gold')).toBeUndefined()
|
|
expect(parseAutoTcName('')).toBeUndefined()
|
|
|
|
// Invalid steps (not multiple of 3)
|
|
expect(parseAutoTcName('armo4')).toBeUndefined()
|
|
expect(parseAutoTcName('weap1')).toBeUndefined()
|
|
expect(parseAutoTcName('bow2')).toBeUndefined()
|
|
|
|
// Tiers out of 1.13c range
|
|
expect(parseAutoTcName('mele42')).toBeUndefined()
|
|
expect(parseAutoTcName('armo90')).toBeUndefined()
|
|
expect(parseAutoTcName('weap90')).toBeUndefined()
|
|
expect(parseAutoTcName('weap0')).toBeUndefined()
|
|
|
|
expect(isAutoTcName('abow3')).toBe(false)
|
|
expect(isAutoTcName('mele42')).toBe(false)
|
|
expect(isAutoTcName('Gold')).toBe(false)
|
|
expect(isAutoTcName('armo4')).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('Integration with 1.13c MPQ data (samples/d2)', () => {
|
|
let types: ItemTypeTable
|
|
let armor: ArmorTable
|
|
let weapons: WeaponTable
|
|
let autoTcs: Map<string, AutoTcNode>
|
|
|
|
beforeAll(async () => {
|
|
if (!hasD2) {
|
|
throw new Error('samples/d2 MPQ files required for Auto-TC test')
|
|
}
|
|
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}`)))
|
|
}
|
|
types = await loadItemTypes(archives)
|
|
armor = await loadArmor(archives)
|
|
weapons = await loadWeapons(archives)
|
|
autoTcs = generateAutoTreasureClasses(types, armor, weapons)
|
|
})
|
|
|
|
it('generates exactly 100 auto-TC nodes', () => {
|
|
expect(autoTcs.size).toBe(100)
|
|
|
|
for (const name of AUTO_TC_NAMES) {
|
|
expect(autoTcs.has(name)).toBe(true)
|
|
const node = autoTcs.get(name)
|
|
expect(node).toBeDefined()
|
|
expect(node?.name).toBe(name)
|
|
}
|
|
})
|
|
|
|
it('verifies AutoTcNode structure invariants across all 100 nodes', () => {
|
|
for (const [name, node] of autoTcs) {
|
|
const parsed = parseAutoTcName(name)!
|
|
expect(parsed).toBeDefined()
|
|
|
|
expect(node.name).toBe(name)
|
|
expect(node.group).toBe(0)
|
|
expect(node.level).toBe(parsed.tier)
|
|
expect(node.picks).toBe(1)
|
|
expect(Array.isArray(node.entries)).toBe(true)
|
|
|
|
// totalProb must strictly equal sum of entry probabilities
|
|
const calculatedProb = node.entries.reduce((sum, e) => sum + e.prob, 0)
|
|
expect(node.totalProb).toBe(calculatedProb)
|
|
}
|
|
})
|
|
|
|
it('verifies all items in each bucket have rarity > 0', () => {
|
|
let totalItemEntries = 0
|
|
for (const [, node] of autoTcs) {
|
|
for (const entry of node.entries) {
|
|
totalItemEntries++
|
|
expect(entry.prob).toBeGreaterThan(0)
|
|
|
|
const base = armor.get(entry.itemCode) ?? weapons.get(entry.itemCode)
|
|
expect(base, `Item ${entry.itemCode} should exist in armor or weapons`).toBeDefined()
|
|
expect(base!.rarity).toBeGreaterThan(0)
|
|
expect(entry.prob).toBe(base!.rarity)
|
|
}
|
|
}
|
|
expect(totalItemEntries).toBe(637)
|
|
})
|
|
|
|
it('verifies tier N items strictly satisfy (N - 3) < qlvl <= N', () => {
|
|
for (const [name, node] of autoTcs) {
|
|
const tier = node.level
|
|
for (const entry of node.entries) {
|
|
const base = armor.get(entry.itemCode) ?? weapons.get(entry.itemCode)
|
|
expect(base).toBeDefined()
|
|
const qlvl = base!.level
|
|
|
|
expect(
|
|
qlvl,
|
|
`In node ${name}, item ${base!.code} with qlvl ${qlvl} must be > ${tier - 3}`,
|
|
).toBeGreaterThan(tier - 3)
|
|
expect(
|
|
qlvl,
|
|
`In node ${name}, item ${base!.code} with qlvl ${qlvl} must be <= ${tier}`,
|
|
).toBeLessThanOrEqual(tier)
|
|
|
|
if (tier === 3) {
|
|
expect(qlvl).toBeGreaterThanOrEqual(1)
|
|
expect(qlvl).toBeLessThanOrEqual(3)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
it('sample checks: armo3 contains cap (qlvl 1, rarity 1); weap3 contains hax (qlvl 3, rarity 3)', () => {
|
|
// 1. armo3 check
|
|
const armo3 = autoTcs.get('armo3')!
|
|
expect(armo3).toBeDefined()
|
|
expect(armo3.name).toBe('armo3')
|
|
expect(armo3.level).toBe(3)
|
|
expect(armo3.group).toBe(0)
|
|
expect(armo3.picks).toBe(1)
|
|
|
|
const capEntry = armo3.entries.find(e => e.itemCode === 'cap')
|
|
expect(capEntry).toBeDefined()
|
|
expect(capEntry?.itemCode).toBe('cap')
|
|
expect(capEntry?.prob).toBe(1)
|
|
|
|
const capBase = armor.get('cap')!
|
|
expect(capBase).toBeDefined()
|
|
expect(capBase.level).toBe(1)
|
|
expect(capBase.rarity).toBe(1)
|
|
|
|
// Verify all items in armo3: cap, qui, lea, buc, lgl, lbt, lbl
|
|
const armo3Codes = armo3.entries.map(e => e.itemCode)
|
|
expect(armo3Codes).toEqual(['cap', 'qui', 'lea', 'buc', 'lgl', 'lbt', 'lbl'])
|
|
expect(armo3.totalProb).toBe(9)
|
|
|
|
// 2. weap3 check
|
|
const weap3 = autoTcs.get('weap3')!
|
|
expect(weap3).toBeDefined()
|
|
expect(weap3.name).toBe('weap3')
|
|
expect(weap3.level).toBe(3)
|
|
|
|
const haxEntry = weap3.entries.find(e => e.itemCode === 'hax')
|
|
expect(haxEntry).toBeDefined()
|
|
expect(haxEntry?.itemCode).toBe('hax')
|
|
|
|
const haxBase = weapons.get('hax')!
|
|
expect(haxBase).toBeDefined()
|
|
expect(haxBase.level).toBe(3)
|
|
expect(haxBase.rarity).toBe(3)
|
|
expect(haxEntry?.prob).toBe(haxBase.rarity)
|
|
|
|
// Also verify wand and club in weap3 have rarity 1
|
|
const wndEntry = weap3.entries.find(e => e.itemCode === 'wnd')!
|
|
expect(wndEntry).toBeDefined()
|
|
expect(wndEntry.prob).toBe(1)
|
|
|
|
const clbEntry = weap3.entries.find(e => e.itemCode === 'clb')!
|
|
expect(clbEntry).toBeDefined()
|
|
expect(clbEntry.prob).toBe(1)
|
|
|
|
expect(weap3.entries.length).toBe(12)
|
|
expect(weap3.totalProb).toBe(26)
|
|
})
|
|
|
|
it('sample checks: mele3 and bow3 buckets', () => {
|
|
// mele3 contains melee weapons (excludes short bow sbw and eagle orb ob1)
|
|
const mele3 = autoTcs.get('mele3')!
|
|
expect(mele3).toBeDefined()
|
|
expect(mele3.level).toBe(3)
|
|
expect(mele3.entries.length).toBe(10)
|
|
expect(mele3.entries.some(e => e.itemCode === 'hax')).toBe(true)
|
|
expect(mele3.entries.some(e => e.itemCode === 'sbw')).toBe(false)
|
|
expect(mele3.entries.some(e => e.itemCode === 'ob1')).toBe(false)
|
|
expect(mele3.totalProb).toBe(22)
|
|
|
|
// bow3 contains Short Bow
|
|
const bow3 = autoTcs.get('bow3')!
|
|
expect(bow3).toBeDefined()
|
|
expect(bow3.level).toBe(3)
|
|
expect(bow3.entries.length).toBe(1)
|
|
expect(bow3.entries[0]?.itemCode).toBe('sbw')
|
|
expect(bow3.entries[0]?.prob).toBe(2)
|
|
expect(bow3.totalProb).toBe(2)
|
|
})
|
|
|
|
it('correctly handles sparse/empty buckets (e.g. bow15)', () => {
|
|
const bow15 = autoTcs.get('bow15')!
|
|
expect(bow15).toBeDefined()
|
|
expect(bow15.name).toBe('bow15')
|
|
expect(bow15.level).toBe(15)
|
|
expect(bow15.entries.length).toBe(0)
|
|
expect(bow15.totalProb).toBe(0)
|
|
|
|
// Converted to TreasureClassNode
|
|
const tcNode = autoTcToTreasureClassNode(bow15)
|
|
expect(tcNode.name).toBe('bow15')
|
|
expect(tcNode.items.length).toBe(0)
|
|
expect(tcNode.totalProbExpansion).toBe(0)
|
|
expect(tcNode.totalProbClassic).toBe(0)
|
|
expect(tcNode.cumulativeProbExpansion).toEqual([])
|
|
})
|
|
|
|
it('verifies 1:1 match with TreasureClassEx.txt autoTCDanglingReferences', async () => {
|
|
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 tcTable = await loadTreasureClasses(archives)
|
|
|
|
// TreasureClassEx.txt references exactly 100 auto-TCs
|
|
expect(tcTable.autoTCDanglingReferences.size).toBe(100)
|
|
|
|
// Every referenced auto-TC must exist in the generated map
|
|
for (const ref of tcTable.autoTCDanglingReferences) {
|
|
expect(autoTcs.has(ref), `Auto-TC ${ref} should be generated`).toBe(true)
|
|
}
|
|
|
|
// Every generated auto-TC must be in tcTable.autoTCDanglingReferences
|
|
for (const key of autoTcs.keys()) {
|
|
expect(tcTable.autoTCDanglingReferences.has(key)).toBe(true)
|
|
}
|
|
})
|
|
|
|
it('supports autoTcToTreasureClassNode conversion', () => {
|
|
const armo3 = autoTcs.get('armo3')!
|
|
const tcNode = autoTcToTreasureClassNode(armo3)
|
|
|
|
expect(tcNode.name).toBe('armo3')
|
|
expect(tcNode.level).toBe(3)
|
|
expect(tcNode.picks).toBe(1)
|
|
expect(tcNode.unique).toBe(0)
|
|
expect(tcNode.set).toBe(0)
|
|
expect(tcNode.rare).toBe(0)
|
|
expect(tcNode.magic).toBe(0)
|
|
expect(tcNode.noDrop).toBe(0)
|
|
expect(tcNode.items.length).toBe(armo3.entries.length)
|
|
expect(tcNode.totalProbExpansion).toBe(armo3.totalProb)
|
|
expect(tcNode.totalProbClassic).toBe(armo3.totalProb) // all armo3 items are classic
|
|
expect(tcNode.cumulativeProbExpansion.length).toBe(armo3.entries.length)
|
|
|
|
const capItem = tcNode.items.find(it => it.item === 'cap')
|
|
expect(capItem).toBeDefined()
|
|
expect(capItem?.kind).toBe('base-item')
|
|
expect(capItem?.prob).toBe(1)
|
|
expect(capItem?.isDangling).toBe(false)
|
|
expect(capItem?.isClassic).toBe(true)
|
|
})
|
|
|
|
it('supports mergeAutoTreasureClasses into TreasureClassTable', async () => {
|
|
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 tcTable = await loadTreasureClasses(archives)
|
|
|
|
// Before merge: auto-TCs return undefined
|
|
expect(tcTable.get('armo3')).toBeUndefined()
|
|
expect(tcTable.get('weap87')).toBeUndefined()
|
|
|
|
const initialTotal = tcTable.all.length
|
|
expect(initialTotal).toBe(852)
|
|
|
|
// Merge
|
|
const merged = mergeAutoTreasureClasses(tcTable, autoTcs)
|
|
expect(merged).toBe(tcTable)
|
|
expect(tcTable.all.length).toBe(852 + 100)
|
|
|
|
// After merge: auto-TCs are accessible via .get() and .byName.get()
|
|
const armo3 = tcTable.get('armo3')
|
|
expect(armo3).toBeDefined()
|
|
expect(armo3?.name).toBe('armo3')
|
|
expect(armo3?.level).toBe(3)
|
|
expect(armo3?.items.length).toBe(7)
|
|
|
|
const armo3Upper = tcTable.get('ARMO3')
|
|
expect(armo3Upper).toBe(armo3)
|
|
|
|
const weap87 = tcTable.get('weap87')
|
|
expect(weap87).toBeDefined()
|
|
expect(weap87?.level).toBe(87)
|
|
|
|
const mele39 = tcTable.get('mele39')
|
|
expect(mele39).toBeDefined()
|
|
expect(mele39?.level).toBe(39)
|
|
|
|
// Merging a second time is idempotent (doesn't duplicate nodes in all)
|
|
mergeAutoTreasureClasses(tcTable, autoTcs)
|
|
expect(tcTable.all.length).toBe(852 + 100)
|
|
})
|
|
|
|
it('supports queryTreasureClass and queryAutoTreasureClass helpers', async () => {
|
|
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 tcTable = await loadTreasureClasses(archives)
|
|
|
|
// Direct TC query
|
|
const gold = queryTreasureClass(tcTable, autoTcs, 'Gold')
|
|
expect(gold).toBeDefined()
|
|
expect(gold?.name).toBe('Gold')
|
|
|
|
// Auto TC fallback query
|
|
const armo3 = queryTreasureClass(tcTable, autoTcs, 'armo3')
|
|
expect(armo3).toBeDefined()
|
|
expect(armo3?.name).toBe('armo3')
|
|
expect(armo3?.items.length).toBe(7)
|
|
|
|
// Non-existent query
|
|
expect(queryTreasureClass(tcTable, autoTcs, 'NonExistent')).toBeUndefined()
|
|
|
|
// queryAutoTreasureClass
|
|
expect(queryAutoTreasureClass(autoTcs, 'armo3')?.name).toBe('armo3')
|
|
expect(queryAutoTreasureClass(autoTcs, 'ARMO3')?.name).toBe('armo3')
|
|
expect(queryAutoTreasureClass(autoTcs, 'Gold')).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('Synthetic Hermetic Unit Tests (no MPQs required)', () => {
|
|
function createMockTypes(): ItemTypeTable {
|
|
const defs: ItemTypeDefinition[] = [
|
|
{
|
|
code: 'armo',
|
|
name: 'Any Armor',
|
|
equiv1: '',
|
|
equiv2: '',
|
|
treasureClass: 1,
|
|
rarity: 3,
|
|
maxSock1: 0,
|
|
maxSock25: 0,
|
|
maxSock40: 0,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'tors',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'helm',
|
|
name: 'Helm',
|
|
equiv1: 'armo',
|
|
equiv2: '',
|
|
treasureClass: 0,
|
|
rarity: 3,
|
|
maxSock1: 2,
|
|
maxSock25: 3,
|
|
maxSock40: 3,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'head',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'weap',
|
|
name: 'Weapon',
|
|
equiv1: '',
|
|
equiv2: '',
|
|
treasureClass: 1,
|
|
rarity: 3,
|
|
maxSock1: 0,
|
|
maxSock25: 0,
|
|
maxSock40: 0,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'rarm',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'axe',
|
|
name: 'Axe',
|
|
equiv1: 'mele',
|
|
equiv2: '',
|
|
treasureClass: 0,
|
|
rarity: 3,
|
|
maxSock1: 2,
|
|
maxSock25: 4,
|
|
maxSock40: 6,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'rarm',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'mele',
|
|
name: 'Melee Weapon',
|
|
equiv1: 'weap',
|
|
equiv2: '',
|
|
treasureClass: 1,
|
|
rarity: 3,
|
|
maxSock1: 0,
|
|
maxSock25: 0,
|
|
maxSock40: 0,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'rarm',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'bow',
|
|
name: 'Bow',
|
|
equiv1: 'miss',
|
|
equiv2: '',
|
|
treasureClass: 1,
|
|
rarity: 3,
|
|
maxSock1: 3,
|
|
maxSock25: 4,
|
|
maxSock40: 6,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'rarm',
|
|
bodyLoc2: 'larm',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
{
|
|
code: 'miss',
|
|
name: 'Missile Weapon',
|
|
equiv1: 'weap',
|
|
equiv2: '',
|
|
treasureClass: 0,
|
|
rarity: 3,
|
|
maxSock1: 0,
|
|
maxSock25: 0,
|
|
maxSock40: 0,
|
|
magic: false,
|
|
rare: true,
|
|
normal: false,
|
|
charm: false,
|
|
gem: false,
|
|
staffMods: '',
|
|
body: true,
|
|
bodyLoc1: 'rarm',
|
|
bodyLoc2: '',
|
|
beltable: false,
|
|
class: '',
|
|
},
|
|
]
|
|
|
|
const byCode = new Map<string, ItemTypeDefinition>()
|
|
for (const d of defs) {
|
|
byCode.set(d.code, d)
|
|
}
|
|
return { types: defs, byCode, _isACache: new Map() }
|
|
}
|
|
|
|
function createMockArmor(): ArmorTable {
|
|
const items: ArmorBase[] = [
|
|
{
|
|
id: 'cap',
|
|
code: 'cap',
|
|
name: 'Cap',
|
|
namestr: 'cap',
|
|
version: 0,
|
|
kind: 'armor',
|
|
spawnable: true,
|
|
rarity: 1,
|
|
level: 1,
|
|
levelreq: 0,
|
|
minac: 3,
|
|
maxac: 5,
|
|
reqstr: 0,
|
|
durability: 12,
|
|
cost: 12,
|
|
gambleCost: 100,
|
|
type: 'helm',
|
|
gemsockets: 2,
|
|
gemapplytype: 0,
|
|
normcode: 'cap',
|
|
ubercode: 'xap',
|
|
ultracode: 'uap',
|
|
invWidth: 1,
|
|
invHeight: 2,
|
|
tags: ['helm'],
|
|
defense: 5,
|
|
maxStack: 1,
|
|
value: 12,
|
|
damage: 0,
|
|
},
|
|
// Excluded: rarity 0
|
|
{
|
|
id: 'zer',
|
|
code: 'zer',
|
|
name: 'Zero Armor',
|
|
namestr: 'zer',
|
|
version: 0,
|
|
kind: 'armor',
|
|
spawnable: true,
|
|
rarity: 0,
|
|
level: 2,
|
|
minac: 0,
|
|
maxac: 0,
|
|
reqstr: 0,
|
|
durability: 0,
|
|
cost: 0,
|
|
gambleCost: 0,
|
|
type: 'helm',
|
|
gemsockets: 0,
|
|
gemapplytype: 0,
|
|
normcode: '',
|
|
ubercode: '',
|
|
ultracode: '',
|
|
invWidth: 1,
|
|
invHeight: 1,
|
|
tags: ['helm'],
|
|
defense: 0,
|
|
maxStack: 1,
|
|
value: 0,
|
|
damage: 0,
|
|
levelreq: 0,
|
|
},
|
|
]
|
|
const byCode = new Map<string, ArmorBase>()
|
|
for (const it of items) byCode.set(it.code, it)
|
|
return new ArmorTable(items, byCode)
|
|
}
|
|
|
|
function createMockWeapons(): WeaponTable {
|
|
const items: WeaponBase[] = [
|
|
{
|
|
id: 'hax',
|
|
code: 'hax',
|
|
name: 'Hand Axe',
|
|
namestr: 'hax',
|
|
version: 0,
|
|
kind: 'weapon',
|
|
spawnable: true,
|
|
rarity: 3,
|
|
level: 3,
|
|
levelreq: 0,
|
|
mindam: 3,
|
|
maxdam: 6,
|
|
twoHanded: false,
|
|
speed: 0,
|
|
reqstr: 0,
|
|
reqdex: 0,
|
|
durability: 28,
|
|
cost: 170,
|
|
gambleCost: 4510,
|
|
type: 'axe',
|
|
wclass: '1hs',
|
|
stackable: false,
|
|
rangeadder: 0,
|
|
normcode: 'hax',
|
|
ubercode: '9ha',
|
|
ultracode: '7ha',
|
|
gemsockets: 2,
|
|
invWidth: 1,
|
|
invHeight: 3,
|
|
tags: ['axe'],
|
|
damage: 6,
|
|
value: 170,
|
|
defense: 0,
|
|
maxStack: 1,
|
|
},
|
|
]
|
|
const byCode = new Map<string, WeaponBase>()
|
|
for (const it of items) byCode.set(it.code, it)
|
|
return {
|
|
all: items,
|
|
byCode,
|
|
get: (c: string) => byCode.get(c.trim().toLowerCase()),
|
|
length: items.length,
|
|
} as unknown as WeaponTable
|
|
}
|
|
|
|
it('filters out rarity === 0 items and populates armo3 and weap3', () => {
|
|
const mockTypes = createMockTypes()
|
|
const mockArmor = createMockArmor()
|
|
const mockWeapons = createMockWeapons()
|
|
|
|
const result = generateAutoTreasureClasses(mockTypes, mockArmor, mockWeapons)
|
|
expect(result.size).toBe(100)
|
|
|
|
const armo3 = result.get('armo3')!
|
|
expect(armo3.entries).toEqual([{ itemCode: 'cap', prob: 1 }])
|
|
expect(armo3.totalProb).toBe(1)
|
|
|
|
const weap3 = result.get('weap3')!
|
|
expect(weap3.entries).toEqual([{ itemCode: 'hax', prob: 3 }])
|
|
expect(weap3.totalProb).toBe(3)
|
|
|
|
const mele3 = result.get('mele3')!
|
|
expect(mele3.entries).toEqual([{ itemCode: 'hax', prob: 3 }])
|
|
expect(mele3.totalProb).toBe(3)
|
|
|
|
const bow3 = result.get('bow3')!
|
|
expect(bow3.entries).toEqual([])
|
|
expect(bow3.totalProb).toBe(0)
|
|
})
|
|
})
|
|
})
|