Space RTS

What it is

A real-time 3D tactical prototype — think Total War in space, closer to a sequence of tactical battles than a grand-strategy game, with ship handling inspired by EVE Online. The wider design (codenamed Codex of Doomed) imagined fleets, factions, and procedurally generated missions; what I actually built is the combat core underneath that — the simulation and the game-feel.

It’s an unfinished prototype, and I’d rather be precise about that than oversell it: there’s no UI, no missions, and no enemy AI, and I stopped before collision and avoidance. What exists is the hard part — a real-time battle sandbox that runs dozens of ships at once.

What I built

Data-driven ships. Hulls are defined through a JSON + Excel pipeline: how many weapon ports of each type a ship has, its stats, and how derived values (speed, turn rate, acceleration) fall out of mass and engine power. Guns are instantiated onto the right ports straight from that config, so a new ship is a data change, not a code change.

Command & tactics. Real orders, issued to many ships at once and shown on-screen: move, attack, orbit, and hold-distance, plus focus-fire. Ships auto-orient to bring the most guns to bear — turning to present a broadside so the largest number of weapons can fire. You can also possess a ship and take direct control of it.

Combat feel. Each gun aims independently with lead and accuracy; firing has recoil, muzzle and impact VFX, and weapon audio that changes with distance. Ships bank in reaction to where a hit lands, then break apart when destroyed. Selection is handled through banners above each ship.

Architecture & performance. The battle runs on a deterministic, FPS- independent tick loop — the logic never touches frame delta, so the simulation is reproducible (and, by design, ready for lockstep P2P later). Update work is split across schedulers running at different frequencies with phase offsets, so the cost of hundreds of guns and projectiles is spread across ticks rather than spiking on one frame.

Deterministic tick loop — 100 Hz, FPS-independent

  TickManager ──▶ each tick (10 ms), fixed order:
     1. Movement      ~5–10 Hz    position, accel, predicted position
     2. Targeting     ~1–2 Hz     pick targets, aim guns (lead + accuracy)
     3. Fire          throttled   fire, capped 10–30 shots / tick
     4. Projectiles   every tick  move, hit-test, TTL, apply damage

  Schedulers stagger via frequency + phase offset to spread CPU load.
  Pooled projectiles & VFX · effect and sound LOD by camera distance.

On top of that: object pooling for projectiles and effects, LOD that simplifies or drops VFX and sound by camera distance, and a few rounds of profiling to keep large fights smooth. The same architecture was designed to extend cleanly to collisions, enemy AI, and intensity-driven dynamic music — hooks are there, but those parts weren’t built.

Where it landed

At the point I stopped, you could command several dozen ships, give them move, attack, orbit, and hold-distance orders, and watch them maneuver to fire optimal broadsides, take localized hit reactions, and get destroyed — with pooled effects, distance-based audio, and LOD holding the frame rate together.

Why it’s here

It’s the clearest example of the engineering I enjoy: a performance-minded simulation architecture, a data-driven pipeline that hands control to design, and combat game-feel — recoil, reactions, sound, destruction — built to sell the fantasy.