Zombie Descent

Top-down shooter with progressively tougher zombie waves that the player defeats to earn a high score.

Role(s): Programmer, Designer

Team Size: 1

Time Frame: 3 weeks

Tools: C++, Custom Engine

Project Summary

Zombie Descent is a top-down shooter featuring progressively tougher zombie waves. I created it as the final project for my Game Engine course at DigiPen, serving as both a showcase and a rigorous test of my custom C++ engine. The game’s increasing enemy difficulty provided a perfect stress test for engine scalability, leading to substantial debugging and optimization efforts. The inspiration for this game came from the Call of Duty zombie mode I used to play with my cousin until 5 a.m. in high school.

Gameplay

Players move horizontally along the bottom of the arena, firing bullets upward at incoming zombie hordes. Each new wave spawns additional enemies with higher health, forcing the player to strategically position and dodge. Some zombies spew “vomit” projectiles, punishing static playstyles. Once the player loses all lives, the game ends, revealing a final score. With each wave cleared, the intensity ramps up, encouraging repeated attempts for higher scores.

Technical Highlights

Custom Engine Integration: Built on a bespoke C++ engine (OpenGL, custom physics, JSON-based object serialization) to handle collisions, rendering, and object lifecycle (creation, destruction).
Dynamic Wave Spawning: The engine’s EnemySpawner class programmatically spawns zombies with incrementally higher HP after each round.
Physics & Collision: Leveraged bounding-box collision (AABB and OBB) for bullet impacts, zombie detection, and projectile interactions, ensuring smooth performance at 60+ FPS.
Event-Driven Architecture: Handled events (e.g., EnemyDeath, GameOver) through a centralized EventManager, enabling decoupled code and clearer game logic.

Challenges & Solutions

Engine Debugging: As the game scaled with more enemies and projectiles, I uncovered bugs in the collision system (e.g., mismatched bounding boxes). By detailed logging and digging deep into engine code, I pinpointed these issues and refined the engine for stable gameplay.
Performance & Memory Management: With wave-based spawning, game objects could pile up quickly. I used efficient object pooling and a “destroy-on-out-of-bounds” approach to remove unused objects, preventing memory bloat or slowdowns.

Achievements

A+ Grade: Received top marks for this final project and class grade, proof that I could successfully architect a game engine.
Complete Engine Stress Test: Successfully validated the engine’s ability to handle dynamic spawning, collision, and event management under heavier load.
Solid FPS & Stability: Maintained a stable framerate, even as enemy counts grew, thanks to targeted optimizations and a fixed physics timestep.

Lessons Learned

Iterative Engine Development: Testing real gameplay scenarios (e.g., large enemy waves) revealed weaknesses in my engine.
Event-Driven Design: Decoupling game logic (e.g., collisions, spawn triggers, scoreboard updates) made the code more maintainable and easier to debug.
Balancing for Fun: Carefully tuning enemy health, and player power was critical to keeping the game challenging yet engaging.

Conclusion

Overall, Zombie Descent demonstrated the resilience and scalability of my custom C++ engine in a wave-based action setting. The project pushed my debugging, optimization, and design skills, ultimately delivering a fast-paced arcade shooter that encourages players to chase high scores—and proves my engine’s readiness for more ambitious projects (see Cursed Bastion game project).

Marco Aguilar