I Built an FPS in Godot. My Daughter Is Building the World.
I built a horror first-person shooter in Godot and now my 13-year-old daughter is designing its monsters and writing its lore. This post covers the game and what backend engineering brought to it, what game dev taught me back and how the project got a creative director.
For some context, I write Go for a living (CLI tools, deployment pipelines and compilers). My usual Tuesday involves connection pools and error propagation and the most visual thing I build is terminal output with ANSI colors.
So, naturally, I decided to build a first-person shooter.
I had no game dev experience. No Unity history. No Unreal scars. Just a fresh Godot 4.6 project and a vague idea about dark corridors, plus the confidence that comes from not knowing what you’re getting into.
The Game
It’s a horror FPS where you wake up in a labyrinth, and it is actually dark, not “slightly dimmed ambient light” dark. You have a flashlight on F and a gun with 30 rounds, and the growing suspicion that something is moving in the fog ahead.
The maze is built with GridMap walls and CSG geometry, and there aren’t any imported 3D models, asset store purchases or textures. Every surface is a flat color: deep browns, cold grays and the occasional sickly green exit sign. The lighting does the work. SpotLight3D ceiling lamps cast warm pools through volumetric fog and SSAO darkens the corners, and the color grading is desaturated to 0.6.
It looks like a PS1 game that learned about post-processing. And it works!
There are three enemy types, and they share one script with exported parameters:
- The Standard is red with 30HP and moves at a moderate speed.
- The Runner is green with 15HP and is fast.
- The Brute is purple with 60HP and is slow.
There’s no inheritance stack and no clever polymorphism, just @export variables and a state machine with four states: IDLE, CHASE, ATTACK and DEAD.
The AI does line-of-sight checks with physics raycasts and has a three-second memory before it forgets you. Break line of sight around a corner and you’ve bought yourself three seconds. Use them.
The combat has more juice than it has any right to. There’s hitscan shooting, camera recoil and a hitmarker flash. Enemies stagger and flash white on damage, and as an attack telegraph they turn orange for 300ms before lunging. Damage indicators light up the HUD edges and the muzzle flash comes from an OmniLight3D that lives for 50 milliseconds.
It feels like a game. A real one.
Every sound effect is procedurally generated from sine waves and noise envelopes that are synthesized in GDScript at runtime. The gunshot is a 4000Hz burst for 60ms and the enemy hit is a short sweep down from 1200Hz. The key pickup is a dual-tone chime of 523Hz rising to 659Hz. Everything else is math.
The background music is AI-generated with Suno. Level 1 gets jump-scare horror and Level 2 gets industrial metal. The tonal shift is deliberate: dread first, then violence. That’s two MP3s and zero music production skills, and the atmosphere carries half the design.
What Backend Engineering Brings to Game Dev
The useful backend instinct is not “make everything abstract.” It is this: build systems, not piles of scripts.
The architecture is a two-tier scene tree. A persistent game shell (game.tscn) owns the Player and the HUD and the run-global state (kills, elapsed time and the current level index). Individual level scenes load into a LevelContainer node and get swapped on progression.
Each level implements a small contract where it provides a SpawnPoint, an Enemies container, a KeyPickup, a Door and an ExitTrigger and emits level_completed when the player reaches the exit. The game shell handles the fade transitions, the health recovery and the victory screen.
Communication is signal-driven, so you call down and signal up. The player emits health_changed, ammo_changed, hit_landed and damage_taken_from. The HUD listens and the game shell wires it all together. No global state. No autoloads. No singleton soup.
Damage is duck-typed with if target.has_method(&"take_damage"): target.take_damage(damage). There are no interfaces and no base classes, so if it has the method, it takes damage. GDScript doesn’t have Go-style interfaces, but for a game this size it has something better: you can stop caring about the concrete type.
Level progression fades to black, waits for the tween to finish and swaps in the next level scene, and the player gets healed 25HP between levels. Head pitch resets so you don’t start the next maze staring at the ceiling, and a centered “Level 2” announcement fades in and out over 1.5 seconds. These are small details, but they’re the difference between “prototype” and “this feels intentional.”
There are two levels so far, and Level 1 is a warm 36x36 maze with 7 enemies. Level 2 is colder and denser and darker. It has a 24x24 grid with 8 enemies, stronger SSAO, denser fog and bluer lighting. The atmosphere shift tells you the game is escalating without a tutorial box explaining it.
What Game Dev Teaches a Backend Engineer
Godot exposed gaps that distributed systems never did.
In backend engineering state is something you minimize. You build stateless services and keep data immutable, and you write pure functions when you can get away with it.
In game dev, state is the point.
Every frame, every entity has a position and velocity and health, plus an animation state, an AI state and flags that interact in ways you didn’t plan. The enemy is chasing you, staggering from a hit, telegraphing an attack and checking line of sight, and all of that happens 60 times per second for every enemy.
Physics interactions are also humbling. I spent an afternoon debugging why enemies sometimes launched into the ceiling after dying. The death animation scaled them down to 0.1x over 300ms while the collision shape stayed active, and the physics engine interpreted a rapidly shrinking collider as a Very Exciting Event.
The fix was two lines that clear the enemy’s collision layer and mask before the death tween. Finding those lines required understanding something backend code never forced me to care about: the physical simulation doesn’t care about your state machine.
Then there’s the material sharing trap. In Godot, scene instances share material resources by default. Change one enemy’s color to white for a hit flash and every enemy on the map turns white. You need to duplicate() the material in _ready(), and you learn this when your entire screen turns white and you briefly question your life choices.
The feedback loop changes how you think too. In backend work you code and run tests, maybe deploy to staging, and wait for metrics. In Godot you press F5 and you’re in the game in under a second. You feel whether the camera recoil is too aggressive. You hear whether the gunshot works. You know immediately whether the fog is oppressive or just annoying.
The iteration cycle is seconds and not minutes, and it’s dangerously addictive.
Then My Daughter Saw It
I showed the demo to my 13-year-old daughter. It had the dark corridors and the flashlight through the fog, and the enemies chasing around corners and flashing orange before they attack.
She played it for two minutes. Then she was hooked. She was running through corridors and toggling the flashlight, and flinching when the industrial metal kicked in on Level 2.
When she stopped she didn’t say “that was fun.” She said: “The enemies need to look like actual monsters. And there needs to be a story.”
Ten minutes later she had a tablet out and was sketching the first monster. Not because I asked. Because the green capsule labeled “Runner” personally offended her.
She’s going to design every monster and boss in the game: how they look, how they move and why they exist in the labyrinth. She’s also going to draft the lore about why the labyrinth exists, what happened to the people who built it and what the player is doing there.
A horror game without lore is just a shooting gallery with good lighting. She understood that faster than I did.
The game got a creative director. She’s 13 and has zero game dev experience, and she already has stronger opinions about monster design than I have about database indexes.
This was not the plan. It is better than the plan.
Where It Stands
The prototype is playable, with two levels, three enemy types, progression, procedural audio, atmospheric lighting and a combat loop that feels good. The architecture is clean enough to add levels quickly. The code is on GitHub as hollows: 1,200 lines of GDScript across 10 scripts, with no plugins, no external dependencies and no asset store. Pure Godot.
Next up is real art to replace the CSG primitives, because my daughter has a tablet and opinions. The plan also has more enemy types with distinct behaviors, boss encounters at the end of level arcs and lore revealed through the environment. And more levels, darker levels, levels that make you regret owning a flashlight.
I started this project because I wanted to learn Godot. I’m continuing it because my daughter picked up a stylus ten minutes after seeing the demo and decided the world needed to be hers.
The code is mine.
The world will be hers.
The game will be better for it.