Gate Patrol

Build defenses, spend Scrap, and survive an escalating zombie horde.

Comment

Inspiration

Gate Patrol started with a simple question: how much strategic depth can come from defending one vulnerable position against an increasingly overwhelming zombie horde?

I wanted to build a portrait mobile survival game that is immediately understandable but becomes increasingly tense as the player survives. Rather than relying on complicated controls or a large number of systems, the goal was to make a small set of mechanics interact in meaningful ways: movement, automatic combat, Scrap collection, defensive construction, upgrades, and increasingly dangerous waves.

A major design goal was creating the feeling that the player is barely holding the line while every decision about where to move, what to build, and when to spend resources matters.

What it does

Gate Patrol is a single-player survival and tower-defense strategy game built for portrait mobile play.

The player controls a survivor defending a fortified Base from escalating waves of infected. The survivor automatically fires at nearby enemies while the player focuses on movement, positioning, construction, and resource decisions.

Defeated enemies provide Scrap that can be invested into battlefield defenses including Sentry Guns, Shotgun Turrets, and a staffed Defender Post. Defenses can be strengthened over time, while Scrap can also be reserved for repairs or future construction.

The game also includes:

  • Escalating zombie waves
  • Walker and Runner enemy threats
  • A Breaker boss encounter
  • Physical Scrap-based construction
  • Defensive upgrades
  • Three-choice Level Up upgrades
  • Persistent Armory progression
  • A tactical Mortar Barrage ability
  • Different wave-pressure patterns that change how the horde approaches
  • Increasingly dense late-game enemy groups

The goal is simple:

Build the line. Spend your Scrap wisely. Protect the gate. Survive the horde.

How we built it

Gate Patrol was developed as a prompt-assisted HTML5 / JavaScript prototype using Three.js.

Development followed an iterative process:

Design → AI-assisted implementation → playtest → gameplay recording → review → refinement

Instead of attempting to create the complete game in one large prompt, the prototype was developed through many controlled iterations.

Early versions established movement, automatic firing, enemies, Base health, waves, and Scrap. Later iterations introduced construction, defensive upgrades, progression, boss encounters, tactical abilities, persistent upgrades, and different horde-pressure patterns.

AI tools assisted with implementation, debugging, visual concepts, gameplay analysis, balancing, and iteration planning. Each implementation was tested in the running game rather than accepted solely based on generated code or implementation reports.

The game uses a lightweight architecture designed for large enemy groups, including object pooling, spatial collision optimization, bounded visual effects, local assets, and simplified Three.js rendering appropriate for mobile browsers.

Challenges we ran into

One of the largest challenges was making a large zombie horde feel threatening without making the battlefield visually confusing or causing unnecessary performance problems.

Enemy density alone was not enough. Spawn timing, spacing, grouping, movement, and wave structure all needed repeated adjustment before enemies began feeling like a coordinated threat rather than a sequence of individual targets.

Another challenge was visual readability. Because Gate Patrol is designed for a portrait phone screen, characters, defenses, projectiles, construction sites, resources, and UI all compete for limited space.

Several visual ideas were tested and rejected because they were too large, too detailed, or interfered with gameplay.

We also encountered smaller technical problems that only became obvious during gameplay recording. For example, an oversized firing effect initially appeared correct at the source-code level but remained visually distracting in motion. Gameplay footage helped isolate the real cause and allowed the effect to be rebuilt more cleanly.

The project reinforced the importance of testing the actual player experience rather than assuming a technically functional feature is automatically a good one.

Accomplishments that we're proud of

The system I am most proud of is the physical construction loop.

Instead of simply purchasing a defense from a menu, the player approaches a construction location and gradually invests Scrap into it while the horde continues advancing.

This creates a natural risk-versus-reward decision:

Do I remain here long enough to finish this defense, or abandon construction temporarily to deal with the incoming threat?

I am also proud of how the horde system evolved.

Later waves can create different pressure patterns such as concentrated central surges, separated attack fronts, fast Runner pulses, and longer sustained attacks. These variations use the same core enemy roster while creating different tactical situations.

The result is a prototype where resource management, positioning, defensive construction, wave structure, and combat increasingly reinforce one another rather than feeling like isolated features.

What we learned

The biggest lesson was that adding more features is not always the best way to make a game deeper.

Some of the strongest improvements came from changing how existing systems interacted.

A different spawn pattern could make an existing defense more valuable. A more visible Scrap reward could make both combat and construction more satisfying. Changing the physical placement of defenses could improve strategy without adding another system.

I also learned that AI-assisted development works best when prompts are specific about what should change and, equally importantly, what should remain untouched.

As the prototype became more complex, targeted iterations produced much safer and more predictable results than broad rewrites.

Finally, repeated gameplay recording became one of the most useful parts of development. Many issues that looked acceptable in code became immediately obvious when watching the game in motion.

What's next for Gate Patrol

The current prototype focuses on proving the core fantasy of surviving an escalating horde while physically strengthening a defensive position.

A larger version of Gate Patrol could expand that foundation with:

  • Additional defensive choices
  • More survivor-operated fortifications
  • Additional enemy pressure patterns
  • New boss encounters
  • Deeper persistent progression
  • Additional tactical abilities
  • More specialized run builds
  • Greater visual evolution of the fortified Base
  • Longer survival runs with stronger late-game escalation

The goal would remain focused on the same core experience:

A fast, readable portrait-mobile survival game where building the right defense at the right moment can determine whether the gate holds or falls.

Share this project:

Updates

Submission history