Overview
Pac’s Revenge is a retro-inspired first-person shooter designed to evoke
the feel of classic 90s FPS titles while supporting modern gameplay systems.
The project emphasized extensibility, custom AI behavior, and a performance-conscious
rendering pipeline to support a stylized aesthetic without heavy runtime cost.
I served as lead programmer, owning core gameplay systems, enemy AI, combat architecture,
boss design, and the project’s retro visual pipeline. I also created all visual assets for the game.
My Role & Ownership
Primary Responsibilities
- Lead programmer responsible for core gameplay architecture
- Designed and implemented enemy AI navigation and behaviors
- Architected and refactored the modular combat and weapon systems
- Designed and implemented the final boss AI encounter
- Technical artist responsible for retro visual presentation
- Created all 2D and 3D art assets
Key Systems I Built
Grid-Based Level Representation
- Procedurally generated a 2D grid representation of each level at runtime
- Derived grid data from 3D wall and object placement
- Served as the foundation for AI navigation and enemy behavior constraints
Enemy AI Navigation System
- Implemented a custom A* pathfinding solution operating on the grid-level map
- Supported directional restrictions and configurable step limits
- Enabled differentiated enemy behaviors using shared navigation logic
Modular Combat & Weapon Framework
- Designed a polymorphic weapon architecture to support future content expansion
- Refactored an initially hardcoded single-weapon system into a flexible framework
- Allowed the player controller to interface with any weapon without rewrites
Weapon Implementations
- Programmed the majority of weapon behaviors and interactions
- Leveraged shared interfaces while preserving weapon-specific logic
Final Boss AI State Machine
- Designed and implemented a multi-phase boss encounter
- Used a custom state machine to support dynamic behavior changes
- Integrated player feedback and phase transitions for pacing and challenge
Retro-Style Shader Pipeline
- Built multiple shaders in HLSL to emulate a retro visual aesthetic
- Implemented custom fog and post-processing effects with stepped opacity
- Replaced Unity’s internal lighting model with lightweight post-processing to reduce render cost
Technical Challenges & Decisions
Refactoring the Combat System for Scalability
The project was initially scoped around a single weapon. As the design evolved, the hardcoded
approach became a bottleneck. I led a refactor using polymorphism and shared interfaces, allowing
new weapons to be added without modifying player or combat controller logic. This significantly
improved maintainability and supported future content expansion.
Performance-Conscious Retro Rendering
Rather than relying on traditional real-time lighting, I replaced the lighting model with custom
post-processing shaders that achieved the desired retro look at a fraction of the cost. This approach
improved performance while maintaining consistent visual style across environments.
Results & Outcome
- Released on Steam to a small audience
- Received positive player feedback despite limited marketing
- Fully playable and shipped product demonstrating long-term development, iteration, and scope management