This post is 80% AI written
I started writing GALSOV’s “Paper Rules” thinking I was doing documentation.
Turns out I was building a design engine: a way to make decisions, spot contradictions, protect scope, and keep the game deterministic enough that future-me can debug the universe without going feral.
TL;DR: the big evolution between the earlier merged drafts (v0.1C/D/F) and v0.1H isn’t “more rules”. It’s more structure, more determinism, and better protection of what v0.1 is (and is not).
The early era (v0.1C/D/F): one big document, many big dreams
The earlier merged versions read like a galaxy being sketched into existence. You can feel the ambition: movement, logistics, sensors, combat, colonies, research… all trying to coexist while I figure out what the “spine” of the game actually is.
This phase is valuable because it captures the raw design intent. It also contains the classic trap: when everything is possible, it’s easy to accidentally design a game that takes five years before you can even play Turn 1.
The big inflection: time inside the turn (Micro-Steps)
The most important leap in v0.1H is the introduction of micro-steps: the resolution phase isn’t one big blob anymore. It becomes a repeatable loop where movement, sensors, and engagements happen in small slices.
This matters because it answers a nasty design question:
How do you keep a turn-based game strategic and deterministic… while still allowing “things to unfold” like detection, interception, and combat timing?
Micro-steps are the “honest clock” inside the turn. And once that clock exists, other systems can anchor to it cleanly.
Combat becomes especially interesting here: instead of being a detached “end of turn fight”, it’s treated as something that consumes operational time. That immediately creates tactical trade-offs: time spent fighting is time not spent moving, scanning, or repositioning.
Scope discipline gets real: the “Parking Lot” becomes a firewall
v0.1H also shows a shift I didn’t fully appreciate until I saw it written down: scope control becomes a rule.
Not just “I’ll do that later”… but a formal place to put big, tempting ideas so they don’t infect the MVP. That’s huge. Hobby projects usually die from feature creep, not from lack of imagination.
Having a Parking Lot turns “cool future systems” into something safe: acknowledged, recorded, but explicitly not part of v0.1’s definition of done.
The docs evolve from “a document” into “a tool”
v0.1H doesn’t just add content — it becomes more usable. The rules get split into modules so I can review and iterate without scrolling through a single mega-text every time.
This sounds boring, (TimboSlice: “It is boring”) but it’s a genuine milestone: it’s the point where “paper rules” stop being a diary and start being a reference system. (TimboSlice: “All true, it’s still been boring… slow… so very very slow!”)
Rule archaeology: contradictions aren’t failure — they’re proof the process works
One of the funniest (and most useful) things about versioned rules is that you get design archaeology: old assumptions fossilize in the text, sitting next to newer models.
Example: jump travel time. At one point it reads like a fixed “1 jump = 1 turn” concept. Later it shifts toward speed-based travel where longer jumps can take multiple turns.
That’s not a disaster — that’s exactly what the paper rules are supposed to do: surface contradictions before they become bugs in code, saves, or UI.
If the universe disagrees with the rules, the universe is wrong. (Or I am. But at least I’ll know exactly where.)
Fun facts pulled from the rules drafts
- “Sun magic” is canon: the universe is only partially understood, and there’s a deliberate baseline risk floor. Space should stay a little scary.
- “Lost-in-jump” is deliciously grim: mechanically treated as destroyed, but the event log should describe the nightmare. (That’s pure sci-fi horror fuel.)
- The “busy turn dossier” vibe is intentional: the game’s feel is meant to be strategic, logged, and inspectable — like you’re reading an after-action report, not just watching numbers change.
TimboSlice: “What this means for gameplay (and for the experiment)”
From a gameplay perspective, the evolution is clear:
- Movement becomes more honest once time-in-turn exists.
- Detection and engagement have a clean place to live (micro-steps), rather than being hand-waved.
- Combat becomes a tactical time cost, not just a phase.
- Scope gets protected so v0.1 can actually ship as a playable core loop.
- The docs become modular, meaning iteration gets faster and contradictions get easier to spot.
And from an “AI-assisted dev experiment” perspective? These versions show something I didn’t expect: the rules aren’t just recording design decisions — they’re recording how decisions get made, challenged, rewritten, and stabilized into something code-ready.
This is what I’m aiming for: a deterministic rules backbone that I (or more honestly… ChatGPT) can translate into code, tests, and a turn log. Same seed + same decisions should yield the same outcome — which means when something breaks, it breaks loudly and traceably.
Next step
The next move is straightforward and brutal: implement the micro-step loop, movement timing, and combat passes in code — then use the turn log as the truth oracle.
Because once the game exists, the rules stop being “ideas”… and start being contracts.
“`0