Building a Zombie RTS Where You Don't Get to Give Orders

I've been building a top-down zombie-apocalypse RTS in Godot 4 with C#, and I wanted to write up where the project actually stands, a few months in. Not a pitch deck — a progress report, warts and all, with some of the more interesting engineering problems along the way.

The pitch

Most RTS games let you click a unit and tell it exactly what to do. This one mostly doesn't.

You're managing a small settlement of survivors in a zombie apocalypse, but you can't directly command them. Each survivor acts on their own, based on their class, personality traits, and current morale. Instead of giving orders, you post flags — "clear this area," "scavenge that building" — each with a resource bounty attached, and survivors decide for themselves whether a job is worth doing. A Scavenger with the Reckless trait might take on a run through zombie territory that a Cowardly Guard would rather sit out. It's closer to managing a small, opinionated crew than commanding an army — the inspiration is Majesty, if anyone remembers that one.

Losing a survivor is permanent, they have real names, and the zombie threat only ever escalates — so the tension isn't "can I win the fight in front of me," it's "am I making a settlement that can survive next week."

What's actually playable right now

The honest core loop works end to end: your starting party of three survivors spawns into a fogged-over map, scavenges for supplies, gets jumped by wandering zombies, and either builds up a real base or slowly falls apart. Concretely, that means:

A settlement you place yourself. Drop a Settlement Center, and it defines a territory circle that accepts delivered resources and gates which buildings actually give you their bonuses.
Real construction, not a menu click. Building a Shelter or Workshop isn't instant — it takes actual survivor labor. You designate a Construction flag, a survivor walks over and works the job (Builders work it twice as fast), and progress persists if they get interrupted partway through.
A resource economy with teeth. Five resource types drain daily. Let Food run out and morale doesn't just dip — it craters, and a survivor whose morale hits zero deserts your roster entirely. They don't vanish, though — they keep wandering the map as an independent loner, which has led to some strange and slightly haunting moments watching a former teammate scavenge against you, indifferent, nearby.
Zombies with actual behavior, not just a health bar with legs — they wander in groups, converge on combat noise, and merge into bigger hordes when they run into each other. A Watchtower facility can spot a horde forming before it reaches you.
Real loot, not fabricated resources. Buildings have doors (that can be locked or bashed in), and searchable furniture inside them — a Medicine Cabinet, an Office Desk — rolls loot weighted by your current shortages and the searching survivor's class and traits.
Combat that cares about noise and stealth. Movement stance (walking vs. running vs. crouching) changes how far zombies can hear you, and a crouched survivor with a silent melee weapon can land a one-hit stealth kill on an unaware target.

None of this is a tech demo dressed up as a game — it's a genuinely playable, if unpolished, slice of the eventual game.

The feature I like the most: death isn't really the end

A few weeks ago I added something that turned out more evocative than I expected: when a survivor dies, they don't just disappear. They reanimate on the spot as a zombie — visually tinted a sickly olive-grey so you can tell at a glance it used to be one of yours — still carrying their name label and everything they had equipped when they died.

Kill that zombie a second time, and it drops a lootable corpse holding everything the original survivor was carrying: their weapon, their gear, whatever resources they'd scavenged. So there's a real, visible cost to letting a survivor die in the field beyond a stat going down — you might watch a friend turn, and then have to decide whether it's worth fighting your way back to loot their own weapon off their corpse.

(A small technical aside, for anyone who likes this kind of thing: making the corpse lootable the same way an in-building search object is meant reusing the exact same "search this thing" flow for two objects that don't share a base class. Rather than force a shared parent class onto them, I pulled out a small ISearchTarget interface — both a SearchableObject and a SurvivorCorpse implement it, and the AI code that resolves a search doesn't need to know or care which one it's looking at.)

The unglamorous work: getting survivors to stop walking into walls

Here's the part of the story that's less exciting to describe but was genuinely the most time-consuming: getting pathfinding to actually work.

Early on, survivors would navigate toward a target and just... stop, standing at a wall corner, forever — because the game only checked "have I arrived," never "am I actually still making progress." A survivor chasing a zombie that wandered behind a building would get physically stuck at the corner and stand there until the zombie wandered back into range, which might be never. A survivor sent to loot a random patch of ground near a building would sometimes get routed straight into the wall closest to that spot and just camp there.

Each of these got fixed individually the first few times they showed up, until it became obvious they were all the same bug wearing different clothes: nine different AI states all shared the identical shape of "walk somewhere, wait to arrive," and only one of them had ever been taught to notice it was stuck. So that got pulled out into one shared, tested StuckGuard component — track your best distance to the target, and if you haven't beaten it in a couple of seconds, give up and go idle instead of standing there forever. It's a small piece of code, but it quietly fixed the same class of bug in eight different places at once, and "survivors getting stuck on walls" hasn't come back since.

What's next

The near-term list is mostly about making existing systems feel complete rather than adding new ones: right now, only two of the seven flag types you can theoretically post — Scavenge and Construction — are actually reachable in the UI. Clear, Defend, Explore, Rescue, and Trade all exist under the hood and are already scored by the AI, but there's no way to place one yet. Making all seven placeable is next up.

Past that, the bigger, more design-heavy pieces are still ahead: the Command Points system that lets you spend a limited resource to take direct control of a survivor in a critical moment, real class-specific behavior for the Medic/Cook/Scout classes (right now they're mechanically identical besides loot weighting), and eventually siege events and special zombie types to keep the escalating-threat pillar honest as a base grows.

It's still very much a project in progress — no title yet, hence the name — but the core loop is there, and it's already produced more than one moment that felt like an actual story rather than a stat sheet. More updates as it grows.