TheLadder/test/content.test.js

// Tests for the shipped Corporate Ladder pack.
//
// These are content tests, not engine tests: they assert that the pack is
// playable, that none of it is dead, and that its economy behaves. Engine
// behaviour is covered against the fixture pack instead, so tuning the game
// cannot break the engine suite and vice versa.
//
// One trap, learned the hard way: the chooser's RNG must be seeded
// *differently* from the game's. Both draw one number per turn from the same
// generator, so sharing a seed correlates the choice index with the event
// draw and silently makes whole option combinations unreachable — which looks
// exactly like a content bug.

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { corporateLadder as pack } from '../content/corporateladder/index.js';
import { validatePack } from '../src/engine/validate.js';
import { startGame, currentTurn, takeTurn } from '../src/engine/game.js';
import { createRng } from '../src/engine/rng.js';
import { play, sweep, median } from './fixtures/strategies.js';
import { summarize } from '../src/ui/summary.js';

/** Play `turns` turns with independently-seeded random choices. */
function randomRun(runSeed, turns, visit = () => {}) {
  const rng = createRng(`chooser-${runSeed}`);
  let state = startGame(pack, { seed: `run-${runSeed}` });
  for (let t = 0; t < turns; t++) {
    const turn = currentTurn(pack, state);
    const available = turn.options.filter((o) => o.available);
    assert.ok(available.length > 0, `no available option on event "${turn.event.id}"`);
    const choice = rng.pick(available).option.id;
    visit(turn, state, choice);
    state = takeTurn(pack, state, choice).state;
  }
  return state;
}

test('the pack is valid, with no warnings', () => {
  const result = validatePack(pack);
  assert.deepEqual(result.errors, []);
  assert.deepEqual(result.warnings, []);
});

test('no content is dead: every event fires and every option becomes available', () => {
  // Across archetypes, not just random play: several things in the pack exist
  // for a player pursuing something, and "broke but well-liked" in particular
  // is a state no single-axis strategy ever reaches.
  //
  // Options are checked on *availability*, not on being taken. Whether a
  // particular bot picks an option is an artefact of how the bot scores; what
  // matters is whether a player is ever offered it unlocked.
  const { firedEvents, offeredOptions } = sweep(pack, { seeds: 12, turns: 250 });

  const allEvents = pack.events.map((e) => e.id);
  const allOptions = pack.events.flatMap((e) => e.options.map((o) => `${e.id}.${o.id}`));
  assert.deepEqual(allEvents.filter((e) => !firedEvents.has(e)), [], 'events that can never fire');
  assert.deepEqual(allOptions.filter((o) => !offeredOptions.has(o)), [],
    'options no player can ever be offered');
});

test('how you play changes where you end up', () => {
  // Measured before promotions land, so this is about how a player handles
  // money rather than about how fast they got out of the mailroom. Mixing the
  // two hides the economy behind the career.
  const { byStrategy } = sweep(pack, { seeds: 12, turns: 35 });
  const finalMoney = (name) => median(byStrategy[name].map((s) => s.money));
  assert.ok(byStrategy.thrifty.every((s) => s.stage === 'mailroom'),
    'nobody should be promoted this early');

  // The shape that matters: minding the money climbs, ignoring it sinks, and
  // playing without a plan roughly treads water. Exact figures move with
  // tuning; the ordering is the design.
  assert.ok(finalMoney('thrifty') > finalMoney('random'), 'a careful player should get ahead');
  assert.ok(finalMoney('random') > finalMoney('spendthrift'), 'a careless player should struggle');
});

