Iron Dome

A 2D base-defense arcade shooter built from scratch on a proprietary C++ engine without third-party frameworks. Engineered the custom 2D math library, deterministic AABB collision pipeline, modular weapon ballistics (piercing, airburst, and overheat), and a high-performance particle system under a fixed 60 FPS update loop.

Role: Gameplay & Physics Programmer (Project Lead)

Play on Itch.io ↗

Project Overview

Iron Dome is a 2D arcade defense shooter inspired by Missile Command and modern anti-air defense systems. Positioned at the bottom of the screen, players defend ground infrastructure by intercepting incoming waves of enemy fighters, bombers, and guided bombs using customizable weapon loadouts.

Built from scratch without third-party game frameworks, the game runs on a custom 2D C++ engine. I developed the core physics simulation and combat architecture: authoring the custom Vec2 and Mtx33 math libraries, implementing broad-to-narrow AABB collision detection, coding distinct weapon mechanics (piercing rounds, airburst flak, overheating, DOT), and developing the dynamic particle pipeline and upgrade shop economy.

Key Contributions

Custom Math & AABB Collision Engine

I engineered a lightweight 2D math library from scratch (Vec2, Mtx33) and implemented a two-tier collision pipeline. The broad phase leverages fast squared-distance checks to reject distant pairs early, while the narrow phase evaluates static AABB overlaps and swept continuous collision detection (CCD) against relative velocities. Coupled with a fixed 60 FPS delta-time step (g_dt), this eliminates high-speed projectile tunneling without relying on third-party physics engines.

Combat Mechanics

I developed various different turrets with dedicated gameplay logic, including timed airburst flak with radial area-of-effect detonations, a fast firing machine gun turret, incendiary thermal rounds which applies damage-over-time burn ticks, and piercing munitions that utilize penetration hit counters to cleanly pass through an initial target without duplicate hit registration. Primary and secondary firing cadences operate on decoupled delta-time accumulators, guaranteeing consistent weapon rates of fire across all loadout combinations.

Particle VFX System

Smoke Trail VFX

Explosion VFX

I engineered an optimized particle engine utilizing an active-tracking linked list over a pre-allocated pool to eliminate runtime heap allocations and garbage collection overhead during intense combat. The update and render pipelines skip inactive nodes entirely, evaluating only live particles for wind forces, alpha fading, and scale decay. Integrated dynamic state-driven emitters to spawn environmental weather, persistent smoke trails when enemy aircraft fall below 50% health, and explosion effects when enemy aircraft are destroyed.

2D Collision Pipeline Deep-Dive

The Problem:

During early gameplay testing with dense wave spawns, dozens of fast-moving aerial targets, dropping bombs, and high-velocity tracer rounds operated on screen simultaneously. Without a third-party physics engine like Box2D, relying on a naive O(N²) collision loop caused noticeable frame rate drops. More critically, high-speed autocannon projectiles frequently suffered from tunneling, skipping past enemy hitboxes between discrete frames and failing to register valid hits during intense combat scenarios.

The Solution:

I engineered a custom two-tier collision pipeline to eliminate tunneling and maintain a locked 60 FPS without external physics dependencies. To minimize CPU overhead during dense combat, the broad phase evaluates fast squared-distance checks (sqLength()) against combined bounding dimensions, discarding non-colliding entity pairs early without expensive square-root operations.

Once potential intersections are identified, the narrow phase checks static bounding overlaps before executing dynamic swept continuous collision detection (dynamicAABB) for moving bodies. By projecting relative velocity vectors across the fixed timestep (g_dt) and resolving entering and exiting time intervals, the system accurately detects sub-frame collisions and guarantees deterministic hit registration even at maximum projectile speeds.

Particle System Deep-Dive

The Problem:

Creating responsive, immersive visual feedback required a flexible effects system capable of simulating diverse behaviors, from transient bullet impact sparks and explosion debris to ambient weather and stateful damage smoke. Hardcoding individual particle scripts or managing one-off timers led to bloated codebase logic and inflexible visual parameters. The engine needed a unified, data-friendly architecture where particle lifecycles, physics decay, and visual transitions could be driven dynamically by runtime gameplay events.

The Solution:

I engineered a modular 2D particle simulation using parameterized lifecycle policies and normalized time interpolation. Each particle instance maintains its initial transform and velocity alongside a delta-time lifetime accumulator. By evaluating the ratio of remaining lifetime against total lifespan, the simulation dynamically interpolates properties such as alpha fading, scale decay, and drag coefficients every frame without requiring manual per-frame keyframing.

To support varied combat and environmental requirements, I decoupled emitter logic from the core particle update loop. Emitters listen directly for gameplay state triggers, such as spawning persistent trailing smoke when an aircraft drops below 50% health, emitting fiery debris on target destruction, or continuously applying directional wind vectors to ambient weather. This modular design enabled rapid iteration on distinct visual profiles while keeping simulation logic decoupled, predictable, and with minimal performance overhead.

Outcomes

Iron Dome established my foundational skills in low-level systems programming, custom 2D math pipelines, and technical project leadership without reliance on commercial game engines. Building the proprietary math library, physics subsystem, and active particle engine from scratch, while steering team milestones and task roadmaps as Project Manager, provided deep practical experience in production delivery, memory management, and systems design.

Project Management & Production Leadership: Led sprint planning, milestone tracking, and task delegation across an 8-person multidisciplinary team, aligning low-level engine architecture goals with gameplay deliverables to ensure on-time project completion.
Proprietary 2D Math & Physics Engine: Engineered custom vector (Vec2) and matrix (Mtx33) libraries alongside a broad-to-narrow swept continuous collision detection (CCD) pipeline locked to a deterministic 60 FPS fixed delta-time step (g_dt).
Modular Ballistics & Combat Logic: Designed multi-behavior projectile mechanics including multi-target piercing, proximity/timed airburst flak explosions, turret heat management, and decoupled primary/secondary weapon cadences.
High-Performance Particle VFX Pipeline: Built a modular, zero-allocation active-list particle manager featuring dynamic lifetime interpolation (alpha fading, scale decay) and state-driven event emitters (health-threshold aircraft smoke, wind weather, radial flak debris).