A first-person arcade shooter built in Unreal Engine 5 as a criticism of generative AI. As the sole systems designer, I built every gameplay system — enemy AI, weapons, the EMP, spawning, and save/persistence — and shipped the build to Steam myself.
Left is the Roller in-game; right is its Behavior Tree running live. As it spots the player the active nodes light up and it moves through its states — detecting, chasing, and attaching — in sync with what's on screen.
It's the same tree broken down below: a Selector prioritizing states, fed by custom services and a drop-and-fall task.
AI slop has overtaken a robotics HQ and corrupted its machines. You're the last security guard left — reduce the rogue creations to scrap using two weapons and scattered EMPs in fast, relentless, no-breaks combat.
The game is a deliberate criticism of generative AI: the enemies and environment are built from found, pre-existing AI imagery. The thing you're fighting is literally made of the thing the game critiques.
Built by a small team on a 20-week timeline, the game is a finished, shippable vertical slice: two levels and an ending, two guns, four enemy types, an EMP device, and several puzzles — with a full Steam store page.
As the sole systems designer, I owned effectively every interactive system, plus packaging, building, and the Steam release pipeline. The only work outside my scope was map layout, Niagara VFX, and two small UI hookups.
The Roller runs on a Behavior Tree + Blackboard. A Selector prioritizes three states — Attached, Falling, Chasing — each gated by a blackboard decorator on RollerState.
Custom services keep it reactive: BTService_Detect checks for the player on a 0.1–0.3s tick, and BTService_UpdatePlayerLocation refreshes the chase target every 0.05s. A custom task, BTTask_DropAndFall, handles the drop from a surface. Writing my own services and tasks — not just wiring existing nodes — is where the real AI work is.
Where the Roller uses a Behavior Tree, the Flyer runs on a hand-built Blueprint state machine driven by an E_FlyerState enum. Each tick evaluates conditions and routes through a Switch into the active state's logic.
Building enemies two ways — a BT for the Roller, a custom state machine for the Flyer — was a deliberate choice to fit each enemy's needs and to demonstrate range across AI architectures.
The EMP is a throwable crowd-control device — the game's risk/relief beat. On detonation it runs a multi-sphere trace in a blast radius, then a for-each loop disables each caught enemy by type (Flyer, Roller, Turret, Tank), applies a VFX and material blend, and despawns.
It's pickup-and-throw with detonate-on-bounce ground detection, so positioning it under a swarm is a real tactical decision when you're about to be overrun.
Both guns were built from the ground up — firing, ammo, and feel. The Shockgun combines a line trace with projectile and impact VFX and camera shake, so hits read with weight and enemies visibly break down to scrap.
Weapon switching, input, movement, and world interaction all run through the player Blueprint I built, organized into named functions and categorized variables rather than one tangled graph.
The spawner manages drone clusters and hands each new enemy its own data — patrol points, reload path, and speed — as it spawns. Slow, normal, and fast spawn tiers let the encounter's intensity be tuned, which is what sells the game's "no breaks" feeling.
A save/persistence chain carries player state — health, shield, ammo, keycards, kill count, elapsed time — across level transitions and into the level-swap setup, so progress isn't lost between the game's two levels. Under the hood the game uses a component-based, event-driven architecture (health and shield components fire dispatchers that drive the HUD).
The EMP in the field — the throwable that buys you space when you're about to be overrun. Land it under a cluster and everything caught in the blast disables at once.
The trace-and-disable-by-type logic behind it is broken down in the Combat section above.
Behavior Tree + Blackboard for the Roller (with custom services and tasks), and a hand-built enum state machine for the Flyer — each chosen to fit the enemy rather than forced into one pattern.
Both guns end to end, plus the EMP's trace-and-disable-by-type crowd control with detonate-on-bounce throwing — the mechanic that gives the combat its risk/relief rhythm.
A cluster spawner that relays per-drone data with tunable difficulty tiers, and a save chain that carries player state across level loads — built on component-based, event-driven architecture.
I packaged and built the game and set up the Steam release pipeline on my own machine — taking it from prototype to a live store page. Owning the full pipeline is uncommon for a designer.