test('the promotion is worth taking, and reachable by a deliberate player', () => {
  const { byStrategy } = sweep(pack, { seeds: 12, turns: 200 });

  const promoted = Object.values(byStrategy).flat().filter((s) => s.stage === 'dispatch');
  const stayed = Object.values(byStrategy).flat().filter((s) => s.stage === 'mailroom');
  assert.ok(promoted.length > 0 && stayed.length > 0, 'both outcomes should occur');
  assert.ok(median(promoted.map((s) => s.money)) > median(stayed.map((s) => s.money)),
    'the coordinator wage should leave a player better off');

  // A player actually pursuing it should get there mid-run, not at the very
  // end — the mailroom is a career, not a tutorial.
  const timings = [];
  for (let seed = 0; seed < 12; seed++) {
    let at = null;
    play(pack, { strategy: 'sociable', seed, turns: 200,
      visit: ({ state }) => { if (state.stage === 'dispatch' && at === null) at = state.turn; } });
    if (at) timings.push(at);
  }
  assert.equal(timings.length, 12, 'a sociable player should always get the offer');
  const typical = median(timings);
  assert.ok(typical > 40 && typical < 90, `promotion landed at turn ${typical}`);
});

test('hard times is uncommon for a careful player and real for a careless one', () => {
  const countHardTimes = (strategy) => {
    let days = 0;
    play(pack, { strategy, seed: 'ht', turns: 200,
      visit: ({ turn }) => { if (turn.event.id === 'rent_bounced') days++; } });
    return days;
  };
  assert.equal(countHardTimes('thrifty'), 0, 'minding the money should keep you out of trouble');
  assert.ok(countHardTimes('spendthrift') > 0, 'ignoring it should land you in it');
});

test('every turn always offers something to do, however badly the run is going', () => {
  // randomRun asserts this on every turn; 40 long runs is the coverage.
  for (let seed = 100; seed < 140; seed++) randomRun(seed, 150);
});

test('money arrives and leaves on a rhythm the player can plan around', () => {
  const wages = [];
  const rent = [];
  let state = startGame(pack, { seed: 'rhythm' });
  for (let t = 0; t < 30; t++) {
    const turn = currentTurn(pack, state);
    const result = takeTurn(pack, state, turn.options.find((o) => o.available).option.id);
    for (const change of result.record.upkeep) {
      if (change.label === 'Wages') wages.push(state.turn);
      if (change.label === 'Rent') rent.push(state.turn);
    }
    state = result.state;
  }

  assert.deepEqual(wages, [5, 19], 'paid on alternate Fridays');
  assert.deepEqual(rent, [8, 15, 22, 29], 'rent every Monday from the second week');
});

test('the calendar names the day and counts the week', () => {
  let state = startGame(pack, { seed: 'calendar' });
  assert.deepEqual(
    [state.calendar.name, state.calendar.cycle, state.calendar.index],
    ['Monday', 1, 0],
  );
  for (let t = 0; t < 11; t++) {
    const turn = currentTurn(pack, state);
    state = takeTurn(pack, state, turn.options.find((o) => o.available).option.id).state;
  }
  assert.equal(state.turn, 12);
  assert.deepEqual([state.calendar.name, state.calendar.cycle], ['Friday', 2]);
});

test('hard times is survivable without any relationship or skill', () => {
  const event = pack.events.find((e) => e.id === 'rent_bounced');
  const ungated = event.options.filter((o) => !o.requires);
  assert.ok(ungated.length > 0, 'a player with nothing must still have a way out');
});

test('the run recovers from hard times rather than sticking there', () => {
  let sawNegative = false;
  let recovered = false;
  play(pack, { strategy: 'spendthrift', seed: 'recovery', turns: 200,
    visit: ({ state }) => {
      if (state.money < 0) sawNegative = true;
      else if (sawNegative) recovered = true;
    } });
  assert.ok(sawNegative, 'a careless run should go broke');
  assert.ok(recovered, 'and should be able to climb back out');
});

test('debt cannot spiral without limit: lending stops and the charge escalates', () => {
  let peakDebt = 0;
  for (const strategy of ['spendthrift', 'desperate', 'random']) {
    for (let seed = 0; seed < 12; seed++) {
      play(pack, { strategy, seed, turns: 200,
        visit: ({ state }) => { peakDebt = Math.max(peakDebt, state.debt); } });
    }
  }
  // The loan is gated at debt < 2000 and lends 500, so 2500 plus stalled
  // interest is the ceiling. Well above that means the gate has stopped working.
  assert.ok(peakDebt <= 3000, `debt reached ${peakDebt}; the borrowing ceiling is not holding`);

  const charges = pack.upkeep.filter((u) => u.label?.startsWith('Loan service charge'));
  assert.ok(charges.length >= 3, 'the service charge should step up as debt grows');
});

