Survival Sandbox Prototype
| |
| Design | Systems Design |
|---|---|
| Programming | AI Programming · Gameplay Programming · Tools Programming · UI Programming |
| Production | Testing |
| Genres | Sandbox · Survival |
An unannounced top-down 2D survival sandbox in Unity 6, where every tool and weapon is the sum of the parts it's built from.
I'm the sole programmer on the prototype, for a private client. I turned the client's documents into one design document, then built the game's systems: procedural world generation, crafting, enemy AI, and the editor tools behind them.
The project
This is a top-down 2D survival sandbox in Unity 6, set on an abandoned Earth after an environmental collapse. The player manages health, hunger and thirst in a procedurally generated world, and builds tools and weapons out of the parts they find. It’s unannounced, so the client and the game’s name stay private.
This page shows the prototype. The art is placeholder, taken from third-party asset packs.
My role
I’m the sole programmer. My job was to turn the client’s design into a playable prototype, and to build the systems the full game will grow on.
What I did
One design document. The design lived in many places: the client’s GDD, slide decks, diagrams, and recordings of our specification sessions. I consolidated all of it into a single design document where every section names its sources, and I listed the questions the documents left open, so decisions were made before the code depended on them.
Tools that are the sum of their parts. The core idea is that a tool’s stats come from what it’s made of. I built an item instance layer so each crafted tool can carry its own parts, durability and effects, and a seven-cell grid where the pattern of parts decides which tool comes out. Parts fold into stats in a fixed order, so the order they were placed in never changes the result.
A world from a seed. The world is generated from a seed, so the same seed always builds the same world. It has a round boundary, terrain autotiled a quarter tile at a time, and houses placed as neighborhoods: a core house far from any other core, with more houses grown beside it by the design’s rules. A world 90 tiles in radius generates in about a second and a half in the editor.
Enemies you learn to read. The design describes enemies as distinct stages the player learns to exploit, so each enemy is a state machine you can read: wander, chase, attack, strafe, guard, flee, scavenge. Before every swing an enemy stands still and shows in red exactly where the hit will land, and a “!” goes up when it spots you. Enemies find their way with A* pathfinding, and they live in camps that call them home at night.
Content as data. Items, recipes, tool parts, enemies and loot are authored in 15 tables that an importer turns into assets, so a new enemy is a row in a table rather than a new prefab. Editor tools rebuild the prototype’s content in one step, and running them twice changes nothing.
One kit for everyone. The player and every enemy share the same actor kit, so a bandit’s sword swing is the player’s sword swing. Chopping a tree, breaking a wall and hitting a bandit all go through the same damage path.
Testing as I go. The codebase has 196 automated tests. Before handing the prototype over, I tested every task against its acceptance criteria and wrote up what passed, what didn’t, and the problems I found outside the tasks.
Outcome
The prototype is playable from the title screen to nightfall, with a generated world, crafting, combat and survival. It’s still in development, and the full game is being built on these systems.
Screenshots and footage captured from the prototype.
- This game is unannounced, so its name and client aren't shown.