Skip to main content

Overview

Headline items in 2025:

  • Selected multiplayer framework (Mirror)
  • Multiplayer lobby system
  • Multiplayer entity management (spawning/destruction)
  • Orbital data sync over the network
  • Multiplayer time control
  • UI development (building core UI code)
  • Physics sim for thermals
  • Tactical view
  • Core systems simulating sensors
  • AESA RADAR sensor, using this system
  • Bullet simulation (capable of simulating tens of thousands of bullets)
  • Bullet rendering
  • Core systems for collision detection (Octree, Sweep & Prune)
  • Multiplayer sync for bullets
  • Deep research on armour damage models
  • Built armour designer minigame (IMPACT). More on this below.
  • Clicking on orbits
  • Core systems for HUD
  • Engine burn gizmo (like the KSP manoeuvre node gizmo)
  • Creating engine burns using gizmo

Successes

Overall I've been very happy with the pace of the project. I've largely kept to working on something completely new each month with a hard cut-off at the end of the month. This really helps with pacing (there's a deadline), prioritisation (I can't get side-tracked with building the perfect solution when there's a deadline) and general motivation (I switch to something new and interesting every few weeks).

It really feels like the overall project has changed in nature. Previously I've been working on a space-game engine - building all the bits of core technology needed for a space game (solar system scale rendering, integration, line rendering etc). Throughout 2025 that has slowly shifted more towards building gameplay oriented thins on top of those systems. Now I'm building a game!

It wasn't part of the plan, but the IMPACT minigame was a nice bonus for this year. I'm considering spending some more time on that in 2026 to really give it some polish, and releasing it as a free game on Steam. That would give me some practice with that process before the real thing!

Failures

I've failed to achieve a few goals I set myself. I deliberately set goals that are a stretch, so failing a few is expected! Despite this, it did hurt my motivation a bit when I missed some goals, that's counter-productive (goals are for motivation) so I need to be more aware of this next year.

In March I worked on the TreeView GUI element, with the goal of this being a core part of the HUD. That was a lot more work than expected, and I'm not even sure if I'll use it in the final HUD! I did learn a lot about implementing UIs in Unity though.

From June onwards my long term goal was for a "jousting" fight by the end of the year - i.e. two ships, in multiplayer, spawned on a (near) collision course which shoot at each other. If you look at the work from mid-year onwards you can see this in what I worked on: sensors (so they can see each other), bullets (so they can shoot each other), multiplayer bullets, damage model (so bullets can do something), tactical view (so you can see what's going on). I didn't achieve this primarily because October was an awful month where I got nothing done (computer exploded, COVID recovery, Jury service). Without that time, I wasn't going to be able to achieve it by the end of the year so I worked on other things.

What's next?

My next major milestone is for an alpha release of basic multiplayer combat in the first half of 2026.

Month Summary

Summarised key points from the dev-notes each month:

January​

  • Tested several multiplayer frameworks and chose Mirror networking.
  • Built a complete lobby flow (connecting to a game, doing initial setup, loading scene etc)
  • Added automatic backpressure to slow down the sim if a client begins to fall behind.
  • Lots of optimisations to orbital integration and orbit line rendering.

Overall this month went really well! I expected multiplayer to take longer, but once I'd selected Mirror everything was pretty fast.

February​

  • Spent a lot of time working on a TreeView GUI, for showing hierarchical data.
  • Worked out general pattern for binding UI to ECS state
  • Built out the core camera system with a split between near view (looking at a spaceship size thing) and astronomical view (looking at a planet size thing).

I spent a lot more time working on the tree view than I really wanted, but this was still worthwhile to figure out the pattern I'm now using for all UI.

March​

  • Researching spacecraft thermals, scoping out some of the spacecraft design aspect of the game
  • Built out an algorithm for simulating heat in a simplified way that can be run at extremely high time speeds.

This was the start of the HotStuff library which has become a core part of the project, everything in the game that uses physical units (metres, joules, watts etc) is based on this foundation.

April​

  • Return to multiplayer, working on some of the in-game stuff instead of in-lobby (e.g. spawning spaceships).
  • Time control algorithm - syncing the simulation time speed across the network and minimising desync even at extreme time speeds.
  • Custom compression of orbital data, down to roughly 34% of the original size. Released as open source serialization library.

These were both major issues that cropped up when I was working on multiplayer in January. They both could have been showstoppers if I couldn't find a way to solve them. Good to sort them both out in the same month!

May​

  • Prototyping of the "tactical view", which shows the environment around a ship
  • Experimenting with ideas for sensors - how realistic should they be? Started out with something way too in depth (Kalman filters, particle filters, injecting noise etc) and ended up replacing it with something that approximates the same results.

I haven't followed up on the tactical view stuff yet, but I did learn a lot about UI design while working this. I'll definitely be coming back to follow up on this in 2026!

June​

  • Started on a long term goal for a "joust" by the end of the year - two ships which spawn on a near collision course and can shoot at each other. Getting this working would require most of the core systems of the game except for manoeuvring.
  • Built an octree system that can be used for general spatial queries (like sensors)
  • Worked on the sensor systems for the game:
    - Foundational systems for representing general sensor stuff in the ECS (sensors, target, tracks etc)
    - Implemented one sensor type on top of this (AESA RADAR)
    A lot of this work was done in the HotStuff library I mentioned before, adding lots more physics sim stuff to handle sensor related physics. I haven't come back and used these sensors for anything yet, they'll probably pop up again in 2026 when I look at tactical view stuff.

July​

  • Building systems for guns and bullets. Using a system of "chains" that can handle many bullets with a small amount of simulation work (e.g. 128 bullets for one single simulated point).
  • Rendering bullets using GPU compute and instanced rendering. Learned a lot about this stuff, and it's a technique I've used a lot since.
  • Collision detection for bullets, using the same octree system I set up for sensors. I was pretty happy with the results, it's a novel system for simulating large number of bullets and it works pretty well. It actually scales better for faster firing guns!

August​

  • Syncing bullets in multiplayer. Tried a few techniques for this but they all took too much traffic, sidestepped the whole issue by just sending triggering events (start/stop firing).
  • Ended up spending most of this month rebuilding the collision system to use Sweep & Prune instead of an octree, since the octree was way too slow. Working on bullets more and rebuilding the octree stuff that I had just worked on a couple of months ago really got me down. Normally I deliberately work on new stuff every month, rather than carrying on with the same task forever, this really highlighted that I need to do that!

September​

  • Researching an armour damage model, modelling how layered armour absorbs impacts. This involved reading a lot of papers on hypervelocity impacts from NASA and trying to work out what the interesting behaviour is that I want to simulate in the game.
  • Built out three prototype damage models.
  • Started on IMPACT minigame (layered armour test app) I was on holiday this month, so I did a lot of research while away from home and carried that over into the prototypes when I got back.

October​

  • Released IMPACT minigame for people to try out the damage model
  • Computer exploded
  • COVID
  • Jury service
  • COVID recovery Yeah this month sucked

November​

  • Aimed to get orbital picking working (i.e. clicking on an orbit line), and to schedule engine burns at that point
  • Raycasting against orbit line
  • Various systems to better handle mouse input and UI events
  • Added concept of Selected and Focused entities, which will be used for all future UI stuff
  • Developed a 3D gizmo for creating engine burns The actual picking system has existed within the core engine for ages, this was about taking that system and driving it from the UI frontend. A lot of work in 2026 will look like this, taking things I've already laid the foundations for an using them for real.

December​

  • Aiming to take the inputs from the 3D gizmo, and turn them into actual engine burns.
  • Lots of small tweaks to engine burn scheduling and orbital integration, to make this work better.
  • There was some discussion in the Discord about nav computers (calculating engine burns automatically). Experimented with Particle Swarm Optimisation for this purpose. Bit of a lazy month, finishing off the work from November and tying up some other loose ends.