333 lines
14 KiB
TypeScript
333 lines
14 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
calculateBashStats,
|
|
calculateLeapStats,
|
|
calculateDoubleSwingStats,
|
|
calculateStunStats,
|
|
calculateDoubleThrowStats,
|
|
calculateLeapAttackStats,
|
|
calculateConcentrateStats,
|
|
calculateFrenzyStats,
|
|
calculateWhirlwindStats,
|
|
calculateBerserkStats,
|
|
} from '../../../src/game/skills/barbarian-combat.ts'
|
|
import { BATCH1_SKILLS } from '../../../src/game/skills.ts'
|
|
import { getSharedDataRegistry } from '../../../src/game/engine/data-registry.ts'
|
|
import { UnitStatList } from '../../../src/game/engine/stat-list.ts'
|
|
import { evaluateSkill113c } from '../../../src/game/skills/registry.ts'
|
|
|
|
describe('Milestone M17 — Barbarian Combat Skills Parity & Adversarial Stress Suite', () => {
|
|
// =========================================================================
|
|
// Dimension 1: Exact 1.13c Numerical Scaling & Level Progressions
|
|
// =========================================================================
|
|
describe('Dimension 1: Exact 1.13c Numerical Scaling & Formulas', () => {
|
|
it('1.1 Bash (126): Evaluates exact damage %, flat damage, and knockback at slvl 1, 10, 20', () => {
|
|
// slvl 1
|
|
const b1 = calculateBashStats(1, 0)
|
|
expect(b1.damageBonusPct).toBe(50)
|
|
expect(b1.flatPhysicalMin).toBe(1)
|
|
expect(b1.flatPhysicalMax).toBe(1)
|
|
expect(b1.knockbackChancePct).toBe(100)
|
|
expect(b1.toHitBonusPct).toBe(20)
|
|
expect(b1.manaCost).toBe(2)
|
|
expect(b1.manaCost256).toBe(512)
|
|
|
|
// slvl 10
|
|
const b10 = calculateBashStats(10, 0)
|
|
expect(b10.damageBonusPct).toBe(50 + 9 * 5) // 95%
|
|
expect(b10.flatPhysicalMin).toBe(1 + 9 * 1) // 10
|
|
expect(b10.flatPhysicalMax).toBe(10)
|
|
expect(b10.toHitBonusPct).toBe(20 + 9 * 5) // 65%
|
|
|
|
// slvl 20
|
|
const b20 = calculateBashStats(20, 0)
|
|
expect(b20.damageBonusPct).toBe(50 + 19 * 5) // 145%
|
|
expect(b20.flatPhysicalMin).toBe(20)
|
|
expect(b20.flatPhysicalMax).toBe(20)
|
|
expect(b20.toHitBonusPct).toBe(20 + 19 * 5) // 115%
|
|
})
|
|
|
|
it('1.2 Leap (132): Evaluates knockback radius scaling', () => {
|
|
const l1 = calculateLeapStats(1)
|
|
expect(l1.knockbackRadiusSubtiles).toBe(4)
|
|
expect(l1.minDistanceYards).toBe(4)
|
|
expect(l1.maxDistanceYards).toBe(30)
|
|
expect(l1.manaCost).toBe(2)
|
|
|
|
const l10 = calculateLeapStats(10)
|
|
expect(l10.knockbackRadiusSubtiles).toBe(4 + 9 * 1) // 13 subtiles
|
|
|
|
const l20 = calculateLeapStats(20)
|
|
expect(l20.knockbackRadiusSubtiles).toBe(4 + 19 * 1) // 23 subtiles
|
|
})
|
|
|
|
it('1.3 Double Swing (133): Evaluates attack rating and descending mana cost to 0 at slvl 9+', () => {
|
|
const ds1 = calculateDoubleSwingStats(1, 0)
|
|
expect(ds1.damageBonusPct).toBe(0)
|
|
expect(ds1.attackRateBonusPct).toBe(50)
|
|
expect(ds1.toHitBonusPct).toBe(15)
|
|
expect(ds1.manaCost).toBe(2)
|
|
expect(ds1.manaCost256).toBe(512)
|
|
expect(ds1.requiresDualWield).toBe(true)
|
|
|
|
const ds5 = calculateDoubleSwingStats(5, 0)
|
|
expect(ds5.toHitBonusPct).toBe(15 + 4 * 5) // 35%
|
|
expect(ds5.manaCost256).toBe(256) // 1 mana
|
|
|
|
const ds9 = calculateDoubleSwingStats(9, 0)
|
|
expect(ds9.manaCost).toBe(0)
|
|
expect(ds9.manaCost256).toBe(0)
|
|
|
|
const ds20 = calculateDoubleSwingStats(20, 0)
|
|
expect(ds20.manaCost).toBe(0)
|
|
expect(ds20.manaCost256).toBe(0)
|
|
expect(ds20.toHitBonusPct).toBe(15 + 19 * 5) // 110%
|
|
})
|
|
|
|
it('1.4 Stun (139): Evaluates base stun duration and attack rating', () => {
|
|
const s1 = calculateStunStats(1, 0, 0)
|
|
expect(s1.baseDurationFrames).toBe(30) // 1.2s
|
|
expect(s1.stunDurationFrames).toBe(30)
|
|
expect(s1.toHitBonusPct).toBe(15)
|
|
expect(s1.manaCost).toBe(2)
|
|
expect(s1.overlayName).toBe('stun')
|
|
|
|
const s10 = calculateStunStats(10, 0, 0)
|
|
expect(s10.baseDurationFrames).toBe(30 + 9 * 5) // 75 frames = 3.0s
|
|
expect(s10.toHitBonusPct).toBe(15 + 9 * 5) // 60%
|
|
|
|
const s20 = calculateStunStats(20, 0, 0)
|
|
expect(s20.baseDurationFrames).toBe(30 + 19 * 5) // 125 frames = 5.0s
|
|
expect(s20.toHitBonusPct).toBe(15 + 19 * 5) // 110%
|
|
})
|
|
|
|
it('1.5 Double Throw (140): Evaluates attack rating progression', () => {
|
|
const dt1 = calculateDoubleThrowStats(1, 0)
|
|
expect(dt1.toHitBonusPct).toBe(20)
|
|
expect(dt1.manaCost).toBe(2)
|
|
expect(dt1.requiresDualThrowing).toBe(true)
|
|
|
|
const dt10 = calculateDoubleThrowStats(10, 0)
|
|
expect(dt10.toHitBonusPct).toBe(20 + 9 * 10) // 110%
|
|
|
|
const dt20 = calculateDoubleThrowStats(20, 0)
|
|
expect(dt20.toHitBonusPct).toBe(20 + 19 * 10) // 210%
|
|
})
|
|
|
|
it('1.6 Leap Attack (143): Evaluates massive damage and knockback radius', () => {
|
|
const la1 = calculateLeapAttackStats(1, 0)
|
|
expect(la1.damageBonusPct).toBe(100)
|
|
expect(la1.knockbackRadiusSubtiles).toBe(4)
|
|
expect(la1.toHitBonusPct).toBe(50)
|
|
expect(la1.manaCost).toBe(9)
|
|
expect(la1.manaCost256).toBe(2304)
|
|
|
|
const la10 = calculateLeapAttackStats(10, 0)
|
|
expect(la10.damageBonusPct).toBe(100 + 9 * 30) // 370%
|
|
expect(la10.knockbackRadiusSubtiles).toBe(4 + 9 * 2) // 22 subtiles
|
|
expect(la10.toHitBonusPct).toBe(50 + 9 * 15) // 185%
|
|
|
|
const la20 = calculateLeapAttackStats(20, 0)
|
|
expect(la20.damageBonusPct).toBe(100 + 19 * 30) // 670%
|
|
expect(la20.knockbackRadiusSubtiles).toBe(4 + 19 * 2) // 42 subtiles
|
|
expect(la20.toHitBonusPct).toBe(50 + 19 * 15) // 335%
|
|
})
|
|
|
|
it('1.7 Concentrate (144): Evaluates defense bonus and uninterruptible attack', () => {
|
|
const c1 = calculateConcentrateStats(1, 0, 0, 0)
|
|
expect(c1.damageBonusPct).toBe(70)
|
|
expect(c1.defenseBonusPct).toBe(100)
|
|
expect(c1.toHitBonusPct).toBe(60)
|
|
expect(c1.isUninterruptible).toBe(true)
|
|
expect(c1.manaCost).toBe(2)
|
|
|
|
const c10 = calculateConcentrateStats(10, 0, 0, 0)
|
|
expect(c10.damageBonusPct).toBe(70 + 9 * 5) // 115%
|
|
expect(c10.defenseBonusPct).toBe(100 + 9 * 10) // 190%
|
|
expect(c10.toHitBonusPct).toBe(60 + 9 * 10) // 150%
|
|
|
|
const c20 = calculateConcentrateStats(20, 0, 0, 0)
|
|
expect(c20.damageBonusPct).toBe(70 + 19 * 5) // 165%
|
|
expect(c20.defenseBonusPct).toBe(100 + 19 * 10) // 290%
|
|
expect(c20.toHitBonusPct).toBe(60 + 19 * 10) // 250%
|
|
})
|
|
|
|
it('1.8 Frenzy (147): Evaluates speed caps, duration (150 frames), and attack progression', () => {
|
|
const f1 = calculateFrenzyStats(1, 0, 0, 0)
|
|
expect(f1.damageBonusPct).toBe(90)
|
|
expect(f1.toHitBonusPct).toBe(100)
|
|
expect(f1.minRunSpeedPct).toBe(20)
|
|
expect(f1.durationFrames).toBe(150)
|
|
expect(f1.manaCost).toBe(3)
|
|
expect(f1.overlayName).toBe('frenzy')
|
|
expect(f1.requiresDualWield).toBe(true)
|
|
|
|
const f10 = calculateFrenzyStats(10, 0, 0, 0)
|
|
expect(f10.damageBonusPct).toBe(90 + 9 * 5) // 135%
|
|
expect(f10.toHitBonusPct).toBe(100 + 9 * 7) // 163%
|
|
expect(f10.maxRunSpeedPct).toBe(20 + 9 * 5) // 65%
|
|
|
|
const f20 = calculateFrenzyStats(20, 0, 0, 0)
|
|
expect(f20.damageBonusPct).toBe(90 + 19 * 5) // 185%
|
|
expect(f20.toHitBonusPct).toBe(100 + 19 * 7) // 233%
|
|
expect(f20.maxRunSpeedPct).toBe(20 + 19 * 5) // 115%
|
|
expect(f20.maxAttackSpeedPct).toBe(Math.min(50, 7 + 19 * 2)) // 45%
|
|
})
|
|
|
|
it('1.9 Whirlwind (151): Evaluates initial negative damage scaling (-50% to +102%) and hit frequency (4 frames)', () => {
|
|
const ww1 = calculateWhirlwindStats(1)
|
|
expect(ww1.damageBonusPct).toBe(-50)
|
|
expect(ww1.toHitBonusPct).toBe(0)
|
|
expect(ww1.hitFrequencyFrames).toBe(4)
|
|
expect(ww1.manaCost).toBe(25)
|
|
expect(ww1.manaCost256).toBe(6400)
|
|
|
|
const ww10 = calculateWhirlwindStats(10)
|
|
expect(ww10.damageBonusPct).toBe(-50 + 9 * 8) // +22%
|
|
expect(ww10.toHitBonusPct).toBe(9 * 5) // 45%
|
|
expect(ww10.manaCost).toBe(34)
|
|
|
|
const ww20 = calculateWhirlwindStats(20)
|
|
expect(ww20.damageBonusPct).toBe(-50 + 19 * 8) // +102%
|
|
expect(ww20.toHitBonusPct).toBe(19 * 5) // 95%
|
|
expect(ww20.manaCost).toBe(44)
|
|
})
|
|
|
|
it('1.10 Berserk (152): Evaluates 100% magic damage conversion and decreasing zero-defense duration', () => {
|
|
const bz1 = calculateBerserkStats(1, 0, 0)
|
|
expect(bz1.damageBonusPct).toBe(150)
|
|
expect(bz1.magicConversionPct).toBe(100)
|
|
expect(bz1.toHitBonusPct).toBe(100)
|
|
expect(bz1.manaCost).toBe(4)
|
|
expect(bz1.zeroDefenseDurationFrames).toBeLessThanOrEqual(75)
|
|
expect(bz1.zeroDefenseDurationFrames).toBeGreaterThanOrEqual(25)
|
|
expect(bz1.overlayName).toBe('berserkfront')
|
|
|
|
const bz20 = calculateBerserkStats(20, 0, 0)
|
|
expect(bz20.damageBonusPct).toBe(150 + 19 * 15) // 435%
|
|
expect(bz20.toHitBonusPct).toBe(100 + 19 * 15) // 385%
|
|
// Duration decreases with level
|
|
expect(bz20.zeroDefenseDurationFrames).toBeLessThan(bz1.zeroDefenseDurationFrames)
|
|
})
|
|
})
|
|
|
|
// =========================================================================
|
|
// Dimension 2: 1.13c Synergy Integration & Blvl Rules
|
|
// =========================================================================
|
|
describe('Dimension 2: 1.13c Synergy Integration', () => {
|
|
it('2.1 Bash receives +5% damage per hard point in Stun', () => {
|
|
const bBase = calculateBashStats(10, 0)
|
|
const bSyn10 = calculateBashStats(10, 10)
|
|
const bSyn20 = calculateBashStats(10, 20)
|
|
|
|
expect(bSyn10.damageBonusPct - bBase.damageBonusPct).toBe(50) // +50%
|
|
expect(bSyn20.damageBonusPct - bBase.damageBonusPct).toBe(100) // +100%
|
|
})
|
|
|
|
it('2.2 Double Swing receives +10% damage per hard point in Bash', () => {
|
|
const dsBase = calculateDoubleSwingStats(1, 0)
|
|
const dsSyn20 = calculateDoubleSwingStats(1, 20)
|
|
|
|
expect(dsSyn20.damageBonusPct - dsBase.damageBonusPct).toBe(200) // +200%
|
|
})
|
|
|
|
it('2.3 Stun receives +8% damage from Bash and +5% duration from War Cry', () => {
|
|
const sBase = calculateStunStats(10, 0, 0)
|
|
const sSyn = calculateStunStats(10, 20, 20)
|
|
|
|
expect(sSyn.damageBonusPct).toBe(160) // 20 * 8%
|
|
expect(sSyn.stunDurationFrames).toBe(Math.trunc(sBase.baseDurationFrames * 2.0)) // +100% duration
|
|
})
|
|
|
|
it('2.4 Concentrate receives +5% dmg from Bash, +10% dmg from Battle Orders, +1% magic from Berserk', () => {
|
|
const cBase = calculateConcentrateStats(10, 0, 0, 0)
|
|
const cSyn = calculateConcentrateStats(10, 20, 20, 20)
|
|
|
|
expect(cSyn.damageBonusPct - cBase.damageBonusPct).toBe(20 * 5 + 20 * 10) // +300%
|
|
expect(cSyn.magicConversionPct).toBe(20) // 20% magic damage conversion
|
|
})
|
|
|
|
it('2.5 Frenzy receives +8% dmg from Double Swing and Taunt, +1% magic from Berserk', () => {
|
|
const fBase = calculateFrenzyStats(10, 0, 0, 0)
|
|
const fSyn = calculateFrenzyStats(10, 20, 20, 20)
|
|
|
|
expect(fSyn.damageBonusPct - fBase.damageBonusPct).toBe((20 + 20) * 8) // +320%
|
|
expect(fSyn.magicConversionPct).toBe(20)
|
|
})
|
|
|
|
it('2.6 Berserk receives +10% magic damage from Howl and Shout', () => {
|
|
const bzBase = calculateBerserkStats(10, 0, 0)
|
|
const bzSyn = calculateBerserkStats(10, 20, 20)
|
|
|
|
expect(bzSyn.damageBonusPct - bzBase.damageBonusPct).toBe((20 + 20) * 10) // +400%
|
|
})
|
|
})
|
|
|
|
// =========================================================================
|
|
// Dimension 3: Adversarial Boundary & Stress Cases
|
|
// =========================================================================
|
|
describe('Dimension 3: Adversarial Stress & Boundary Sanitization', () => {
|
|
it('3.1 Handles zero and negative levels safely without NaN or crash', () => {
|
|
for (const slvl of [-10, 0, 1]) {
|
|
const bash = calculateBashStats(slvl)
|
|
expect(Number.isFinite(bash.damageBonusPct)).toBe(true)
|
|
expect(bash.flatPhysicalMin).toBeGreaterThan(0)
|
|
|
|
const ds = calculateDoubleSwingStats(slvl)
|
|
expect(Number.isFinite(ds.manaCost)).toBe(true)
|
|
expect(ds.manaCost).toBeGreaterThanOrEqual(0)
|
|
|
|
const ww = calculateWhirlwindStats(slvl)
|
|
expect(Number.isFinite(ww.damageBonusPct)).toBe(true)
|
|
expect(ww.manaCost).toBeGreaterThan(0)
|
|
}
|
|
})
|
|
|
|
it('3.2 Handles massive extreme levels (slvl 99) monotonically', () => {
|
|
const bz99 = calculateBerserkStats(99, 20, 20)
|
|
expect(bz99.damageBonusPct).toBe(150 + 98 * 15 + 400) // 2020%
|
|
expect(bz99.zeroDefenseDurationFrames).toBeGreaterThanOrEqual(25)
|
|
|
|
const la99 = calculateLeapAttackStats(99, 20)
|
|
expect(la99.damageBonusPct).toBe(100 + 98 * 30 + 200) // 3240%
|
|
|
|
const ww99 = calculateWhirlwindStats(99)
|
|
expect(ww99.damageBonusPct).toBe(-50 + 98 * 8) // 734%
|
|
})
|
|
})
|
|
|
|
// =========================================================================
|
|
// Dimension 4: Registry Integration & Data-Driven Parity
|
|
// =========================================================================
|
|
describe('Dimension 4: Data-Driven Registry Integration', () => {
|
|
it('4.1 Verifies all 10 Barbarian Combat Skills evaluate via evaluateSkill113c', async () => {
|
|
const registry = await getSharedDataRegistry()
|
|
const stats = new UnitStatList()
|
|
const skillIds = [126, 132, 133, 139, 140, 143, 144, 147, 151, 152]
|
|
|
|
for (const id of skillIds) {
|
|
const skillRec = registry.getSkillById(id)
|
|
expect(skillRec, `Skills.txt record missing for skill ${id}`).toBeDefined()
|
|
stats.setBaseSkillLevel(id, 10)
|
|
|
|
const res = evaluateSkill113c({
|
|
registry,
|
|
skill: skillRec!,
|
|
slvl: 10,
|
|
blvl: 10,
|
|
statList: stats,
|
|
})
|
|
|
|
expect(res.skillId).toBe(id)
|
|
expect(res.manaCost).toBeGreaterThanOrEqual(0)
|
|
expect(Number.isFinite(res.manaCost256)).toBe(true)
|
|
expect(Number.isFinite(res.toHitBonusPct)).toBe(true)
|
|
}
|
|
})
|
|
|
|
it('4.2 Enforces BATCH1_SKILLS length invariant = strictly 38', () => {
|
|
expect(Object.keys(BATCH1_SKILLS).length).toBe(38)
|
|
})
|
|
})
|
|
})
|