Game Development

C# pathway

Programming Foundations / Practice rooms / Track curriculum and enrollment

1. Pong from the Game Loop Up

   Build a replayable Pong match by connecting fixed-step timing, responsive paddle control, discrete contact, shaped bounces, scoring, seeded serves and point phases. Inspect complete state and event traces while keeping rendering separate from simulation.

   • Time Is Part of the Game: 5 lessons
   • Build a Paddle That Feels Deliberate: 5 lessons
   • Make Contact Mean Something: 5 lessons
   • Turn Misses into a Rally State Machine: 5 lessons
   • Assemble a Replayable Match: 5 lessons

2. Breakout and Collision Geometry

   Build a deterministic Breakout level from broad-phase candidates, exact circle contact, ordered swept responses, brick health, drops and effects, lives and inspectable replay state.

   • Bounds Before Collisions: 5 lessons
   • Contact Has Direction: 5 lessons
   • Catch What Crossed Between Frames: 5 lessons
   • State Beyond the Bounce: 5 lessons
   • Assemble and Inspect the Level: 5 lessons

3. A Responsive Platformer Controller

   Compose a responsive controller from gravity, slope tangents, jump timing, ground and air response, translating supports, drop-through, checkpoints and adjustable profiles, with input-attributed replay evidence.

   • Fall, Probe, and Land: 5 lessons
   • Make Intent Survive Human Timing: 5 lessons
   • Tune Response, Not Just Speed: 5 lessons
   • Move with the World Without Losing Yourself: 5 lessons
   • Measure the Controller You Built: 5 lessons

4. Animation and Game Feel

   Connect animation state, continuous pose phases, impact timing, live particles, sound requests and camera framing. Build a deterministic scene with independent effect controls and trace each effect to its source event.

   • Animation Follows State: 5 lessons
   • Write Motion as a Phrase: 5 lessons
   • Make Impact Causal: 5 lessons
   • Budget the Supporting Cast: 5 lessons
   • Keep Feedback Legible for More Players: 5 lessons

5. Enemy Minds and Combat

   Build an enemy that senses and remembers targets, chooses known goals, steers, and fights through explicit attack windows. Trace legal state changes, actor-specific health, once-per-attack hits and applied difficulty settings in a replayable encounter.

   • Make Enemy State Explicit: 5 lessons
   • Perception Is Evidence, Not Omniscience: 5 lessons
   • Move Toward a Reasoned Target: 5 lessons
   • Make Combat Windows Exact: 5 lessons
   • Prove Why the Enemy Acted: 5 lessons

6. Paths, Waves, and Tower Defence

   Build a tower-defence encounter that connects weighted grid routing, scheduled and deferred enemies, target policy, projectile interception and contact, legal purchases, independent slow effects, unique rewards/leaks and an audited replay.

   • Turn a Map into a Graph: 5 lessons
   • Search Without Hiding the Search: 5 lessons
   • Aim at Where the Target Will Be: 5 lessons
   • Schedule Pressure and Account for Every Coin: 5 lessons
   • Defend, Measure, and Audit: 5 lessons

7. Procedural Dungeons

   Build a seeded dungeon from room layouts and cave updates, repair all floor components, place content under budget and spacing rules, and inspect the map, routes, stage history and replay evidence.

   • Variation You Can Reproduce: 5 lessons
   • Carve Structure Before Decoration: 5 lessons
   • Grow Caves, Then Prove They Connect: 5 lessons
   • Place Content Under Constraints: 5 lessons
   • Publish the Seed and Its Evidence: 5 lessons

8. Inventory, Dialogue, and Saving

   Build item-specific inventory and crafting, equip owned instances, connect dialogue and quest rewards, retain complete action history, and verify versioned save migration and recovery.

   • Inventory Snapshots and Stack Operations: 5 lessons
   • Crafting Previews and Transaction Records: 5 lessons
   • Conversation Changes World State: 5 lessons
   • A Save Is a Versioned Protocol: 5 lessons
   • Prove the Whole Player-State Journey: 5 lessons

9. Performance and Data-Oriented Worlds

   Build reusable object pools, coherent spatial queries, bounded motion scheduling and dense component storage; assemble a replayable crowded world with actual state, trace-derived integrity checks and optional measured frame-time observations.

   • Control Object Lifetime Before Optimizing Math: 5 lessons
   • Ask Nearby Space, Not the Whole World: 5 lessons
   • Schedule Work Across Frames: 5 lessons
   • Make Memory Layout Match the Work: 5 lessons
   • Ship a Crowded World With Evidence: 5 lessons

10. Complete Browser Game: Signal Courier

    Design, implement, balance, make accessible, test, and publish Signal Courier: a deterministic top-down extraction game whose controls, combat, content, progression, performance, replay, and release evidence all run in the browser.

    • Turn a Game Pitch Into Executable Rules: 5 lessons
    • Make Every Frame of the Core Loop Explainable: 5 lessons
    • Build Tension Without Breaking the Rules: 5 lessons
    • Make Challenge Legible and Controllable: 5 lessons
    • Release a Game You Can Defend: 5 lessons