Modular Engine Systems
Separated rendering, input, combat, animation, state management, and persistence into organized systems for easier maintenance.
Game Engine Architecture Project
Modular 2D RPG Engine
A custom 2D RPG engine built with C#, MonoGame, XML, and xUnit, focused on modular systems for rendering, input, animation, combat, persistence, and content editing.
- C#
- MonoGame
- xUnit.net
- XML
- WinForms
Context & purpose
Project overview
This project is a custom 2D RPG engine built to explore C# software architecture through rendering, input, state management, combat, animation, persistence, and tooling.
The codebase grew beyond 10,000 lines and became a long-running exercise in modular design, refactoring, testing, and maintaining reusable systems across iterative development cycles.
It also includes a WinForms editor that improved content creation efficiency and provided experience building tools around a larger application.
From Input to Rendered Gameplay
Engine Flow
The engine processes player input, updates game state, handles combat and animation logic, then renders the updated scene through MonoGame.
- Input
Capture keyboard and player controls.
- Update
Apply game logic and state changes.
- Combat
Resolve attacks, collisions, and interactions.
- Animate
Update sprite frames and movement states.
- Render
Draw the updated scene through MonoGame.
- Input
Capture keyboard and player controls.
- Update
Apply game logic and state changes.
- Combat
Resolve attacks, collisions, and interactions.
- Animate
Update sprite frames and movement states.
- Render
Draw the updated scene through MonoGame.
Engine functionality
Key features
Custom Combat Logic
Built reusable combat components for attacks, player actions, hit detection, and enemy interactions.
Animation System
Created sprite animation handling for character movement, directional animation states, and reusable animated objects.
Save / Load Persistence
Used XML-based persistence to store and reload game data across play sessions.
WinForms Editor Tool
Developed a companion editor tool to speed up content creation and reduce manual configuration work.
Unit Testing
Used xUnit tests to validate core systems and reduce regressions during iterative development.
Interface preview
Application screenshots
Architecture & implementation
Technical highlights
MonoGame Rendering
Used MonoGame to render 2D gameplay scenes, sprites, shapes, and user interface elements.
C# Engine Architecture
Organized the codebase into separate systems for rendering, input, animation, combat, state management, and persistence.
XML Data Persistence
Used XML to store structured game data and support save/load workflows.
Geometry & Collision Logic
Implemented reusable shape and collision logic for gameplay objects, attacks, and interaction checks.
WinForms Tooling
Built a desktop editor utility to support faster content creation and reduce repetitive setup work.
xUnit Testing
Added unit tests around core systems to improve reliability during ongoing refactoring and feature development.
Problem solving
Challenges & solutions
- Managing Engine Complexity:As the project grew, keeping rendering, input, combat, animation, and persistence organized required breaking the code into smaller reusable systems.
- Building Reusable Game Systems:Creating systems that worked across different gameplay objects helped me better understand abstraction, composition, and object-oriented design.
- Improving Content Creation:Manually configuring game data became time-consuming, so I built a WinForms editor tool to make content setup faster and more consistent.
Planned enhancements
Future improvements
- 01Expand map editor features
- 02Add more enemy behaviors
- 03Improve combat balancing
- 04Add inventory and quest systems
- 05Improve asset loading pipeline
- 06Package playable demo
Continue exploring
Explore moreengineering projects.
Browse additional full-stack applications, production websites, and software projects covering APIs, databases, testing, deployment, and maintainable system design.
Back to projects