feat(bar): implement Barbarian Combat Skills (IDs 126, 132, 133, 139, 140, 143, 144, 147, 151, 152)

- Authoritative 1.13c parity for 10 Barbarian Combat skills - Exact damage, attack rating, mana, duration, and knockback formulas - 6-part synergy integration (Bash, Stun, Double Swing, Concentrate, Frenzy, Berserk) - Adversarial stress tests (slvl 0, 1, 10, 20, 99) - Enforces BATCH1_SKILLS length invariant = strictly 38 - Fixes #464
2026-09-25 01:56:23 +00:00 · 2026-09-25 01:56:23 +00:00 · bd4920f3aa
parent 98210321da
commit bd4920f3aa
2 changed files with 770 additions and 0 deletions
--- a/src/game/skills/barbarian-combat.ts
+++ b/src/game/skills/barbarian-combat.ts
@ -0,0 +1,438 @@
+/**
+ * Diablo II: Lord of Destruction v1.13c — Barbarian Combat Skills Module
+ *
+ * Dedicated pure calculation and kinematics formulas for the 10 Barbarian Combat Skills:
+ * - Skill 126: Bash (ReqLevel 1)
+ * - Skill 132: Leap (ReqLevel 6)
+ * - Skill 133: Double Swing (ReqLevel 6)
+ * - Skill 139: Stun (ReqLevel 12)
+ * - Skill 140: Double Throw (ReqLevel 12)
+ * - Skill 143: Leap Attack (ReqLevel 18)
+ * - Skill 144: Concentrate (ReqLevel 18)
+ * - Skill 147: Frenzy (ReqLevel 24)
+ * - Skill 151: Whirlwind (ReqLevel 30)
+ * - Skill 152: Berserk (ReqLevel 30)
+ *
+ * 1.13c Ground Truth:
+ * - Skills.txt & Missiles.txt & Overlay.txt (Patch_D2.mpq)
+ * - Strict fixed-point 24.8 mana calculations
+ * - Uninterruptible swing flag for Concentrate
+ * - Double Swing mana reduction reaching 0 at slvl 9+
+ * - Frenzy dual-wield buff duration (150 frames = 6s) and speed scaling
+ * - Whirlwind spinning path progression (-50% + 8%/lvl)
+ * - Berserk 100% physical to magic damage conversion & defense zeroing
+ */
+
+// --- Interfaces for Skill Calculations ---
+
+export interface BashStats {
+  readonly damageBonusPct: number
+  readonly flatPhysicalMin: number
+  readonly flatPhysicalMax: number
+  readonly knockbackChancePct: number
+  readonly toHitBonusPct: number
+  readonly manaCost: number
+  readonly manaCost256: number
+}
+
+export interface LeapStats {
+  readonly minDistanceYards: number
+  readonly maxDistanceYards: number
+  readonly knockbackRadiusSubtiles: number
+  readonly manaCost: number
+  readonly manaCost256: number
+}
+
+export interface DoubleSwingStats {
+  readonly damageBonusPct: number
+  readonly attackRateBonusPct: number
+  readonly toHitBonusPct: number
+  readonly manaCost: number
+  readonly manaCost256: number
+  readonly requiresDualWield: boolean
+}
+
+export interface StunStats {
+  readonly stunDurationFrames: number
+  readonly baseDurationFrames: number
+  readonly damageBonusPct: number
+  readonly toHitBonusPct: number
+  readonly manaCost: number
+  readonly manaCost256: number
+  readonly overlayName: string
+}
+
+export interface DoubleThrowStats {
+  readonly damageBonusPct: number
+  readonly toHitBonusPct: number
+  readonly manaCost: number
+  readonly manaCost256: number
+  readonly requiresDualThrowing: boolean
+}
+
+export interface LeapAttackStats {
+  readonly damageBonusPct: number
+  readonly knockbackRadiusSubtiles: number
+  readonly toHitBonusPct: number
+  readonly minDistanceYards: number
+  readonly maxDistanceYards: number
+  readonly manaCost: number
+  readonly manaCost256: number
+}
+
+export interface ConcentrateStats {
+  readonly damageBonusPct: number
+  readonly defenseBonusPct: number
+  readonly toHitBonusPct: number
+  readonly magicConversionPct: number
+  readonly isUninterruptible: boolean
+  readonly manaCost: number
+  readonly manaCost256: number
+}
+
+export interface FrenzyStats {
+  readonly damageBonusPct: number
+  readonly toHitBonusPct: number
+  readonly minRunSpeedPct: number
+  readonly maxRunSpeedPct: number
+  readonly maxAttackSpeedPct: number
+  readonly durationFrames: number
+  readonly magicConversionPct: number
+  readonly manaCost: number
+  readonly manaCost256: number
+  readonly overlayName: string
+  readonly requiresDualWield: boolean
+}
+
+export interface WhirlwindStats {
+  readonly damageBonusPct: number
+  readonly toHitBonusPct: number
+  readonly attacksPerTick: number
+  readonly hitFrequencyFrames: number
+  readonly manaCost: number
+  readonly manaCost256: number
+}
+
+export interface BerserkStats {
+  readonly damageBonusPct: number
+  readonly toHitBonusPct: number
+  readonly magicConversionPct: number
+  readonly zeroDefenseDurationFrames: number
+  readonly manaCost: number
+  readonly manaCost256: number
+  readonly overlayName: string
+}
+
+// --- Pure Calculation Functions ---
+
+/**
+ * Skill 126: Bash
+ * Ground Truth:
+ * - calc1: ln12 + skill('Stun'.blvl)*par8 (ln12: par1=50, par2=5, par8=5)
+ * - calc2: ln34 (par3=1, par4=1) -> flat min/max physical damage
+ * - toHit: 20 base, +5/lvl
+ * - Knockback: 100%
+ * - Mana: 2 (constant)
+ */
+export function calculateBashStats(slvl: number, stunBlvl = 0): BashStats {
+  const lvl = Math.max(1, slvl)
+  const stunPts = Math.max(0, stunBlvl)
+
+  const damageBonusPct = 50 + (lvl - 1) * 5 + stunPts * 5
+  const flatPhysicalMin = 1 + (lvl - 1) * 1
+  const flatPhysicalMax = 1 + (lvl - 1) * 1
+  const toHitBonusPct = 20 + (lvl - 1) * 5
+
+  return {
+    damageBonusPct,
+    flatPhysicalMin,
+    flatPhysicalMax,
+    knockbackChancePct: 100,
+    toHitBonusPct,
+    manaCost: 2,
+    manaCost256: 512,
+  }
+}
+
+/**
+ * Skill 132: Leap
+ * Ground Truth:
+ * - p1: 4 (min distance), p2: 30 (max distance)
+ * - calc1: ln34 (p3: 4, p4: 1) -> knockback radius in subtiles
+ * - Mana: 2 (constant)
+ */
+export function calculateLeapStats(slvl: number, leapAttackBlvl = 0): LeapStats {
+  const lvl = Math.max(1, slvl)
+  const knockbackRadiusSubtiles = 4 + (lvl - 1) * 1
+
+  return {
+    minDistanceYards: 4,
+    maxDistanceYards: 30,
+    knockbackRadiusSubtiles,
+    manaCost: 2,
+    manaCost256: 512,
+  }
+}
+
+/**
+ * Skill 133: Double Swing
+ * Ground Truth:
+ * - calc1: skill('Bash'.blvl)*par8 (par8=10)
+ * - toHit: 15, LevToHit: 5 -> 15 + (lvl - 1) * 5
+ * - mana: 8 (in 256ths / 4), lvlmana: -1 (decreases by 64 in 256ths)
+ *   slvl 1: 512 (2 mana)
+ *   slvl 2: 448 (1.75 mana)
+ *   slvl 5: 256 (1 mana)
+ *   slvl 9+: 0 mana
+ */
+export function calculateDoubleSwingStats(slvl: number, bashBlvl = 0): DoubleSwingStats {
+  const lvl = Math.max(1, slvl)
+  const bashPts = Math.max(0, bashBlvl)
+
+  const damageBonusPct = bashPts * 10
+  const toHitBonusPct = 15 + (lvl - 1) * 5
+
+  // 1.13c mana calculation: mana = 8, lvlmana = -1
+  const rawManaCost256 = Math.max(0, (8 - (lvl - 1)) * 64)
+  const manaCost = Math.max(0, Math.ceil(rawManaCost256 / 256))
+
+  return {
+    damageBonusPct,
+    attackRateBonusPct: 50,
+    toHitBonusPct,
+    manaCost,
+    manaCost256: rawManaCost256,
+    requiresDualWield: true,
+  }
+}
+
+/**
+ * Skill 139: Stun
+ * Ground Truth:
+ * - p1: 30 (duration frames base), p2: 5 (duration frames/lvl)
+ * - calc1: skill('Bash'.blvl)*par8 (par8=8) -> +8% damage/pt
+ * - ELenSymPerCalc: skill('War Cry'.blvl)*par6 (par6=5) -> +5% duration/pt
+ * - toHit: 15 base, +5/lvl
+ * - Mana: 2 (constant)
+ */
+export function calculateStunStats(slvl: number, bashBlvl = 0, warCryBlvl = 0): StunStats {
+  const lvl = Math.max(1, slvl)
+  const bashPts = Math.max(0, bashBlvl)
+  const warCryPts = Math.max(0, warCryBlvl)
+
+  const baseDurationFrames = 30 + (lvl - 1) * 5
+  const stunDurationFrames = Math.trunc((baseDurationFrames * (100 + warCryPts * 5)) / 100)
+  const damageBonusPct = bashPts * 8
+  const toHitBonusPct = 15 + (lvl - 1) * 5
+
+  return {
+    stunDurationFrames,
+    baseDurationFrames,
+    damageBonusPct,
+    toHitBonusPct,
+    manaCost: 2,
+    manaCost256: 512,
+    overlayName: 'stun',
+  }
+}
+
+/**
+ * Skill 140: Double Throw
+ * Ground Truth:
+ * - calc1: skill('Double Swing'.blvl)*par8 (par8=8)
+ * - toHit: 20, LevToHit: 10 -> 20 + (lvl - 1) * 10
+ * - Mana: 2 (512 in 256ths)
+ */
+export function calculateDoubleThrowStats(slvl: number, doubleSwingBlvl = 0): DoubleThrowStats {
+  const lvl = Math.max(1, slvl)
+  const dsPts = Math.max(0, doubleSwingBlvl)
+
+  const damageBonusPct = dsPts * 8
+  const toHitBonusPct = 20 + (lvl - 1) * 10
+
+  return {
+    damageBonusPct,
+    toHitBonusPct,
+    manaCost: 2,
+    manaCost256: 512,
+    requiresDualThrowing: true,
+  }
+}
+
+/**
+ * Skill 143: Leap Attack
+ * Ground Truth:
+ * - calc1: ln34 + skill('Leap'.blvl)*par8 (p3=100, p4=30, par8=10)
+ * - Knockback range: p5=4, p6=2 -> 4 + (lvl - 1) * 2 subtiles
+ * - toHit: 50, LevToHit: 15 -> 50 + (lvl - 1) * 15
+ * - Mana: 9 (constant)
+ */
+export function calculateLeapAttackStats(slvl: number, leapBlvl = 0): LeapAttackStats {
+  const lvl = Math.max(1, slvl)
+  const leapPts = Math.max(0, leapBlvl)
+
+  const damageBonusPct = 100 + (lvl - 1) * 30 + leapPts * 10
+  const knockbackRadiusSubtiles = 4 + (lvl - 1) * 2
+  const toHitBonusPct = 50 + (lvl - 1) * 15
+
+  return {
+    damageBonusPct,
+    knockbackRadiusSubtiles,
+    toHitBonusPct,
+    minDistanceYards: 4,
+    maxDistanceYards: 30,
+    manaCost: 9,
+    manaCost256: 2304,
+  }
+}
+
+/**
+ * Skill 144: Concentrate
+ * Ground Truth:
+ * - calc1: ln12 + skill('Bash'.blvl)*par8 + skill('Battle Orders'.blvl)*par7
+ *   (p1=70, p2=5, par8=5, par7=10)
+ * - defense bonus: p3=100, p4=10 -> 100 + (lvl - 1) * 10%
+ * - toHit: 60, LevToHit: 10 -> 60 + (lvl - 1) * 10
+ * - calc4: skill('Berserk'.blvl) -> 1% magic conversion per point
+ * - Mana: 2 (constant)
+ */
+export function calculateConcentrateStats(
+  slvl: number,
+  bashBlvl = 0,
+  battleOrdersBlvl = 0,
+  berserkBlvl = 0,
+): ConcentrateStats {
+  const lvl = Math.max(1, slvl)
+  const bashPts = Math.max(0, bashBlvl)
+  const boPts = Math.max(0, battleOrdersBlvl)
+  const berserkPts = Math.max(0, berserkBlvl)
+
+  const damageBonusPct = 70 + (lvl - 1) * 5 + bashPts * 5 + boPts * 10
+  const defenseBonusPct = 100 + (lvl - 1) * 10
+  const toHitBonusPct = 60 + (lvl - 1) * 10
+  const magicConversionPct = Math.min(100, berserkPts * 1)
+
+  return {
+    damageBonusPct,
+    defenseBonusPct,
+    toHitBonusPct,
+    magicConversionPct,
+    isUninterruptible: true,
+    manaCost: 2,
+    manaCost256: 512,
+  }
+}
+
+/**
+ * Skill 147: Frenzy
+ * Ground Truth:
+ * - calc1: ln12 + (skill('Double Swing'.blvl) + skill('Taunt'.blvl))*par8
+ *   (p1=90, p2=5, par8=8)
+ * - run speed: p3=20, p4=200
+ * - attack speed: p5=0, p6=50
+ * - duration: p7=150 frames (6s)
+ * - toHit: 100, LevToHit: 7 -> 100 + (lvl - 1) * 7
+ * - calc4: skill('Berserk'.blvl) -> 1% magic conversion per point
+ * - Mana: 3 (constant)
+ * - Overlay: Frenzy
+ */
+export function calculateFrenzyStats(
+  slvl: number,
+  doubleSwingBlvl = 0,
+  tauntBlvl = 0,
+  berserkBlvl = 0,
+): FrenzyStats {
+  const lvl = Math.max(1, slvl)
+  const dsPts = Math.max(0, doubleSwingBlvl)
+  const tauntPts = Math.max(0, tauntBlvl)
+  const berserkPts = Math.max(0, berserkBlvl)
+
+  const damageBonusPct = 90 + (lvl - 1) * 5 + (dsPts + tauntPts) * 8
+  const toHitBonusPct = 100 + (lvl - 1) * 7
+  const minRunSpeedPct = 20
+  const maxRunSpeedPct = Math.min(200, 20 + (lvl - 1) * 5)
+  const maxAttackSpeedPct = Math.min(50, 7 + (lvl - 1) * 2)
+  const magicConversionPct = Math.min(100, berserkPts * 1)
+
+  return {
+    damageBonusPct,
+    toHitBonusPct,
+    minRunSpeedPct,
+    maxRunSpeedPct,
+    maxAttackSpeedPct,
+    durationFrames: 150,
+    magicConversionPct,
+    manaCost: 3,
+    manaCost256: 768,
+    overlayName: 'frenzy',
+    requiresDualWield: true,
+  }
+}
+
+/**
+ * Skill 151: Whirlwind
+ * Ground Truth:
+ * - calc1: ln12 (p1=-50, p2=8) -> -50 + (lvl - 1) * 8%
+ * - toHit: 0, LevToHit: 5 -> 0 + (lvl - 1) * 5
+ * - Mana: 25 base, +1/lvl -> 25 + (lvl - 1) * 1
+ * - hit frequency: every 4 frames (1.13c ground truth)
+ */
+export function calculateWhirlwindStats(slvl: number): WhirlwindStats {
+  const lvl = Math.max(1, slvl)
+
+  const damageBonusPct = -50 + (lvl - 1) * 8
+  const toHitBonusPct = 0 + (lvl - 1) * 5
+  const manaCost = 25 + (lvl - 1) * 1
+  const manaCost256 = manaCost * 256
+
+  return {
+    damageBonusPct,
+    toHitBonusPct,
+    attacksPerTick: 1,
+    hitFrequencyFrames: 4,
+    manaCost,
+    manaCost256,
+  }
+}
+
+/**
+ * Skill 152: Berserk
+ * Ground Truth:
+ * - calc1: ln12 + (skill('Howl'.blvl) + skill('Shout'.blvl))*par8
+ *   (p1=150, p2=15, par8=10)
+ * - calc2: par4 - min(((110*lvl)/(lvl+6)*(par4-par3)/100),(par4-par3))
+ *   (par4=75, par3=25) -> defense zero duration
+ * - calc4: 100 -> 100% physical damage converted to Magic damage
+ * - toHit: 100, LevToHit: 15 -> 100 + (lvl - 1) * 15
+ * - Mana: 4 (constant)
+ * - Overlay: BerserkOverlay
+ */
+export function calculateBerserkStats(
+  slvl: number,
+  howlBlvl = 0,
+  shoutBlvl = 0,
+): BerserkStats {
+  const lvl = Math.max(1, slvl)
+  const howlPts = Math.max(0, howlBlvl)
+  const shoutPts = Math.max(0, shoutBlvl)
+
+  const damageBonusPct = 150 + (lvl - 1) * 15 + (howlPts + shoutPts) * 10
+  const toHitBonusPct = 100 + (lvl - 1) * 15
+
+  // calc2: par4 - min(((110*lvl)/(lvl+6)*(par4-par3)/100),(par4-par3))
+  const par4 = 75
+  const par3 = 25
+  const range = par4 - par3 // 50
+  const reduction = Math.min(range, Math.floor(((110 * lvl) / (lvl + 6)) * (range / 100)))
+  const zeroDefenseDurationFrames = par4 - reduction
+
+  return {
+    damageBonusPct,
+    toHitBonusPct,
+    magicConversionPct: 100,
+    zeroDefenseDurationFrames,
+    manaCost: 4,
+    manaCost256: 1024,
+    overlayName: 'berserkfront',
+  }
+}
--- a/tests/skills/bar/adv-bar-combat-stress.test.ts
+++ b/tests/skills/bar/adv-bar-combat-stress.test.ts
@ -0,0 +1,332 @@
+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)
+    })
+  })
+})