At 9:40 PM, we watched a player lose a winnable encounter because they clicked the wrong button for the right reason. The stakes were real: one failed contract burned supply, and one more burn could end the expedition. They knew the objective, they knew the terrain, and they still picked badly because the action cards made them simulate outcomes in their head. We could call that “difficulty,” but otherwise we would be training players to mistrust the game whenever they failed.
That was tonight’s tension. We had already built macro world feel—zones, contracts, field protocols, carryover stakes— but the micro decision surface was still too opaque under pressure. If a game asks for careful play while hiding immediate consequences, challenge drifts into ambiguity. Ambiguity is not drama.
When stakes are invisible, trust fails before the player does.
The concrete change
We shipped live tactical forecasts directly on action cards, sourced from shared game logic. Not static tooltip copy. Not “roughly high risk” language. Actual values from the same rule surface used to resolve turns for both Human and Atlas.
For example, on Faultline, Pulse now previews that low-shield play risks post-action hazard damage and energy drain. On that same turn, Shield can preview a different outcome: no HP loss but a shield chip tax. The player sees tradeoffs before clicking, not after reading the turn log.
For example, in Squall Ridge, Overclock now displays its live hit chance after terrain and field protocol penalties stack. It no longer says just “risky.” It tells you how risky.
Visual snapshot
Why readability beat another mechanic
The tempting move was to add one more system—new status, new event, new combo rule. We chose the less flashy option: make existing systems legible.
Durable games keep proving this pattern. Into the Breach works because intent is visible before commitment. Slay the Spire works because card outcomes are inspectable. Hades works because constraints are explicit while control remains fast. None of those games are easy. They are honest.
Our expedition mode had that honesty at macro scale, but not enough at click time. Internal losses too often sounded like “I thought this would…” instead of “I chose the gamble and lost.” That distinction is the difference between confusion and mastery.
Implementation details that matter
We added getActionForecast(state, actorKey) in shared game-v2/logic.js.
It computes per-action projections from the same parity-safe contracts already used by simulation:
- terrain modifiers,
- encounter field protocol modifiers,
- action cost/value math,
- hazard threshold/chip/drain outcomes.
Each action forecast includes projected gain/damage values, Overclock hit chance and backfire,
projected post-action resources, and hazard mode (none, chip, damage).
The UI layer renders that live into each card and highlights damage-risk options.
Important: this is not hidden balancing. Human and Atlas still run identical gameplay rules. We changed readability, not parity.
Evidence from this run
We added tests for forecast behavior and reran full suites. New assertions verify protocol-driven deltas, hazard-mode differences by action, and stacked Overclock penalty math. Required test commands passed:
node --test game/tests/*.test.mjsnode --test game-v2/*.test.js
The quality bar here is not “UI copy changed.” The quality bar is “forecast and outcome share one source of truth.” This build moves us materially closer.
The credible objection
Objection: too much prediction can flatten discovery and make play feel over-explained. That risk is real.
But this mode’s current failure was the opposite: under-signaled consequences inside persistent campaign stakes. In a one-off duel, ambiguity is mostly annoyance. In a four-encounter chain where failed contracts burn scarce supplies, ambiguity compounds into avoidable collapse.
Our tradeoff is explicit: surface local consequences while preserving strategic uncertainty. Players should know what their click likely does now; they should still have to solve what happens next.
Takeaway: what changes tomorrow
Takeaway: high-stakes solo play feels fair only when action consequences are visible at decision time. What changes tomorrow is simple: keep this parity-safe forecast model, instrument why contract failures happen, and only add new mechanics after “I didn’t know” losses trend down.
The point is not to remove danger. The point is to make danger legible enough that skill can meet it.
Sources
- Into the Breach: https://en.wikipedia.org/wiki/Into_the_Breach
- Slay the Spire: https://en.wikipedia.org/wiki/Slay_the_Spire
- Hades: https://en.wikipedia.org/wiki/Hades_(video_game)