Designing a Remake with the Original Game as the Spec

Greetings, Commanders.

Picture this: you're watching a dozen cheap missiles shoal toward an enemy colony, knowing most of them exist purely to eat anti-missile fire so the warheads behind them get through. It feels like an exploit. It feels like something the original designers never intended. It is also, provably, exactly how Fragile Allegiance has always worked — and why the strategy still has a cult following three decades later.

Moments like that are the whole reason this remake gets designed the way it does. Because when people ask how I'm rebuilding Fragile Allegiance, the honest answer is: I don't have the source code. What I have is better — a decompilation project that dissects the 1996 DOS original instruction by instruction and publishes what it finds as functional documentation. The decomp is my game design document.

The Original Is the Spec

That changes the entire design process. Instead of asking "what would be fun?", the first question is always "what does the original actually do?" — and then, separately, "should I keep it?"

Every system in the remake gets traced back to that question. The two streams of randomness that generate the universe. How asteroids are born. The ten ores and their distribution across the field. How mines extract them. When the decomp proved the original's RNG behaves a certain way, I reproduced it — not approximately, but the same behavior, so the belt you survey in the remake is statistically the belt K240 veterans remember flying.

The Faithfulness Policy

The rule I settled on: mechanics are faithful, presentation is mine.

Faithful: the simulation layer. The universe generation, the ore economy, the life-support math, the missile logic. These are the game's physics, and they get ported with the care of a historical restoration.

Mine: the interface. The original is a 640×480 DOS screen; porting it literally would be archaeology, not game design. So I redesigned it in the original's spirit — a fictional in-universe OS ("FMC OS"), 90s terminal chrome, Orbitron and Rajdhani typefaces, gold on black. The fiction of the original, re-rendered for a modern screen.

Where the two collide, I err toward the original. The game's weirdness is a feature, not a bug to be sanded off: missile-first strategies, sabotage agents, shoaling cheap missiles to soak up anti-missile fire, traders worth befriending for specific items. That emergent depth is why this game still has a cult following in 2026, and I refuse to flatten it. Sand off the edges and you get a generic 4X wearing Fragile Allegiance's nameplate.

Decisions That Shaped the Code

Three implementation choices came directly out of this philosophy:

  • Custom game clock. The original ticked the whole world on its own rhythm. Unity's Update() isn't a game loop, so I built a custom one — per-frame Tick(), per-second TickPerSecond(), spread across frames with a time budget so a busy belt doesn't hitch. The game runs on game time, not frame time, just like 1996 did.
  • ScriptableObject state machine. Player flow — colony view, asteroid field, build, launch — is a data-driven FSM. Adding a screen means adding a state asset, not rewriting a controller.
  • HTN planner for the AI. The rival corporations plan like they mean it: colonize, attack, defend, patrol. Their decisions get made one game-second at a time, from the same information you have. No omniscient rivals — the original never cheated, and neither do we.

Lessons from the Decomp

Three things the last months of digging taught me:

  1. The original lied to you about your economy. Air, food, water, power — the original's life-support math had quirks the manual never mentioned. The decomp caught them. Whether I reproduce the quirks is always a design call: some are balance, some are bugs. I kept the ones that make the game Fragile Allegiance.
  2. Reverse-engineering is slow, honest work. Every claim in my design docs carries a status — confirmed, hypothesis, or ?. When new analysis overturns an old conclusion, the docs get corrected the same day. Designing on top of half-truths is how remakes drift into fan fiction.
  3. Playability is allowed to be better than 1996. Range-select in the sidebar, hover fixes, a tutorial — these aren't betrayals. They're what original players wished they had.

What's Next

With the fidelity layer settled, the next transmissions get back to the systems you'll actually command. Expect deep dives into the economy the decomp uncovered — and how the roadmap priorities shake out against what the original really did under the hood.

Signing out,

  • Jari