Emberfall/tests/combat.test.js

// Tests for src/game/combat.js — pure combat resolution.
const { describe, it } = require('node:test');
const assert = require('node:assert/strict');
const { resolveCombat } = require('../src/game/combat');
const { mulberry32 } = require('../src/utils/rng');

describe('resolveCombat', () => {
  const heroBase = {
    class: 'warrior', level: 1, hpCurrent: 70, maxHp: 70,
    str: 8, agi: 4, int: 2, vit: 8,
    bonus_attack: 0, bonus_defense: 0, bonus_vit: 0,
  };

  const rat = { name: 'Giant Rat', level: 1, hp: 20, attack: 6, defense: 1, speed: 12 };
  const wolf = { name: 'Meadow Wolf', level: 2, hp: 32, attack: 9, defense: 3, speed: 16 };
  const goblin = { name: 'Goblin Scrapper', level: 3, hp: 45, attack: 12, defense: 5, speed: 11 };
  const drake = { name: 'Ashfang Drake', level: 14, hp: 300, attack: 50, defense: 30, speed: 18 };

  it('hero wins against equal-level monster', () => {
    const rng = mulberry32(42);
    const result = resolveCombat({ ...heroBase }, rat, rng);
    assert.strictEqual(result.winner, 'hero');
    assert.ok(result.rounds.length > 0);
    assert.ok(result.hpRemaining > 0);
  });

  it('monster wins against much higher-level monster', () => {
    const rng = mulberry32(99);
    const result = resolveCombat({ ...heroBase }, drake, rng);
    assert.strictEqual(result.winner, 'monster');
    assert.ok(result.rounds.length > 0);
    assert.ok(result.hpRemaining > 0);
  });

  it('returns round-by-round log', () => {
    const rng = mulberry32(42);
    const result = resolveCombat({ ...heroBase }, rat, rng);
    for (const round of result.rounds) {
      assert.ok('round' in round);
      assert.ok('actor' in round);
      assert.ok('damage' in round);
      assert.ok('targetHpAfter' in round);
      assert.ok(round.damage >= 1);
    }
  });

  it('hero acts first when speed is equal or higher', () => {
    // Hero warrior speed = 10 + 4 = 14. Rat speed = 12. Hero acts first.
    const rng = mulberry32(1);
    const result = resolveCombat({ ...heroBase }, rat, rng);
    assert.strictEqual(result.rounds[0].actor, 'hero');
  });

  it('monster acts first when monster speed is higher', () => {
    // Wolf speed = 16. Hero warrior speed = 14. Monster acts first.
    const rng = mulberry32(1);
    const result = resolveCombat({ ...heroBase }, wolf, rng);
    assert.strictEqual(result.rounds[0].actor, 'monster');
  });

  it('deterministic with same seed', () => {
    const rng1 = mulberry32(123);
    const result1 = resolveCombat({ ...heroBase }, goblin, rng1);
    const rng2 = mulberry32(123);
    const result2 = resolveCombat({ ...heroBase }, goblin, rng2);
    assert.deepStrictEqual(result1.winner, result2.winner);
    assert.deepStrictEqual(result1.rounds.length, result2.rounds.length);
    assert.deepStrictEqual(result1.hpRemaining, result2.hpRemaining);
  });

  it('caps at 20 rounds — higher HP% wins', () => {
    // Create a scenario where both are nearly dead after many rounds
    // Use a seed that produces low damage rolls
    const rng = mulberry32(7777);
    const weakHero = { ...heroBase, hpCurrent: 10, maxHp: 70, str: 2, agi: 2, vit: 2 };
    const weakMonster = { ...rat, hp: 10, attack: 1, defense: 0, speed: 5 };
    const result = resolveCombat(weakHero, weakMonster, rng);
    assert.ok(result.winner === 'hero' || result.winner === 'monster');
    assert.ok(result.rounds.length <= 20);
  });

  it('mage gets bonus vs high-defense monster', () => {
    const mageHero = {
      class: 'mage', level: 5, hpCurrent: 55, maxHp: 55,
      str: 2, agi: 4, int: 9, vit: 5,
      bonus_attack: 0, bonus_defense: 0, bonus_vit: 0,
    };
    // Stone Golem has defense 40
    const golem = { name: 'Stone Golem', level: 12, hp: 260, attack: 38, defense: 40, speed: 6 };
    const rng = mulberry32(55);
    const result = resolveCombat(mageHero, golem, rng);
    // Just verify it runs without error and returns valid structure
    assert.ok(result.winner === 'hero' || result.winner === 'monster');
    assert.ok(result.rounds.length > 0);
  });

  it('crit hits deal multiplied damage', () => {
    // Force a crit by using a seed that produces rng() * 100 < critChance on first roll
    // Warrior critChance = min(40, 5 + floor(4*0.5)) = 7%
    // We can't easily force a crit, but verify crit field exists in log
    const rng = mulberry32(42);
    const result = resolveCombat({ ...heroBase }, rat, rng);
    const critRounds = result.rounds.filter(r => r.crit);
    // Crit may or may not occur, but if it does, damage should be higher
    for (const cr of critRounds) {
      assert.strictEqual(cr.crit, true);
    }
  });

  it('monster crit field is present', () => {
    const rng = mulberry32(1);
    const result = resolveCombat({ ...heroBase }, wolf, rng);
    const monsterRounds = result.rounds.filter(r => r.actor === 'monster');
    for (const mr of monsterRounds) {
      assert.ok('crit' in mr);
    }
  });
});