[{"content":" Building Complete Gameplay Experiences # These projects represent my work designing and developing complete games, from initial concepts to polished gameplay experiences. They showcase my strengths in gameplay programming, technical design, software engineering, and cross-disciplinary collaboration while emphasizing modular systems that are both enjoyable for players and maintainable for developers.\nProjects # ","externalUrl":null,"permalink":"/projects/game-development/","section":"Projects","summary":"","title":"Game Development","type":"projects"},{"content":"A baseball roguelike built around modular gameplay systems, strategic team management, and data-driven content designed for rapid iteration and future expansion.\nProject Overview Monster League Baseball is an actively developed 2.5D baseball roguelike that blends strategic team management with fast-paced arcade baseball gameplay. As the project\u0026rsquo;s Lead Designer and Gameplay Programmer, I established the game\u0026rsquo;s overall vision, designed its core mechanics, and continue to guide its development from concept to implementation.\nBeyond defining the player experience, I develop the underlying gameplay systems and software architecture that support the game\u0026rsquo;s continued growth. My focus is on creating modular, maintainable, and data-driven systems that enable rapid iteration, simplify the addition of new content, and allow designers to expand gameplay without requiring significant code changes.\nWorking closely with artists, designers, and fellow programmers, I help translate creative ideas into polished gameplay while balancing technical scalability with an engaging player experience.\nQuick Facts Status Active Development Role Lead Designer \u0026amp; Gameplay Programmer Team Size 8 Developers Duration May 2025 - Present Engine Unity Language C# Version Control Perforce Platform Windows \u0026amp; Mac Play Steam • itch.io Videos YouTube Devlog Lead Design # Directed the creative vision of Monster League Baseball, establishing the core gameplay experience while guiding the design of new mechanics throughout development.\n▶ Core Gameplay Vision\nGameplay Programming # Implemented the core gameplay systems that define the player\u0026rsquo;s on-field experience.\n▶ Batting System\n▶ Running System\n▶ Upgrade System\n▶ Superlative System\nChallenges \u0026amp; Lessons Learned # Reflecting on the technical and design challenges encountered throughout development, the decisions made to overcome them, and the insights gained that continue to influence my approach to gameplay programming and software engineering.\n▶ Challenges and Lessons\nLead Design Core Gameplay Vision # Monster League Baseball was created to address a gap in the sports game genre by combining the strategic depth and replayability of roguelikes with the accessibility and excitement of baseball. Inspired by games such as Slay the Spire, Dicey Dungeons, and Vampire Survivors, my goal was to create a sports game where every run feels unique while remaining approachable to players of all skill levels.\nFrom the beginning of development, every design decision has been guided by four core design pillars that continue to shape the game today.\nAccessibility First # One of the primary design goals was creating a game with a low skill floor and a high skill ceiling. Players should be able to jump into a game with only a basic understanding of baseball concepts such as strikes, outs, and innings, without requiring lengthy tutorials or prior experience.\nAt the same time, experienced players are rewarded through strategic team building, upgrade synergies, and mastery of the game\u0026rsquo;s mechanics. My goal was to create a game that players could immediately understand while continuing to discover new strategies over dozens of playthroughs.\nEvery Run Is Unique # A central pillar of Monster League Baseball is giving players ownership over the team they build.\nBefore every run, players draft nine athletes from a roster of twelve, allowing them to create teams that reflect their preferred playstyle. Throughout development, one of the most rewarding experiences has been watching players naturally develop favorite characters, preferred team compositions, and even players they intentionally avoid.\nThis philosophy extends beyond gameplay. Players can customize their team\u0026rsquo;s colors, while the post-game Superlative System celebrates individual player achievements, helping each team feel unique and memorable.\n*Lineup screen where players draft their team before beginning a run.*\nMeaningful Decisions # Every inning is designed to present meaningful choices that influence the remainder of the run.\nPlayers continuously decide how to improve their team through upgrade selection, roster management, and long-term planning. Rather than relying solely on mechanical skill, Monster League Baseball encourages experimentation and rewards discovering powerful synergies between players and upgrades.\nThe objective is for every run to tell a different story, giving players new strategies to explore and reasons to return.\nCelebrating Baseball # While Monster League Baseball embraces the creativity and replayability of the roguelike genre, it is also intended to celebrate the personality and traditions of baseball.\nMany gameplay elements draw inspiration from classic ballpark culture. Upgrade items are themed around stadium food such as hot dogs, popcorn, burgers, peanuts, and slushies, while occasionally embracing more unconventional additions like lobster, shish kebabs, and cans of worms to reinforce the game\u0026rsquo;s playful tone.\nThe same philosophy extends to the game\u0026rsquo;s presentation. An early trailer featured a remix of Take Me Out to the Ball Game, while boss teams such as the Cy Youngs reference baseball history and terminology. These details help create a lighthearted atmosphere that captures the charm of spending a day at the ballpark while embracing the game\u0026rsquo;s whimsical world.\nGameplay Programming Batting System # Highlights # ⚾ Timing-based batting mechanic combining swing timing, directional aiming, and power control. 📐 Custom algorithms calculate launch angle and hit distance based on player input and pitch location. 🎲 Controlled randomness creates varied yet predictable batting outcomes. 🔄 Finite State Machine architecture simplifies gameplay flow and future feature additions. 🧩 Modular implementation supports extensibility for abilities, animation events, and gameplay modifiers. The batting system is built around a timing-based minigame that combines player timing, directional aiming, and power control into a single interaction. As a pitch approaches the batter, the player must swing at the correct moment while clicking and dragging the mouse to determine both the direction and power of the hit. The timing of the swing, combined with the player\u0026rsquo;s input and the pitch location, determines the resulting trajectory of the ball.\nTo calculate the final hit, the system uses two custom algorithms that determine the launch angle and travel distance. These calculations combine the ball\u0026rsquo;s position within the strike zone, player-controlled power and aim, and a controlled amount of randomness to produce varied yet predictable outcomes. This approach rewards player skill while introducing enough controlled randomness to keep batting outcomes varied and prevent gameplay from feeling deterministic.\nInternally, the batting mechanic is implemented as a finite state machine consisting of several gameplay states, including Waiting for Input, Swing Back, Swing Forward, and Idle. Separating the mechanic into distinct states keeps the implementation modular and easier to maintain, while also simplifying the addition of future features such as batting abilities, animation events, or timing modifiers.\nThis architecture allowed the batting system to remain easy to extend throughout development while keeping gameplay logic isolated and readable.\n*Players combine timing, directional aiming, and power control to influence the trajectory of every hit.*\nRunning System # Highlights # 🏃 Direct mouse-controlled baserunning with forward and retreat movement. ⚾ Automatic enforcement of baseball base occupancy and force-play rules. 🔄 Conflict resolution system prevents multiple runners from occupying the same base. 👥 Supports both individual runner control and advancing all eligible baserunners. 🧩 Modular architecture designed to support future mechanics such as stamina and advanced baserunning abilities. The running system provides players with direct control over baserunners through mouse input, allowing them to advance toward the next base or retreat to a previous base at any point during play. The system is designed to give players precise control while automatically enforcing the rules and constraints of baseball.\nA key challenge was managing base occupancy. To ensure only one runner occupies a base at a time, the system models baseball\u0026rsquo;s base occupancy and force-play rules, automatically resolving runner conflicts while ensuring every baserunning decision results in a valid game state. If a player attempts to advance to an occupied base, the runner is redirected to prevent multiple players from stacking on the same base. Conversely, when a force play requires a trailing runner to advance, the occupying runner is automatically moved forward to maintain correct baseball behavior.\nThe running system supports both individual runner movement and advancing all eligible baserunners simultaneously, allowing gameplay logic to respond appropriately to different game situations without duplicating code. By separating these behaviors into reusable systems, additional running mechanics can be introduced without significantly modifying the existing implementation.\nA planned enhancement is a stamina system that limits how long runners can remain between bases. This will discourage players from indefinitely stalling between bases while introducing an additional layer of strategic decision-making during play.\n*Players can direct individual baserunners at any time while the running system automatically enforces baseball rules such as force plays and base occupancy.*\nUpgrade System # Highlights # 🍔 Data-driven item framework using configurable JSON definitions. ⭐ Weighted rarity system with support for unique team-wide items. 🔀 Item merging mechanic that combines compatible upgrades while conserving inventory space. 📡 Event-driven ability system using tagged gameplay events and effect dispatching. 🧩 Modular architecture that allows new upgrades to be added with minimal changes to existing systems. The upgrade system provides players with meaningful progression between innings through a drag-and-drop interface. After each inning, players are presented with a randomized selection of upgrades that can be applied to individual team members. Players select from a variety of food items that provide permanent stat increases, modify gameplay mechanics such as batting zones, or grant conditional abilities that activate during gameplay.\nUpgrade selection is driven by a data-driven item framework. Each item contains configurable properties such as rarity, activation conditions, and unique restrictions. When generating upgrade choices, the system performs weighted rarity selection while ensuring that unique items can only exist once per team. This approach makes it easy to introduce new upgrades or rebalance existing ones without modifying gameplay logic.\nTo encourage long-term progression, compatible upgrades can be merged together. Merging combines two related items into a more powerful version while freeing an inventory slot, creating meaningful decisions between expanding a player\u0026rsquo;s inventory or strengthening existing abilities.\nDuring gameplay, upgrades are activated through an event-driven system. Gameplay systems broadcast tagged events whenever significant actions occur, such as batting, pitching, or baserunning. The Upgrade Manager listens for these events, identifies any matching upgrades on the relevant player or across the entire team, and dispatches the appropriate effect through a lookup map. By separating event detection from effect execution, new upgrades can be added by defining their data and implementing their behavior without requiring changes to the core gameplay systems.\nThis architecture keeps the upgrade framework modular, extensible, and easy to maintain while supporting a growing library of unique player abilities.\n*Between innings, players strengthen their team by selecting upgrades that provide permanent stat increases, gameplay modifications, or unique conditional abilities.*\nSuperlative System # Highlights # 📊 Tracks player performance statistics throughout gameplay. 🏆 Generates personalized end-of-game awards based on recorded statistics. 🔄 Prevents duplicate award recipients by dynamically selecting alternative superlatives. 🎲 Includes randomized fallback awards to handle edge cases and guarantee results. 🧩 Modular architecture allows new statistics and awards to be added independently. The superlative system generates personalized post-game awards that highlight memorable player performances at the conclusion of each match. Throughout gameplay, the system continuously records a wide range of player statistics, including runs scored, upgrades collected, outs recorded, and even more lighthearted metrics such as the number of particles spawned. These statistics are then evaluated to determine which players best fit each available award category.\nTo ensure each award remains meaningful, the system prevents duplicate recipients whenever possible. Once a player has been selected for a superlative, that award category is removed from the remaining selection pool, and the system searches for alternative candidates for subsequent awards. This produces a more varied and engaging end-of-game summary while ensuring multiple players can be recognized for different contributions.\nThe system also includes several fallback mechanisms to guarantee that post-game awards can always be generated. In situations where gameplay statistics do not produce enough unique results, the remaining awards are selected from a pool of randomized superlatives that do not depend on tracked game data. This prevents edge cases from causing duplicate awards or interrupting the end-of-game sequence.\nBy separating statistic collection from award selection, the superlative system is easily extensible. New statistics and award categories can be introduced independently, allowing additional superlatives to be added without modifying the core evaluation logic.\n*At the conclusion of each match, the Superlative System recognizes memorable player performances by generating personalized post-game awards based on tracked gameplay statistics.*\nChallenges \u0026amp; Lessons Learned\nDeveloping Monster League Baseball has taught me as much about game design and software engineering as it has about programming. Throughout the project, I encountered challenges that fundamentally changed how I approach design, planning, and long-term development.\nDesigning for Player Understanding # One of the earliest challenges was realizing that players often struggled to understand the game without direct guidance. During early playtests, I regularly found myself explaining mechanics or coaching players through the first inning. One memorable playtester spent nearly thirty minutes attempting to complete the opening inning without success because the game\u0026rsquo;s mechanics were not communicated clearly enough.\nWatching players become confused instead of engaged reinforced one of the most valuable lessons I have learned as a designer: if players need an explanation, the game is not communicating effectively. Since then, I have continually refined mechanics, visual feedback, and user interactions to make the game understandable at a glance while preserving its strategic depth.\nThe Value of Planning # Before beginning this project, I disliked creating game design documents and often viewed them as unnecessary overhead. Early development reflected that mindset. The project became increasingly directionless, features expanded beyond the team\u0026rsquo;s capacity, and we ultimately missed a major development milestone after spending months without a clear roadmap.\nThat experience completely changed my perspective. Today, I rely on detailed design documentation to establish the game\u0026rsquo;s vision, prioritize development, and communicate ideas with the rest of the team. Having a shared design document has made development significantly more focused while reducing scope creep and uncertainty.\nDesigning for Change # Working on a long-term project has taught me that both code and game design inevitably evolve. Decisions that seemed reasonable early in development often became limitations months later as the project grew and new features were introduced.\nThis experience has encouraged me to write more modular, maintainable systems that are easier to extend without disrupting existing gameplay. It has also changed how I approach design decisions. Rather than becoming attached to individual mechanics, I now evaluate every feature based on whether it improves the overall player experience.\nThe batting system is a good example of this mindset. While its core design has remained largely unchanged for many months, continued playtesting has highlighted opportunities to improve readability and player feedback. Although redesigning an established feature can be difficult, I have learned that letting go of existing work in pursuit of a better experience ultimately results in a stronger game.\nTechnologies Used # Unity C# JSON Perforce Shader Graph Visual Studio GIMP Looking Ahead # Monster League Baseball continues to evolve through regular iteration and playtesting. As development progresses, I plan to further expand the game\u0026rsquo;s systems while refining the overall experience.\nCurrent goals include:\n4 Unique Playable Characters, each with distinct abilities and playstyles. 9 Boss Encounters featuring unique mechanics and strategic challenges. 50 Upgrade Items to support a wide variety of player builds. 20 Upgrade Mergers that reward experimentation and long-term progression. Seeded Runs for replaying, sharing, and competing with identical game seeds. An In-Game Almanac documenting lore, player abilities, upgrades, and gameplay mechanics. ","externalUrl":null,"permalink":"/projects/game-development/monster-league-baseball/","section":"Projects","summary":"A baseball roguelike emphasizing modular gameplay systems and data-driven design.","title":"Monster League Baseball","type":"projects"},{"content":"A custom C++ game engine built around modular engine architecture, reusable gameplay systems, and extensible software design.\nOverview # The Slippers Engine is a custom C++ game engine developed to explore engine architecture, gameplay frameworks, and reusable software design. Built on top of a provided graphics framework, the project focused on implementing the systems required to support game development, including object management, scene organization, collision detection, audio, and debugging tools.\nDevelopment began with establishing the engine\u0026rsquo;s core architecture. A modular game object framework was created around reusable behaviors such as updating, rendering, input handling, alarms, and collision detection. These systems provided a flexible foundation for gameplay programming while encouraging code reuse and clear separation of responsibilities.\nThe engine was later expanded with more advanced functionality. The collision system evolved from simple bounding sphere tests to support both axis-aligned and oriented bounding boxes, while terrain support was added to enable larger and more dynamic environments. As part of the project, I also designed and implemented a complete audio framework using OpenAL, adding support for 3D positional audio, environmental reverb, and sound occlusion to create a more immersive gameplay experience.\nThroughout development, I created a variety of debugging tools to improve development efficiency. These included an on-screen logging system with configurable panels, a free camera, collision visualization tools, and time manipulation features for debugging gameplay behavior. To validate the engine and demonstrate its capabilities, a fully playable tank game was developed alongside the engine, serving as both a testbed for new systems and a practical demonstration of the engine\u0026rsquo;s functionality.\nQuick Facts Status Completed Team Size Solo Duration Jan 2025 - Jun 2025 Language C++ Version Control Perforce Platform Windows Documentation Doxygen Technical Highlights # Implemented the core systems that form the foundation of the engine while emphasizing modularity, reusability, and maintainable software design.\n▶ Game Object Framework\n▶ Audio Framework\n▶ Developer Tools\n▶ Challenges \u0026amp; Lessons\nGame Object Framework\nHighlights # Component-style behavior through service subscriptions Modular update, rendering, collision, input, and timer systems Efficient execution using registration-based lists Reusable architecture for gameplay object creation Documentation\nThe Game Object Framework forms the foundation of the engine. Every gameplay object inherits from a common GameObject base class, which in turn derives from a collection of service classes including Updatable, Drawable, Alarmable, Collidable, and Inputable. Rather than every object participating in every engine system by default, objects explicitly register for the services they require. This subscription-based approach reduces unnecessary processing while keeping gameplay code modular and easy to extend.\nEach service is responsible for a specific aspect of gameplay behavior and maintains its own collection of registered objects. During the engine\u0026rsquo;s update loop, each manager iterates only over the objects that have subscribed to its functionality, allowing systems to remain independent while avoiding large monolithic update functions.\nUpdatable # The Updatable service executes once per frame and is responsible for general gameplay logic. Systems such as movement, AI, and object state changes are implemented through this interface, providing a consistent update cycle for gameplay objects.\nDrawable # Rendering is divided into Drawable and Drawable2D services. World objects are rendered through the standard drawable pipeline, while UI and other transparent elements are handled separately through the 2D pipeline. Separating these systems ensures that interface elements are rendered after the 3D scene while avoiding transparency ordering issues.\nAlarmable # The Alarmable service provides built-in timer functionality. Every game object has access to five independent timers that can be scheduled to execute after a specified duration. This allows delayed gameplay events to be implemented without manually tracking elapsed time within update functions.\nCollidable # The collision framework supports multiple bounding volume types, including Bounding Spheres, Axis-Aligned Bounding Boxes (AABB), and Oriented Bounding Boxes (OBB).\nTo improve performance, the engine employs two optimization strategies:\nEvery collision test begins with a fast bounding sphere check before evaluating more expensive collision volumes. Objects register collision pairs, ensuring they are only tested against relevant object types rather than every collidable object in the scene. Together, these optimizations significantly reduce the number and cost of collision calculations performed each frame.\nInputable # The Inputable service uses an event subscription model. Objects register for specific keyboard inputs, indicating whether they should respond to key presses, releases, or both. The input manager dispatches events only to subscribed objects, removing the need for every gameplay object to continuously poll keyboard state each frame.\nBy separating gameplay behaviors into independent services, the Game Object Framework provides a modular and extensible foundation for the engine. New gameplay objects can be created by inheriting only the functionality they require, reducing coupling between systems while making the engine easier to maintain and expand.\n*Inheritance hierarchy of the Game Object Framework, demonstrating how gameplay objects compose reusable engine services through modular base classes.*\nAudio Framework\nHighlights # Custom audio framework built with OpenAL 3D positional audio and listener management Environmental reverb with configurable acoustic spaces Material-based sound occlusion integrated with terrain Documentation\nAudio Demo\nThe Audio Framework was designed and implemented entirely by me using OpenAL. I chose OpenAL because it provided a lightweight, flexible API while supporting advanced features such as 3D positional audio and environmental effects. The system is built around four primary components: the Listener, Sound Sources, Reverb Spaces, and Occlusion. Together, these systems create an immersive audio environment while remaining modular and extensible.\nListener # The Listener represents the player\u0026rsquo;s perspective within the world. Its position and orientation are updated each frame, allowing sounds to be spatialized based on the player\u0026rsquo;s location and viewing direction. This forms the foundation of the engine\u0026rsquo;s 3D audio system and enables other features, such as occlusion and environmental effects, to react naturally as the player moves throughout the scene.\nSound Sources # The engine supports two types of sound sources:\nWorld Space Sources exist within the game world and respond to distance attenuation, spatial positioning, reverb, and occlusion. Listener Space Sources remain relative to the listener, making them ideal for interface sounds and other non-spatial audio. Both source types support playback controls including play, pause, stop, looping, pitch adjustment, and volume control, while sharing a common interface for sound management.\nReverb Spaces # The engine supports configurable Reverb Spaces that simulate different acoustic environments. Reverb volumes can be placed throughout a scene and automatically affect nearby sound sources.\nTo simplify development, several preset environments are included, including:\nSmall Room Studio Concert Hall Cave Cathedral For greater flexibility, custom environments can also be created by configuring properties such as density, diffusion, gain, decay time, and other OpenAL reverb parameters.\nOcclusion # One of the engine\u0026rsquo;s most advanced audio features is its material-based occlusion system.\nWhen a sound source is registered as occludable, the engine performs line-of-sight tests between the source and the listener. Objects registered as Occludable Objects participate in these tests and define the material through which sound travels.\nEach material influences audio differently, with built-in presets such as wood, brick, wool, and dirt affecting the amount of attenuation applied. The system also supports multiple layers of occluding geometry, allowing sound to realistically pass through several walls or obstacles before reaching the listener.\nThe occlusion framework integrates directly with the terrain system, allowing hills and other landscape features to naturally block and dampen sounds without requiring any additional implementation by gameplay code.\nBy separating spatialization, environmental effects, and occlusion into independent systems, the Audio Framework remains modular while supporting realistic and highly configurable audio behavior. New sound types, reverb environments, and material definitions can be introduced without modifying the core audio architecture.\nDeveloper Tools\nHighlights # On-screen logging and customizable debug panels Free camera for scene inspection Collision and geometry visualization Time manipulation for debugging Utility math library for common engine operations Documentation\nTo improve development efficiency, I built a collection of developer tools that simplified debugging and testing throughout the engine\u0026rsquo;s development. These tools provided real-time insight into engine behavior, reduced the time required to diagnose issues, and made it significantly easier to verify new gameplay systems as they were implemented. The toolkit includes an on-screen logging system, customizable debug panels, a free camera, collision visualization, time controls, and a reusable mathematics utility library.\nScreen Logger # The screen logging system provides real-time feedback directly within the game window. Simple log messages can be displayed in the upper-left corner of the screen, while more advanced Debug Panels can be positioned anywhere within the viewport.\nEach panel automatically resizes itself to fit its contents and supports independently configurable background and border colors, allowing related debugging information to be grouped together and quickly identified during development.\n*Multiple developer tools operating simultaneously, including collision visualization, the screen logger, and customizable debug panels used to rapidly diagnose and validate engine behavior.*\nFree Camera # The free camera allows developers to freely navigate scenes independent of gameplay. It proved particularly useful when validating collision volumes, inspecting level geometry, and observing gameplay systems from different perspectives.\nDuring development, the free camera was frequently used alongside the collision visualizer to verify that collision calculations behaved correctly in three-dimensional space.\nCollision Visualization # The collision visualizer provides several methods for inspecting engine geometry in real time. It can display individual points, line segments, and complete collision volumes while allowing each element to be assigned a custom color.\nThis visualization framework was invaluable during the development of the collision system, making it possible to quickly verify collision volumes and identify mathematical errors that would have been difficult to diagnose through code alone.\n*Bounding sphere collision volumes visualized in real time. The engine's debugging tools were used throughout development to verify collision calculations and rapidly identify spatial errors.*\nTime Controls # The engine includes tools for pausing gameplay and advancing execution in a controlled manner. By freezing time, gameplay state can be inspected while stepping through code within the debugger, making it easier to isolate logic errors and validate engine behavior frame by frame.\nMathematics Utilities # Documentation\nThe engine also includes a reusable mathematics utility library containing commonly used helper functions. These utilities simplify development by providing frequently needed operations such as:\nDegree and radian conversion Screen-space to world-space coordinate conversion Fast square root approximation Random floating-point number generation Value clamping Centralizing these functions reduced duplicated code throughout the engine while providing consistent implementations for commonly used mathematical operations.\nTogether, these developer tools significantly improved the speed and reliability of development. Rather than treating debugging as an afterthought, the engine provides dedicated tooling that makes diagnosing problems, validating gameplay systems, and testing new features considerably more efficient.\nChallenges \u0026amp; Lessons\nBuilding the Slippers Engine was my first large-scale software project, spanning approximately 25 weeks of development. More than any previous project, it taught me the importance of designing reusable building blocks rather than focusing solely on individual features. Many of the systems implemented early in development, such as the Game Object Framework and collision architecture, became the foundation upon which every subsequent feature was built. This reinforced the value of investing time in clean architecture before rapidly expanding a project.\nThe project\u0026rsquo;s size also highlighted the importance of documentation. As the engine continued to grow, I made a conscious effort to thoroughly document classes, systems, and their intended usage. This not only made it easier to revisit older code after weeks of development but also reinforced the importance of writing software that is understandable to both others and my future self.\nOne of the most valuable aspects of the project was the opportunity to independently design and architect a major engine system. Choosing to implement an audio framework with OpenAL required researching an unfamiliar library, designing an extensible architecture, and integrating it with existing systems such as collision detection and terrain. It was my first experience taking a system from initial concept through design, implementation, debugging, and refinement.\nFinally, developing the accompanying tank game demonstrated the importance of validating engine features through real gameplay. Every new system was immediately exercised in a practical environment, exposing edge cases and integration issues that would have been difficult to discover through isolated testing alone. This experience reinforced the idea that an engine is only as strong as the applications built with it.\n","externalUrl":null,"permalink":"/projects/software-engineering/slippers-engine/","section":"Projects","summary":"A custom C++ game engine built around modular engine architecture, reusable gameplay systems, and extensible software design.","title":"Slippers Engine","type":"projects"},{"content":" Building the Technology Behind Games # These projects focus on the technical systems that power interactive software. From custom game engines and rendering pipelines to networking, algorithms, and performance optimization, they demonstrate my interest in designing efficient, modular, and maintainable software.\nMany of these projects emphasize low-level programming concepts such as graphics rendering, engine architecture, memory management, networking, mathematics, and reusable software design. Together, they represent my approach to solving complex technical problems while building systems that are scalable, extensible, and easy to maintain.\nProjects # ","externalUrl":null,"permalink":"/projects/software-engineering/","section":"Projects","summary":"","title":"Software Engineering","type":"projects"},{"content":" Designing Engaging Player Experiences # These projects explore the creative side of game development by focusing on gameplay mechanics, player interaction, and systems design. Rather than emphasizing implementation alone, they demonstrate the process of designing experiences that are intuitive, engaging, and rewarding while balancing player choice, progression, and challenge.\nEach project reflects an iterative design process, from prototyping mechanics and refining gameplay loops to evaluating player feedback and improving the overall experience. Together, they showcase my understanding of how thoughtful design and clear communication contribute to creating memorable games.\nProjects # ","externalUrl":null,"permalink":"/projects/game-design/","section":"Projects","summary":"","title":"Game Design","type":"projects"},{"content":"Custom DirectX 11 graphics engine featuring reusable rendering systems, custom HLSL shaders, terrain generation, and real-time rendering techniques.\nOverview # The Graphics Engine is a custom DirectX 11 rendering framework developed to explore modern graphics programming and gain hands-on experience with the real-time rendering pipeline. The project focused on building reusable rendering systems while implementing the graphics techniques required to display and render interactive 3D scenes.\nAt the core of the engine is a flexible Graphics Object framework paired with a collection of custom HLSL vertex and pixel shaders. Together these systems support colored, textured, and illuminated rendering while allowing different rendering techniques to share a common architecture.\nTo further explore graphics programming, the engine also implements terrain generation from height maps, dynamic lighting, fog, mirrors, and a collection of reusable primitive meshes including cubes, spheres, pyramids, planes, and skyboxes.\nQuick Facts Status Completed Team Size Solo Duration Jan 2025 - April 2025 Language C++ \u0026amp; HLSL Version Control Perforce Platform Windows Technical Highlights # Implemented a reusable graphics framework capable of rendering interactive 3D scenes while exploring the major stages of the DirectX 11 rendering pipeline.\n▶ Graphics Object Framework\n▶ Shader Programming\n▶ Terrain Rendering\n▶ Rendering Effects\n▶ Challenges \u0026amp; Lessons\nGraphics Object Framework\nHighlights # Reusable rendering architecture Graphics object abstraction Model and texture management Primitive mesh library The Graphics Object framework separates rendering behavior from scene objects by encapsulating shaders, textures, lighting information, and rendering state within reusable graphics objects. This allows different rendering techniques to share a common interface while minimizing duplicated rendering code.\nTo support rapid scene creation, the engine includes several built-in primitive meshes including cubes, spheres, pyramids, planes, skyboxes, and terrain generated from height maps. Each mesh contains vertex positions, normals, and UV coordinates, allowing them to immediately support textured and lit rendering.\n*Colored cube rendered using a custom HLSL shader. This early rendering test verified vertex transformations, color interpolation, and the DirectX 11 rendering pipeline.*\n*Built-in primitive meshes rendered in wireframe mode. The engine includes reusable geometric models that support textured and lit rendering through a shared graphics framework.*\n*Procedurally generated sphere demonstrating the engine's ability to construct and render geometry through generated vertex and index data.*\nShader Programming\nHighlights # Custom HLSL vertex shaders Custom HLSL pixel shaders Constant buffer management Lighting calculations A major focus of the project was writing custom HLSL shaders to better understand the GPU rendering pipeline. Vertex shaders transform model geometry into screen space while pixel shaders perform texture sampling and lighting calculations to produce the final image.\nShader parameters including transformation matrices, camera information, lighting data, and material properties are passed through DirectX constant buffers each frame, allowing rendering behavior to be dynamically updated during runtime.\nDeveloping these shaders provided valuable experience with how CPU-side rendering code communicates with GPU programs to render interactive 3D scenes.\n*Scene illuminated using custom HLSL lighting shaders, showcasing dynamic light sources and material-based shading.*\nTerrain Rendering\nHighlights # Height map terrain generation Texture mapping Lighting support The terrain renderer generates geometry directly from grayscale height maps, allowing landscapes to be created procedurally while integrating seamlessly into the engine\u0026rsquo;s lighting and rendering systems.\nBecause terrain is treated as another graphics object, it automatically benefits from existing rendering features including textures, lighting, and camera movement.\n*Height map–generated terrain rendered with custom shaders and integrated into the engine's rendering pipeline.*\nRendering Effects\nHighlights # Dynamic lighting Fog Mirror rendering Texture mapping To explore common graphics techniques, the engine implements several real-time rendering effects including dynamic lighting, textured rendering, atmospheric fog, and mirrors. These effects were integrated into the existing rendering architecture rather than implemented as isolated demonstrations, making them reusable across multiple scenes and graphics objects.\n*Atmospheric fog implemented within the pixel shader, allowing distant geometry to gradually blend into the scene and improve depth perception.*\n*Mirror rendering achieved through an additional rendering pass, allowing reflective surfaces to display real-time scene reflections.*\nChallenges \u0026amp; Lessons\nThe Graphics Engine was my first deep exploration into modern graphics programming and the DirectX 11 rendering pipeline. Implementing my own HLSL shaders provided a much stronger understanding of how data moves from CPU-side game objects into GPU programs before finally being transformed into rendered pixels.\nOne of the biggest lessons from the project was the importance of abstraction. Separating graphics objects, models, shaders, and rendering state into reusable systems made it significantly easier to introduce new rendering techniques without rewriting existing code.\n","externalUrl":null,"permalink":"/projects/software-engineering/graphics-engine/","section":"Projects","summary":"A custom DirectX 11 graphics engine featuring reusable rendering systems, custom HLSL shaders, terrain generation, and real-time rendering techniques.","title":"Graphics Engine","type":"projects"},{"content":"Multiplayer game showcasing client-server networking, client-side prediction, dead reckoning, and deterministic replay systems.\nOverview # Omega Race was a networking-focused project centered around extending an existing game with multiplayer capabilities. The primary objective was to implement a client-server architecture while exploring techniques used to improve responsiveness and reduce the effects of network latency.\nBeyond networking, the project also introduced a deterministic replay system capable of recording gameplay as a sequence of commands. This allowed games to be replayed exactly as they occurred, providing a valuable debugging tool while demonstrating the benefits of data-driven game logic.\nQuick Facts Status Completed Team Size Solo Duration April 2025 - Jun 2025 Language C# Version Control Perforce Platform Windows Technical Highlights # Implemented several networking techniques commonly used in multiplayer games while building tools to improve debugging and testing.\n▶ Client-Server Networking\n▶ Prediction Algorithms\n▶ Replay System\n▶ Challenges \u0026amp; Lessons\nClient-Server Networking\nHighlights # Client-server architecture State synchronization Network message serialization The project extends the original game with a client-server networking model, allowing multiple players to participate within the same game session. Player state and gameplay events are synchronized across the network through serialized messages, ensuring all connected clients maintain a consistent view of the game.\nPrediction Algorithms\nHighlights # Client-side prediction Dead reckoning Latency compensation To improve responsiveness under network latency, two prediction techniques were implemented.\nClient-side prediction allows player movement to respond immediately to local input without waiting for confirmation from the server, significantly reducing perceived input delay.\nDead reckoning predicts the future position of remote players using previously received movement information, producing smoother motion while reducing visible network jitter.\nTogether, these techniques create a more responsive multiplayer experience despite the inherent delays of network communication.\nReplay System\nHighlights # Command recording Deterministic playback Data-driven debugging One of the project\u0026rsquo;s most useful tools was a deterministic replay system. Rather than recording video, the engine records gameplay as a sequence of player commands that can later be replayed to reproduce the same game session.\nBecause gameplay logic is data-driven, replay files can be used to reproduce bugs, verify gameplay behavior, and repeatedly test networking changes without requiring live multiplayer sessions.\nChallenges \u0026amp; Lessons\nOmega Race introduced me to many of the challenges unique to multiplayer game development. Unlike single-player gameplay, networking requires balancing responsiveness with consistency while accounting for latency and packet delays.\nImplementing client-side prediction and dead reckoning demonstrated how modern multiplayer games maintain a responsive experience despite imperfect network conditions. Developing the replay system also reinforced the value of deterministic game logic, showing how recording gameplay as commands can simplify debugging and regression testing.\nThis project provided my first practical experience with multiplayer networking and established a foundation for understanding more advanced networking techniques used in modern games.\n","externalUrl":null,"permalink":"/projects/software-engineering/omega-race/","section":"Projects","summary":"A multiplayer game focused on client-server networking, prediction algorithms, and deterministic replay systems.","title":"Omega Race","type":"projects"},{"content":"Multithreaded C++ application using concurrent breadth-first search, atomics, and condition variables to efficiently solve mazes.\nOverview # The Multithreaded Maze Solver explores how concurrent algorithms can accelerate pathfinding by allowing multiple worker threads to search a maze simultaneously. Rather than assigning independent mazes to each thread, every thread collaborates on solving the same maze, coordinating through shared state to detect when a valid solution has been found.\nThe project emphasizes synchronization, concurrent algorithm design, and efficient communication between threads while demonstrating how atomics and condition variables can be used to safely coordinate work across multiple CPU cores.\n|\u0026mdash;|\u0026mdash;| | Status | Completed | | Team Size | Solo | | Duration | Nov 2025 | | Language | C++ | | Version Control | Perforce | | Platform | Windows |\nTechnical Highlights # Implemented a concurrent maze-solving algorithm that combines parallel breadth-first search with lightweight synchronization and deterministic path reconstruction.\n▶ Parallel Breadth-First Search\n▶ Thread Synchronization\n▶ Path Reconstruction\n▶ Challenges \u0026amp; Lessons\nParallel Breadth-First Search\nHighlights # Parallel bidirectional breadth-first search Concurrent exploration from the start and goal Reduced search space through simultaneous traversal Rather than solving the maze from a single starting point, the solver launches two worker threads simultaneously. One thread begins a breadth-first search from the maze entrance while the other begins from the exit. Both threads expand through the maze independently, exploring new cells in parallel.\nBy searching from both ends at the same time, the algorithm reduces the amount of the maze each thread must explore before a solution is found. As the search frontiers grow toward one another, they eventually intersect, allowing the solver to terminate the search and reconstruct the complete path.\nThread Synchronization\nHighlights # Atomic cell ownership Condition variables Race-free communication To safely coordinate concurrent searches, every thread atomically \u0026ldquo;paints\u0026rdquo; each maze cell it visits with its own identifier. This allows ownership of a cell to be established without requiring coarse-grained locks.\nWhen a thread encounters a cell that has already been claimed by another thread, a valid connection between the searches has been discovered. The threads then signal a shared condition variable, allowing all workers to terminate without unnecessary computation while avoiding race conditions.\nThis lightweight synchronization strategy minimizes contention while ensuring thread-safe communication between workers.\nPath Reconstruction\nHighlights # Parent tracking Solution stitching Deterministic reconstruction Each thread maintains a record of the cells it visited during its breadth-first search. Once two searches intersect, the recorded paths from both threads are reconstructed and stitched together at the meeting point to produce a complete solution from the maze\u0026rsquo;s start to its destination.\nSeparating path reconstruction from the search itself simplified synchronization while ensuring the final solution remained deterministic regardless of which threads discovered the intersection.\nChallenges \u0026amp; Lessons\nThis project provided practical experience designing concurrent algorithms beyond simply dividing work across multiple threads. The most significant challenge was balancing parallel performance with safe synchronization while avoiding unnecessary locking that could reduce scalability.\nUsing atomics for cell ownership and condition variables for thread coordination demonstrated how lightweight synchronization primitives can enable efficient communication without introducing excessive contention. The project also reinforced the importance of designing algorithms that naturally parallelize rather than simply executing sequential work on multiple threads.\nOverall, the Multithreaded Maze Solver strengthened my understanding of concurrent programming, synchronization, and algorithm design while providing hands-on experience with writing efficient multithreaded C++ applications.\n","externalUrl":null,"permalink":"/projects/software-engineering/multithreaded-maze-solver/","section":"Projects","summary":"A multithreaded C++ maze solver using concurrent breadth-first search, atomic synchronization, and path reconstruction.","title":"Multithreaded Maze Solver","type":"projects"},{"content":"A custom desktop application inspired by the Pokémon Emerald PC interface, designed to simplify weekly Twitch schedule creation through reusable templates and automated date management.\nOverview # The Hyperoid Schedule Maker is a desktop utility I created for a friend to simplify the process of producing weekly Twitch schedules. Instead of manually editing images every week, the application provides a familiar interface modeled after the Pokémon Emerald PC storage system, allowing schedule information to be updated quickly while maintaining a consistent visual style.\nThe application automates repetitive tasks such as updating dates, scrolling through available options, and previewing schedule changes in real time. By reducing the amount of manual editing required, new schedules can be created much faster while remaining visually consistent.\nAlthough designed for a specific use case, the project demonstrates how software can automate repetitive workflows through a clean, user-friendly interface. Future improvements are planned to further simplify adding new artwork and schedule templates without requiring modifications to the application.\nQuick Facts # Status Archived Team Size Solo Language C# Platform Windows Project Type Productivity Tool Technical Highlights # Recreation of the Pokémon Emerald PC box interface Automatic weekly date generation Scrollable schedule editor Live schedule preview Designed to reduce repetitive content creation tasks Gallery # Schedule Editor # The editor allows schedule information to be updated through a simple interface while preserving the visual style inspired by Pokémon Emerald. Automatic scrolling and date management reduce the amount of repetitive work required each week.\n*The schedule editor allows individual days, activities, and dates to be updated through a simple interface while maintaining a consistent visual style.*\nLive Preview # A real-time preview displays the completed schedule using the selected artwork and updated information before it is exported for use on Twitch.\n*Live preview of the generated schedule, allowing layouts and artwork to be reviewed before exporting.*\nPokémon-Inspired Interface # The application\u0026rsquo;s title screen and interface were recreated to closely match the look and feel of the Pokémon Emerald PC storage system while adapting it for a practical productivity tool.\n*Custom title screen matching the Pokémon Emerald aesthetic and establishing the visual identity of the application.*\nLessons Learned # Although relatively small in scope, this project reinforced the value of building tools that solve real-world problems. Rather than focusing on complex algorithms, the emphasis was on creating an intuitive user experience that eliminated repetitive manual work. It also provided experience recreating the visual style of an existing game while adapting it to serve an entirely different purpose.\n","externalUrl":null,"permalink":"/projects/software-engineering/scheduler/","section":"Projects","summary":"A custom desktop application that streamlines creating Twitch schedules through an interface inspired by Pokémon Emerald.","title":"Hyperoid Schedule Maker","type":"projects"},{"content":"A one-page tabletop role-playing game inspired by classic mystery cartoons, designed to encourage collaborative storytelling and accessible role-playing.\nOverview # Meddlesome Kids is a one-page tabletop role-playing game inspired by mystery cartoons such as Scooby-Doo and minimalist RPGs including Honey Heist and Kaiju Girls. Players take on the roles of a gang of teenage detectives who travel from town to town solving supernatural mysteries—only to uncover the human culprit hiding behind the monster.\nUnlike traditional tabletop RPGs that require lengthy rulebooks, Meddlesome Kids was designed to teach players everything they need to know in just a single page. One player assumes the role of the Mystery Maker, creating suspects, locations, clues, and the hidden villain, while the remaining players work together to investigate the mystery before confronting the culprit in a dramatic final trap.\nThis project marked my first experience designing a tabletop role-playing game and challenged me to communicate complete game systems as clearly and concisely as possible.\nQuick Facts # Status Completed Team Size Solo Duration May 2024 - Jun 2024 Project Type One-Page Tabletop RPG Play itch.io Design Goals # Capture the feeling of classic mystery cartoons in a tabletop format. Create a complete role-playing experience that fits on a single page. Encourage collaborative storytelling between players. Reduce rules overhead so new players can begin playing immediately. Support replayability through randomized mysteries, locations, and characters. Core Mechanics # Players create unique teen detectives by selecting a role, background, quirks, and items before setting out to investigate a mystery. As they gather clues, question suspects, and explore dangerous locations, the Mystery Maker advances the villain\u0026rsquo;s plan through dice rolls.\nThe game culminates in a cooperative final trap, where each player contributes to capturing the disguised villain. The more creative and collaborative the group\u0026rsquo;s plan, the greater their chances of successfully revealing the culprit.\nRandomized tables for monsters, suspects, locations, and stakes ensure that each mystery plays differently while remaining easy to prepare.\nGallery # *The player reference sheet contains everything needed to create a detective, learn the rules, and begin solving mysteries within minutes.*\n*The Mystery Maker sheet provides randomized prompts for creating unique mysteries, suspects, monsters, and story hooks while guiding the game's narrative.*\n*A companion reference sheet provides Mystery Makers with additional guidance, including player role explanations, optional gameplay systems, and advice for running the game's climactic finale.*\nLessons Learned # Designing Meddlesome Kids taught me that simplicity is often the hardest design challenge. Fitting an entire tabletop role-playing game onto a single page required careful iteration, prioritization, and clear communication. Every mechanic had to justify its inclusion, and every rule had to be concise enough for players to learn quickly without sacrificing meaningful decision making or opportunities for creative storytelling.\n","externalUrl":null,"permalink":"/projects/game-design/meddlesome-kids/","section":"Projects","summary":"A one-page tabletop role-playing game inspired by Scooby-Doo that focuses on collaborative mystery solving and narrative-driven gameplay.","title":"Meddlesome Kids","type":"projects"},{"content":"A competitive two-player game that blends push-your-luck mechanics with strategic resource management, rewarding players who know when to take risks and when to play it safe.\nOverview # Night 20\u0026rsquo;s is a competitive two-player game inspired by push-your-luck games such as Chicken and the risk management found in Blackjack. Players take turns rolling a twenty-sided die in an attempt to finish with more points than their opponent. However, every additional roll comes with increasing risk—a roll of either 1 or 20 immediately ends the game.\nBetween rolls, players earn points that can be spent on temporary advantages for themselves or disadvantages for their opponent. Deciding whether to invest points into improving future rolls or continue chasing a higher score creates meaningful strategic decisions throughout every match.\nI was responsible for both the game\u0026rsquo;s programming and overall design, focusing on creating a simple ruleset that encouraged tense decision making and frequent player interaction.\nQuick Facts # Status Completed Role Designer \u0026amp; Programmer Team Size 4 Developers Duration Mar 2024 Project Type Competitive Strategy Game Engine Unity Language C# Platform HTML5 Play itch.io Design Goals # Create a simple game centered around meaningful risk-versus-reward decisions. Encourage interaction by allowing players to directly influence each other\u0026rsquo;s rolls. Reward strategic resource management instead of relying solely on luck. Keep matches short while maintaining replayability. Core Mechanics # Players accumulate points by rolling a twenty-sided die, but every additional roll risks instantly ending the game. Rather than spending points immediately, players must decide whether to save them for future turns or purchase temporary modifiers.\nPlayers can spend points to increase or decrease upcoming rolls, force advantage or disadvantage, or simply hold their current score and challenge their opponent to surpass it. These mechanics create opportunities to bluff, pressure opponents, and weigh short-term gains against long-term strategy.\nGallery # *The title screen introduces the game's tabletop-inspired presentation and immediately communicates its focus on twenty-sided dice and strategic competition.*\n*Players balance their current score against the temptation to roll again while spending points on buffs, debuffs, and dice modifiers to influence the outcome of future turns.*\n*Strategic abilities such as Advantage and Disadvantage introduce additional layers of decision making by allowing players to manipulate probability at the cost of valuable points.*\n*The in-game rules explain each purchasable ability, allowing players to quickly understand the strategic options available before every match.*\nLessons Learned # Designing Night 20\u0026rsquo;s reinforced how a small set of mechanics can produce surprisingly deep gameplay. By combining a straightforward push-your-luck system with resource management and player interaction, I was able to create meaningful decisions without introducing unnecessary complexity. The project also highlighted the importance of balancing probabilities, pacing, and player agency to ensure that every match remained competitive while still feeling unpredictable.\n","externalUrl":null,"permalink":"/projects/game-design/night-twenty/","section":"Projects","summary":"A competitive two-player push-your-luck game where players manage risk, probability, and strategic power-ups to outscore their opponent.","title":"Night 20's","type":"projects"},{"content":"A local multiplayer arena game where weapon variety and customizable match rules create fast-paced and unpredictable Roomba battles.\nOverview # Roombo Royale is a local multiplayer arena game developed as part of a team project. Players control weaponized Roombas and compete using three unique weapons: a knife for high-damage close combat, a mace for sweeping area attacks, and a gun for ranged engagements. Each weapon encourages a different playstyle, allowing players to adapt their strategy throughout a match.\nMy primary role on the project was gameplay programming and user interface development. The feature I was most proud of was the customizable match settings system, which allowed players to modify gameplay rules before each match. By exposing settings such as movement speed, damage, and health, players could create unique game modes ranging from fast-paced Hyper Speed matches to tense Sudden Death battles.\nIn addition to gameplay customization, I implemented several user interface elements, including dynamic battery health bars that transition from green to yellow, red, and finally black as players lose health, providing immediate visual feedback during combat.\nQuick Facts # Status Completed Role Gameplay Programmer Team Size 5 Developers Duration April 2025 - Jun 2025 Engine Unity Language C# Platform HTML5 Play itch.io Programming Contributions # Three distinct weapon systems with unique gameplay roles Fully customizable match settings Dynamic battery health UI Modular gameplay parameters supporting custom game modes Local multiplayer gameplay Gallery # *Roombo Royale's title screen introduces the game's lighthearted, competitive atmosphere while establishing its visual identity.*\n*Players battle using three distinct weapon types; a knife for close-range damage, a mace for sweeping attacks, and a gun for ranged combat—each encouraging different playstyles and strategies.*\n*Multiple arena layouts create different combat scenarios and encourage players to continually adapt their positioning and tactics throughout each match.*\n*Fast-paced close-quarters encounters highlight the dynamic battery health system, providing players with immediate visual feedback as damage is taken during combat.*\nLessons Learned # Working on a team project reinforced the importance of building gameplay systems that are both modular and configurable. Creating a flexible match settings system demonstrated how exposing gameplay variables can dramatically increase replayability without requiring additional game mechanics. It also provided valuable experience collaborating with designers and artists while developing features that integrated cleanly into the rest of the game.\n","externalUrl":null,"permalink":"/projects/game-development/roombo-royale/","section":"Projects","summary":"A local multiplayer Roomba fighting game featuring customizable match settings, multiple weapon types, and dynamic gameplay modifiers.","title":"Roombo Royale","type":"projects"},{"content":"A simulation game where players help clients find housing by balancing budgets, preferences, and landlord requirements through dialogue and decision making.\nOverview # Housing Hero is a simulation game where players take on the role of a Chicago housing specialist responsible for matching clients with apartments that best fit their needs. Every client has unique preferences and circumstances, requiring players to weigh affordability, location, amenities, and personal requirements before recommending a property.\nOnce a suitable apartment has been selected, players must communicate with landlords to address any concerns and negotiate on behalf of their clients. Successfully balancing both the client\u0026rsquo;s needs and the landlord\u0026rsquo;s requirements is key to securing housing.\nMy primary contribution focused on gameplay programming and user interface systems. The feature I was most proud of was the dynamic texting conversation system. Messages are created and removed as they scroll on and off screen while automatically repositioning the remaining conversation, allowing long discussions to remain efficient without sacrificing a natural messaging interface.\nQuick Facts # Status Completed Role Gameplay Programmer Team Size 4 Developers Duration Nov 2025 Engine Unity Language C# Platform HTML5 Play itch.io Technical Highlights # Dynamic scrolling conversation system Automatic loading and unloading of chat messages Responsive message alignment and layout Data-driven client and apartment information Decision-based gameplay and dialogue Gallery # *Players compare multiple housing options by balancing apartment features, pricing, and client preferences before recommending the best fit.*\n*After selecting a property, players communicate with landlords through a dynamic messaging system that automatically loads, unloads, and repositions messages as conversations grow.*\n*Each completed playthrough summarizes how successfully players matched clients with housing, encouraging thoughtful decision making throughout the game.*\nLessons Learned # Housing Hero gave me valuable experience building user interface systems that manage large amounts of dynamic content. Designing the scrolling conversation window reinforced the importance of separating presentation from data, allowing messages to be created, removed, and repositioned efficiently as conversations changed. It also highlighted how thoughtful UI design can make complex gameplay systems feel intuitive and approachable for players.\n","externalUrl":null,"permalink":"/projects/game-development/housing-hero/","section":"Projects","summary":"A simulation game where players match clients with suitable housing while balancing budgets, landlord requirements, and client needs.","title":"Housing Hero","type":"projects"},{"content":"An educational game that uses interactive gameplay to teach players about the tragic story of the Radium Girls and the dangers they unknowingly faced.\nOverview # Painting Dials is an educational game inspired by the story of the Radium Girls, factory workers who painted glow-in-the-dark watch dials using radium-based paint during the early twentieth century. Players take on the role of one of these workers, repeatedly painting watch numbers while following the same dangerous practices that were expected in the workplace.\nThe game challenges players to balance speed and accuracy while earning as much money as possible before the effects of prolonged radium exposure become fatal. As the player continues working, visual cues gradually communicate the progression of radiation poisoning, reinforcing the long-term consequences of actions that initially appear harmless.\nRather than simply presenting historical information, the goal was to use gameplay mechanics to create empathy and help players better understand the difficult conditions these workers endured.\nQuick Facts # Status Completed Team Size Solo Duration Nov 2025 Project Type Educational Game Engine Unity Language C# Platform HTML5 Play itch.io Design Goals # Teach players about the history of the Radium Girls through interactive gameplay. Use gameplay mechanics to reinforce historical events rather than relying solely on written exposition. Create empathy by having players experience the repetitive work and difficult choices faced by dial painters. Balance educational messaging with an engaging gameplay loop. Core Gameplay # Players repeatedly dip their brush into radium paint, prepare the brush using the historically accurate lip-pointing technique, and carefully paint watch dials before time runs out. Completing watches earns money, encouraging players to continue working despite the increasing health risks.\nAs more radium is ingested, visual feedback gradually communicates the effects of radiation poisoning, ultimately leading to the player\u0026rsquo;s death. The ending screen then provides historical context, connecting the player\u0026rsquo;s experience to the real lives of the Radium Girls.\nGallery # *The title screen introduces the game's minimalist presentation while emphasizing its educational focus and historical subject matter.*\n*The tutorial teaches the complete painting process, including the historically accurate practice of pointing brushes with the lips before painting watch dials.*\n*Players race against time to complete as many watch faces as possible while unknowingly exposing themselves to increasing amounts of radium in pursuit of higher earnings.*\n*After the player's death, the game explains the historical consequences suffered by the Radium Girls, connecting the gameplay experience to the real events that inspired it.*\nLessons Learned # Painting Dials demonstrated how game mechanics can communicate ideas more effectively than exposition alone. Designing the gameplay around repetitive work, financial incentives, and gradual health deterioration helped reinforce the historical narrative through player interaction rather than simply telling the story. The project strengthened my understanding of using mechanics to support educational goals while creating meaningful player experiences.\n","externalUrl":null,"permalink":"/projects/game-design/painting-dials/","section":"Projects","summary":"An educational game that explores the story of the Radium Girls by placing players in the role of a dial painter.","title":"Painting Dials","type":"projects"},{"content":"A recreation of Atari\u0026rsquo;s classic arcade game developed to explore object-oriented design patterns through a complete game implementation.\nOverview # Centipede is a recreation of Atari\u0026rsquo;s classic arcade game developed as an exercise in object-oriented software design. While the gameplay closely follows the original, the primary goal of the project was to gain practical experience implementing software design patterns within a complete game.\nBy recreating a familiar game, I was able to focus on building clean, maintainable systems rather than designing new gameplay mechanics. Throughout development, I applied multiple design patterns to organize gameplay systems, reduce coupling between objects, and create code that was modular, reusable, and easy to extend.\nQuick Facts # Status Completed Team Size Solo Duration Sep 2024 - Nov 2024 Language C++ Platform Windows Design Patterns # Factory Pattern — Centralized the creation of game objects, simplifying entity spawning and reducing coupling between gameplay systems. Observer Pattern — Allowed game systems to react to gameplay events without creating direct dependencies between objects. State Machine — Organized gameplay logic into clearly defined states, simplifying enemy behavior and game flow. Command Pattern — Encapsulated player actions into reusable command objects, making input handling modular and extensible. Flyweight Pattern — Reduced memory usage by sharing common data between similar game objects instead of duplicating resources. Gallery # *A faithful recreation of Atari's classic Centipede, providing a complete gameplay framework for experimenting with software architecture and object-oriented design.*\nLessons Learned # This project demonstrated the value of software design patterns beyond textbook examples. Implementing Factory, Observer, State Machine, Command, and Flyweight patterns within a complete game provided practical experience applying object-oriented principles to real gameplay systems. It reinforced the importance of designing software that is modular, maintainable, and easy to extend while showing how thoughtful architecture can simplify complex interactions between game objects.\n","externalUrl":null,"permalink":"/projects/game-development/centipede/","section":"Projects","summary":"A recreation of Atari’s classic Centipede built to explore object-oriented design patterns through a complete game implementation.","title":"Centipede","type":"projects"},{"content":"Hi! I\u0026rsquo;m Lucas Wall, a software engineer and gameplay programmer with a passion for building games from the ground up. I enjoy tackling technical challenges ranging from gameplay systems and engine architecture to graphics programming and networking, with a focus on writing clean, reusable, and maintainable code.\nMany of the projects featured throughout this portfolio reflect that interest. From developing a custom C++ game engine and DirectX 11 graphics framework to building multiplayer networking systems and creating Monster League Baseball, I enjoy exploring both the technical foundations that power games and the gameplay experiences they create.\nOutside of personal projects, I teach programming to elementary and middle school students using platforms such as Minecraft Education Edition, LEGO robotics, and Python. Teaching has strengthened my ability to communicate technical ideas clearly while encouraging curiosity and problem solving in young programmers.\nWhen I\u0026rsquo;m away from the keyboard, you\u0026rsquo;ll usually find me playing games, spending time with friends, or training in Tae Kwon Do, where I\u0026rsquo;ve earned the rank of third-degree black belt. My favorite games include Celeste and the Kirby series, both of which inspire the kind of polished, approachable gameplay experiences I hope to create myself.\n","externalUrl":null,"permalink":"/about-me/","section":"Home","summary":"","title":"About Me","type":"page"},{"content":"","externalUrl":null,"permalink":"/tags/algorithms/","section":"Tags","summary":"","title":"Algorithms","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/atomics/","section":"Tags","summary":"","title":"Atomics","type":"tags"},{"content":"","externalUrl":null,"permalink":"/authors/","section":"Authors","summary":"","title":"Authors","type":"authors"},{"content":"","externalUrl":null,"permalink":"/tags/c%23/","section":"Tags","summary":"","title":"C#","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/c++/","section":"Tags","summary":"","title":"C++","type":"tags"},{"content":"","externalUrl":null,"permalink":"/categories/","section":"Categories","summary":"","title":"Categories","type":"categories"},{"content":"","externalUrl":null,"permalink":"/tags/client/server/","section":"Tags","summary":"","title":"Client/Server","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/condition-variables/","section":"Tags","summary":"","title":"Condition Variables","type":"tags"},{"content":" Get In Touch # I\u0026rsquo;m always interested in discussing software engineering, gameplay programming, graphics programming, and new opportunities. Whether you have a question about one of my projects or would like to connect professionally, I\u0026rsquo;d be happy to hear from you.\nContact Information # Email\n📧 lucas@studioslippers.org\nResume\n📄 Download Resume Portfolio\nBrowse my projects using the navigation above to learn more about my experience and technical work.\nI typically respond to emails within a day or two.\n","externalUrl":null,"permalink":"/contact/","section":"Home","summary":"","title":"Contact","type":"page"},{"content":"","externalUrl":null,"permalink":"/tags/design-patterns/","section":"Tags","summary":"","title":"Design Patterns","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/desktop-application/","section":"Tags","summary":"","title":"Desktop Application","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/directx-11/","section":"Tags","summary":"","title":"DirectX 11","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/educational-games/","section":"Tags","summary":"","title":"Educational Games","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/engine-architecture/","section":"Tags","summary":"","title":"Engine Architecture","type":"tags"},{"content":"","externalUrl":null,"permalink":"/categories/game-design/","section":"Categories","summary":"","title":"Game Design","type":"categories"},{"content":"","externalUrl":null,"permalink":"/tags/game-design/","section":"Tags","summary":"","title":"Game Design","type":"tags"},{"content":"","externalUrl":null,"permalink":"/categories/game-development/","section":"Categories","summary":"","title":"Game Development","type":"categories"},{"content":"","externalUrl":null,"permalink":"/tags/game-programming/","section":"Tags","summary":"","title":"Game Programming","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/gameplay-programming/","section":"Tags","summary":"","title":"Gameplay Programming","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/hlsl/","section":"Tags","summary":"","title":"HLSL","type":"tags"},{"content":" About Me # I\u0026rsquo;m a gameplay programmer and software engineer passionate about building engaging gameplay systems and maintainable code. I enjoy designing modular architectures, solving technical challenges, and creating games that are intuitive for players while remaining flexible for developers.\nI\u0026rsquo;m always looking for opportunities to expand my skill set. Whether it\u0026rsquo;s implementing a custom audio system in C++, learning networking techniques, or building this portfolio with Hugo and Blowfish, I enjoy exploring new technologies and applying them to real projects.\n","externalUrl":null,"permalink":"/","section":"Home","summary":"","title":"Home","type":"page"},{"content":"","externalUrl":null,"permalink":"/tags/json/","section":"Tags","summary":"","title":"JSON","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/multithreading/","section":"Tags","summary":"","title":"Multithreading","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/networking/","section":"Tags","summary":"","title":"Networking","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/openal/","section":"Tags","summary":"","title":"OpenAL","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/perforce/","section":"Tags","summary":"","title":"Perforce","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/productivity-tool/","section":"Tags","summary":"","title":"Productivity Tool","type":"tags"},{"content":" Projects # Throughout my academic and personal work, I\u0026rsquo;ve developed projects spanning gameplay programming, engine architecture, graphics programming, networking, multithreading, and technical game design.\nThe projects below are organized by discipline. Each category explores a different aspect of software engineering and game development, with individual project pages covering the technical challenges, implementation details, and lessons learned throughout development.\nBrowse the categories below to explore my work.\n","externalUrl":null,"permalink":"/projects/","section":"Projects","summary":"","title":"Projects","type":"projects"},{"content":"You can view my resume below or download a PDF copy.\n📄 Download Resume ","externalUrl":null,"permalink":"/resume/","section":"Home","summary":"","title":"Resume","type":"page"},{"content":"","externalUrl":null,"permalink":"/series/","section":"Series","summary":"","title":"Series","type":"series"},{"content":"","externalUrl":null,"permalink":"/tags/shader-graph/","section":"Tags","summary":"","title":"Shader Graph","type":"tags"},{"content":"","externalUrl":null,"permalink":"/categories/software-engineering/","section":"Categories","summary":"","title":"Software Engineering","type":"categories"},{"content":"","externalUrl":null,"permalink":"/tags/systems-design/","section":"Tags","summary":"","title":"Systems Design","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/tabletop-rpg/","section":"Tags","summary":"","title":"Tabletop RPG","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/","section":"Tags","summary":"","title":"Tags","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/ui/","section":"Tags","summary":"","title":"UI","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/ui-design/","section":"Tags","summary":"","title":"UI Design","type":"tags"},{"content":"","externalUrl":null,"permalink":"/tags/unity/","section":"Tags","summary":"","title":"Unity","type":"tags"}]