Will O’ The Fox - Cultivation of Core Programming Concepts

Overview

Over the course of two semesters, I designed and built a bespoke 2D game engine from the ground up while leading a team of four programmers to develop a puzzle platformer on top of it. This project was my first serious foray into core software development concepts — data structures, abstraction, polymorphism, and serialization all became daily tools rather than textbook topics. The result was a fully functional component-based engine written entirely in C++ with no middleware, powering a complete 2D platforming puzzle game. Beyond the technical work, this project taught me how to manage a small engineering team, run productive meetings, and maintain a shared codebase across multiple contributors using different kinds of version control.

Engine Architecture & Team Leadership

I managed a team of four programmers as we co-wrote the engine from scratch in C++, relying on no middleware and integrating only targeted libraries where they made sense: OpenGL for rendering, SDL2 for windowing and input, JSON for Modern C++ for data handling, FMOD for audio, and Tiled for level editing and map data. Every other system — the core loop, object management, physics, scripting logic — was our own. My role was both architectural and managerial: I defined the engine’s high-level structure, assigned ownership of subsystems, and kept the team aligned on conventions and priorities throughout both semesters.

Development Process & Knowledge Sharing

Keeping a four-person team productive on a shared codebase required consistent process. I led weekly technical meetings where we reviewed progress, surfaced blockers, and planned upcoming work. Code reviews were a regular practice — not just for quality control, but as a learning tool for the whole team. I also organized pair programming sessions, particularly when onboarding teammates to unfamiliar subsystems, and drove the creation of internal engine documentation so that any team member could work confidently across the codebase. These practices kept our velocity steady and ensured that knowledge wasn’t siloed with any single person.

Entity Component System Design

The engine’s backbone was an Entity Component System (ECS) design pattern, which I wrote the foundational structure for and then taught to the rest of the team. ECS gave us the flexibility to define game objects as compositions of small, reusable components rather than deep inheritance hierarchies — a critical advantage for a puzzle platformer where behaviors needed to be mixed, matched, and iterated on quickly. I authored the core entity manager, component registration system, and update loop, then walked each programmer through how to extend the system with new component types. This pattern shaped every other system in the engine and became the shared language our team used to reason about game logic.

Automatic Deserialization & Polymorphic Types

One of the more technically ambitious features I built was an automatic deserialization pipeline for engine structures. Components, game objects, and entire levels could be defined in external data files and loaded at runtime without manual parsing for each type. The system leveraged polymorphic serializable types, meaning that new component classes could be registered and deserialized generically — the engine didn’t need to know the concrete type at compile time to reconstruct it from data. This dramatically sped up our content pipeline, allowed our team to iterate on level designs and object configurations without recompiling, and gave me hands-on experience with some of the more nuanced aspects of C++ type systems and runtime polymorphism.