Blaze
A retro arcade shoot em up inspired by Geometry Wars, built in Unity with vector-style visuals, wave-based survival, and a unique boost-to-kill mechanic.
video
screenshots
about
About the Project
Blaze is a top-down arcade survival game built in the spirit of Geometry Wars Retro Evolved 2 — the first Xbox Live Arcade game I ever owned, and a game that's stuck with me ever since. Waves of enemies spawn and close in on the player, and the goal is simply to survive as long as possible.
The visuals are built entirely from vector-generated shapes — no sprites or textures, just clean geometric forms that evoke the classic arcade aesthetic.
The Core Mechanic
The most distinctive design decision in Blaze is how combat works. Your guns don't damage enemies — instead they fire backwards to intercept incoming missiles. To actually destroy enemies, you have to boost-dash directly into them, smashing them apart on contact. This creates a constant tension between staying mobile to survive and committing to aggressive dashes to clear the screen.
Features
Wave-based survival with escalating difficulty, vector-style visuals, rear-firing guns for missile interception, boost-dash as the primary offensive tool, and a priority-based enemy AI pathfinding system built to handle hundreds of simultaneous enemies.
tech breakdown
The most technically interesting challenge in Blaze was the enemy AI pathfinding. With potentially hundreds of enemies on screen at once, running A* pathfinding recalculations for every enemy every frame was never going to work.
The solution was a grid cell priority queue system. The map is divided into square cells, and path recalculation requests are queued and processed over time rather than all at once. Enemies in the same cell as the player, or in adjacent cells, are given higher priority and recalculate more frequently. Enemies further away recalculate less often — the player rarely notices the difference, but the performance impact is significant.
If I were to rebuild this today I'd swap the A* implementation for a flow field algorithm, which is much better suited to large numbers of enemies all targeting the same point. A single flow field calculation covers the entire map and every enemy can read from it — far more efficient than individual pathfinding per enemy.
what i learned
Blaze taught me a lot about designing around performance constraints. The AI pathfinding problem forced me to think carefully about when and how often expensive calculations need to run — and how to fake precision where the player can't tell the difference.
The boost-to-kill mechanic came from a desire to make movement feel meaningful. In most shoot em ups the ship feels like a cursor — you just point and shoot. Making the dash your primary weapon meant positioning and momentum mattered, which made the game feel much more physical and satisfying.
Knowing what I know now about flow fields, I'd approach the AI very differently. But working through the problem with A* and a priority queue was genuinely educational — understanding why a flow field is better requires understanding what A* struggles with first.