I’ve wanted to make a game for a long time. I’ve also always liked games that leave enough room for you to become curious about them: sandboxes, simulations, games where the interesting part is not necessarily getting to the end, but spending enough time inside the rules that you start finding things the maker probably didn’t place there for you directly.

A little over two years ago, a few things lined up. I was spending a lot of time thinking about simulation, procedural generation and AI, and I had also just started UNMS and wanted to push myself creatively into things I hadn’t made before. Making a game had been sitting somewhere in the back of my head for years, and suddenly it felt like the right project for all of those interests to meet.

That eventually became New Dawn Protocol, a strategy game about rebuilding a planet. You coordinate settlements through a long recovery: what gets built, what gets repaired first, where scarce water, power and freight capacity go, and which of the world’s many problems actually gets a response.

That is roughly what it looks like now. The planet is generated from a seed and then left to become something through simulation: weather moves across it, water collects and runs downhill, settlements produce and depend on one another, people move, infrastructure fails, and other societies make decisions of their own. Underneath what looks fairly quiet from this distance is a world that has become much larger and more interconnected than I expected when I started.

There is a lot I enjoy about making these systems just for their own sake, but I think the thing that has kept me interested for this long is slightly different.

I want to be able to make the game without already knowing it.

There is something strange about building ordinary software in that you generally have to understand the thing before it can exist. You decide where a button goes because you know what it does. You design a flow because you know where someone is trying to get. Even when the implementation surprises you, the intended behavior usually doesn’t.

A sandbox game can have a different relationship with its maker. You can know every rule and still not know the particular thing those rules are going to produce.

That has become one of my favourite things about working on NDP.

Procedural generation seemed like the obvious place to begin. If I don’t place every mountain, settlement or forest myself, then the world can contain things I have never seen before.

And that works, up to a point.

NDP starts by generating the physical planet from a seed. Continents, ocean basins, ridges, climate, drainage, groundwater and initial ecology all come out of the same process. The generator can reject worlds that fall outside some fairly broad constraints, but it is not trying to create a particular authored map.

I still love procedural generation, but after spending a lot of time with it I don’t think novelty alone gets you very far. You can generate a thousand unfamiliar mountains and fairly quickly stop caring which mountain you got. The same problem exists with almost any form of generation. Infinite dialogue is not automatically more interesting dialogue. Infinite characters are not automatically people you care about. Infinite events are still just events.

Surprise itself is very cheap.

What I’ve found much more interesting is being surprised by something and then being able to understand why it happened.

That difference has ended up shaping a lot of NDP. A world generated from a seed gives the simulation somewhere unfamiliar to begin. After that, I mostly want the world to earn what happens to it.

Imagine it rains somewhere

That is not especially interesting on its own. The weather system could change a precipitation value, the renderer could make the ground wet, and we could move on.

But in NDP the rain enters a physical cell. Some of it becomes surface water, some enters the soil, some reaches groundwater and some runs downhill. Settlements depend on those water systems, and if one begins running short it may start consuming packaged reserves. Replacing those reserves creates freight demand somewhere else.

Now the weather has created a logistics problem.

Freight has to use the same routes that carry workers, doctors, engineers, emergency teams, security deployments and trade. Corridors have condition, capacity and travel time. Politics can affect access to them, and disease can follow the actual movement of people across the network.

A distant water failure might therefore dispatch a treatment crew, taking capacity away from industrial freight. Maintenance somewhere else is delayed, output falls and another settlement starts importing workers to compensate. More people are now moving through the region, an outbreak can follow that movement, and a health response that slows the disease may also reduce available labour. If material conditions remain bad for long enough, the problem can eventually become political.

I know the rules involved in that sequence. I designed them. But I don’t necessarily know that sequence is going to happen.

The water failure is not secretly a quest trigger for a political crisis. There is no authored connection between those two events. They are connected because the things in between actually happened.

Knowing the rules without knowing the future

There is a funny tension in building something like this, because making the game less predictable has required making the simulation itself much more exact.

NDP has one authoritative simulation. The interface renders and explains it, but facts like whether a shipment arrived belong to the simulation. I want the rules to be boringly reliable so the outcomes can be interesting.

Randomness is a good example. A typical seeded simulation might draw values from one long random sequence. The result is deterministic as long as the same code asks the same questions in the same order, but that means adding one extra random calculation to disease can accidentally change tomorrow’s weather simply because everything later moved one place down the sequence.

That is technically deterministic, but it is not the kind of causality I want.

So random events in NDP have addresses. Very roughly, an outcome is derived from the seed, the kind of thing asking for randomness, the entity involved and the particular occurrence. A disease roll and a weather roll therefore do not disturb each other simply because one happened to be evaluated first.

I like this partly because it makes debugging possible, but mostly because of what it means for the world. If tomorrow’s weather changes, I want it to be because something about tomorrow’s weather changed, not because I happened to add another question to the program six systems earlier.

You have a lot of authority in NDP, but authority is not the same thing as direct control. You authorize a repair, an expedition or an agreement with another society.

Then it has to actually happen.

A repair still needs crews. Those crews have to travel. Materials have to move through corridors that may already be carrying something else. The grid has to support the work.

If an agreement with another society falls apart, I don’t necessarily want the reason to be that a diplomatic event decided relations should deteriorate. It can happen because the material commitment underneath the agreement became impossible to sustain. Maybe the freight network failed, maybe resources were committed elsewhere, maybe a crisis consumed the capacity you expected to have. The political consequence is real because the promise underneath it was real too.

Leaving it alone

I want the player to arrive in the middle of something already happening, make a few consequential interventions, and then discover what those interventions have become later.

One of my favourite ways to test the game now is to not play it.

I recently let one of the current worlds run unattended for a full simulated year. Disease outbreaks developed, civic cases opened, political relationships shifted, proposals arrived and expired unanswered, infrastructure deteriorated, people moved, inventories changed and the economy kept going.

A huge number of individual events happened during that run, but I don’t find that interesting because the number is large. Most of those events are extremely boring in isolation.

What I like is that the world had a year. The player just wasn’t very helpful during it.

There is a point somewhere in a project like this where the thing starts giving some of the complexity back to you. A settlement I originally thought of mainly in terms of what it produces becomes important because of where it happens to sit in the route network. A minor infrastructure problem becomes difficult because three unrelated systems need the same corridor. An agreement I expected to keep becomes expensive at exactly the wrong time. A political situation develops out of material conditions I wasn’t paying attention to.

None of it is magical, and if I dig far enough I can usually explain exactly why it happened.

But I did not sit down and decide that it should.

There are parts of NDP I know in absurd detail now: how a shipment moves, how groundwater is represented, why one extra disease roll doesn't change next month's weather. And the more exactly I know those parts, the less I know the worlds they produce.

I don't want a game that behaves randomly enough to surprise me. I want one where I can look at something I never expected, follow the consequences backwards, and eventually think: of course.

I get that feeling for free, because I wrote the rules. The real question for the next stretch of this project is whether I can give it to someone who didn't.