test('a deliberate player can reach relationship-gated content in a reasonable run', () => {
  // The Trevor chain is the deepest gate in the pack. A player cultivating him
  // should get there well inside a normal session, not at turn 100.
  const regard = (o) => (o.option.effects ?? [])
    .filter((e) => e.path === 'relationships.trevor.likes_you')
    .reduce((sum, e) => sum + e.value, 0);

  let state = startGame(pack, { seed: 'befriend-trevor' });
  let reached = null;
  for (let t = 0; t < 60 && reached === null; t++) {
    const turn = currentTurn(pack, state);
    if (turn.event.id === 'trevor_favor') { reached = state.turn; break; }
    const best = turn.options.filter((o) => o.available).sort((a, b) => regard(b) - regard(a))[0];
    state = takeTurn(pack, state, best.option.id).state;
  }
  assert.ok(reached && reached < 45, `Trevor's chain opened at turn ${reached ?? 'never'}`);
});

test('a played run replays identically from its seed', () => {
  const a = randomRun(42, 80);
  const b = randomRun(42, 80);
  assert.deepEqual(a, b);
});

test('the retrospective has something to read back', () => {
  const state = randomRun(3, 60);
  assert.ok(state.notable.length > 0, 'notable moments should accumulate');
  assert.equal(state.history.length, 60, 'every turn is recorded');
  assert.ok(state.history.every((h) => Array.isArray(h.upkeep)), 'upkeep is recorded per turn');
});

test('a long run does not collapse onto a handful of situations', () => {
  // Motivated by a real 183-turn session. Before Dispatch was fleshed out, its
  // two floor events were 46% of every promoted run — one every three turns.
  // This is the guardrail on that: variety is a property of the pack, and it
  // should fail loudly when a stage is too thin for the run it invites.
  for (const strategy of ['sociable', 'thrifty', 'random']) {
    const counts = new Map();
    let turns = 0;
    play(pack, { strategy, seed: 'variety', turns: 200,
      visit: ({ turn }) => {
        counts.set(turn.event.id, (counts.get(turn.event.id) ?? 0) + 1);
        turns++;
      } });

    const [topEvent, topCount] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
    const share = topCount / turns;
    assert.ok(share < 0.25,
      `${strategy}: "${topEvent}" was ${(share * 100).toFixed(0)}% of turns`);

    // Measured against what was actually reachable: a run that never leaves
    // the mailroom cannot see Dispatch, and counting that as thin content
    // would be measuring career progress rather than variety.
    const visited = new Set([...counts.keys()]
      .map((id) => pack.events.find((e) => e.id === id).stage)
      .filter(Boolean));
    const reachable = pack.events
      .filter((e) => e.stage === undefined || visited.has(e.stage)).length;
    assert.ok(counts.size / reachable > 0.6,
      `${strategy}: saw ${counts.size} of ${reachable} reachable situations in ${turns} turns`);
  }
});

test('the retrospective reports how repetitive the run was', () => {
  const state = play(pack, { strategy: 'sociable', seed: 'repeats', turns: 120 });
  const summary = summarize(pack, state);

  assert.equal(summary.turns, 120);
  assert.ok(summary.eventsSeen > 0 && summary.eventsSeen <= summary.eventsTotal);
  assert.ok(summary.averageTimesSeen > 1, 'a long run repeats situations');
  assert.equal(
    summary.averageTimesSeen.toFixed(2),
    (summary.turns / summary.eventsSeen).toFixed(2),
    'the average is turns over distinct situations',
  );
  assert.ok(summary.mostSeen.count >= summary.averageTimesSeen);
  assert.ok(summary.repeatedSituations <= summary.eventsSeen);
  assert.deepEqual(summary.stagesVisited, ['mailroom', 'dispatch'],
    'the retrospective knows the career moved');
});