JesseMarkowitzandClaude Opus 5
e482f07157
The MVP is playable: a turn screen, a career retrospective, an optional feedback widget, local-storage autosave with file export/import, and a build that flattens everything into one self-contained HTML file. A turn has two phases — the scenario and its options, then what the choice did and, separately, what the day cost regardless. Numbers that move without the player seeing why are most of what makes them meaningless. Locked options are shown greyed with the requirement spelled out rather than hidden, so a player can see the door they cannot open yet. The interface is named entirely by the pack. `pack.display` maps a state path to a label, a format and an order, which is why the header reads "Standing" for a path called `reputation` and why debt disappears while it is zero. The first playtest then found three things, all of them fair. *"Wasn't clear what daily drain was for."* The ledger was labelling changes by the path that moved — "Money −$18" — when the upkeep entry that caused them had a perfectly good name. It now says "Coffee, transit, lunch". The labels were in the data the whole time and never reached the screen. *"Should probably pay rent weekly / get paid every other week… would be good to have day of week and week # shown."* Packs can now declare a calendar, and the engine derives the day name, cycle and index from the turn number before the event is drawn — so content can require a Friday and the header can say "Thursday · Week 2 · Day 12". Upkeep entries take `every` and `offset`, making wages fall on alternate Fridays and rent every Monday. The turn screen carries a diary line — "Wages tomorrow · Rent in 4 days" — computed generically from whatever a pack schedules. *"Always in debt — could never get ahead."* The old economy bled $25 a day regardless of play. It is now roughly break-even at baseline, with a `spare_shift` event that appears *because* you are broke: the way out of a hole should be visible from inside it. Across archetypes a careful player ends around $1,400, an unplanned one treads water, and a careless one sinks into real debt. That retune broke the coverage test, usefully. Random play stopped reaching hard times at all, which made the entire debt branch look dead — it was not, since random play is not a plausible player. Coverage is now the union across five archetypes, including one that is broke *and* well-liked, because the "ask a friend for money" options sit in a state no single-axis strategy reaches. Not covered by any of this: styling and dark mode, which only a human with a browser can check. This machine has none that can render a page. 109 tests. Reasoning in docs/DECISIONS.md §14-21. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VMSFHyVPitUoosW5wyEADj
88 lines
3.3 KiB
JavaScript
88 lines
3.3 KiB
JavaScript
// Player archetypes for content probing.
|
|
//
|
|
// "Is this content reachable?" is not the same question as "does random play
|
|
// reach it?" — a random player is not a plausible player, and several things
|
|
// in a pack exist precisely for a player pursuing something. Coverage is
|
|
// therefore the union across archetypes, and each one is a rough caricature of
|
|
// a way somebody actually plays.
|
|
//
|
|
// NOTE: seed the chooser differently from the game. Both draw one number per
|
|
// turn from the same generator, so a shared seed correlates the choice with
|
|
// the event draw and silently makes combinations unreachable.
|
|
|
|
import { startGame, currentTurn, takeTurn } from '../../src/engine/game.js';
|
|
import { createRng } from '../../src/engine/rng.js';
|
|
|
|
const moneyGain = (resolved) => (resolved.option.effects ?? [])
|
|
.filter((e) => e.path === 'money' && e.op === 'add')
|
|
.reduce((sum, e) => sum + e.value, 0);
|
|
|
|
const relationshipGain = (resolved) => (resolved.option.effects ?? [])
|
|
.filter((e) => e.path.startsWith('relationships.'))
|
|
.reduce((sum, e) => sum + e.value, 0);
|
|
|
|
const best = (options, score) => [...options].sort((a, b) => score(b) - score(a))[0];
|
|
|
|
export const strategies = {
|
|
/** No plan at all. */
|
|
random: (options, rng) => rng.pick(options),
|
|
/** Takes the money every time. */
|
|
thrifty: (options) => best(options, moneyGain),
|
|
/** Spends it every time. */
|
|
spendthrift: (options) => best(options, (o) => -moneyGain(o)),
|
|
/** Chases standing with people. */
|
|
sociable: (options) => best(options, relationshipGain),
|
|
/**
|
|
* Broke but well-liked — the state the "ask a friend for money" options were
|
|
* written for, and one no single-axis strategy ever reaches.
|
|
*/
|
|
desperate: (options, rng) => (rng.next() < 0.25
|
|
? rng.pick(options)
|
|
: best(options, (o) => relationshipGain(o) - moneyGain(o) / 40)),
|
|
};
|
|
|
|
/** Play one run to `turns`, calling `visit` before each choice. */
|
|
export function play(pack, { strategy = 'random', seed = 'run', turns = 200, visit } = {}) {
|
|
const choose = strategies[strategy];
|
|
const rng = createRng(`chooser-${strategy}-${seed}`);
|
|
let state = startGame(pack, { seed: `game-${strategy}-${seed}` });
|
|
|
|
for (let t = 0; t < turns; t++) {
|
|
const turn = currentTurn(pack, state);
|
|
const available = turn.options.filter((o) => o.available);
|
|
if (available.length === 0) throw new Error(`no available option on "${turn.event.id}"`);
|
|
const chosen = choose(available, rng);
|
|
visit?.({ turn, state, chosen });
|
|
state = takeTurn(pack, state, chosen.option.id).state;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
/** Play every archetype across several seeds, reporting what was reached. */
|
|
export function sweep(pack, { seeds = 12, turns = 200 } = {}) {
|
|
const firedEvents = new Set();
|
|
const takenOptions = new Set();
|
|
const byStrategy = {};
|
|
|
|
for (const strategy of Object.keys(strategies)) {
|
|
const finals = [];
|
|
for (let seed = 0; seed < seeds; seed++) {
|
|
const state = play(pack, {
|
|
strategy,
|
|
seed,
|
|
turns,
|
|
visit: ({ turn, chosen }) => {
|
|
firedEvents.add(turn.event.id);
|
|
takenOptions.add(`${turn.event.id}.${chosen.option.id}`);
|
|
},
|
|
});
|
|
finals.push(state);
|
|
}
|
|
byStrategy[strategy] = finals;
|
|
}
|
|
return { firedEvents, takenOptions, byStrategy };
|
|
}
|
|
|
|
export const median = (values) =>
|
|
[...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
|