A Modular 2D Platformer Built on a Reusable C++ Engine
Super Mario Clone is a modern C++ platforming application built using Engine Interface and the SFML Engine Backend. Rather than focusing on recreating a complete commercial game, the project reimplements the platform simulation systems originally developed for the AI Game Controller project within a reusable engine architecture.
The project serves as both a standalone platforming application and the foundation for the next generation of the AI Game Controller, allowing autonomous agents to be integrated as reusable modules rather than remaining tightly coupled to a single application.
The Engineering Problem
The original AI Game Controller combined platform simulation and artificial intelligence within the same project, making the gameplay environment difficult to reuse independently of the AI systems.
Super Mario Clone addresses this by rebuilding the platform simulation as a dedicated application layer above the reusable engine architecture. The challenge is to create a modular platforming framework that cleanly separates gameplay mechanics, world simulation, physics, animation and scene management from future AI implementations.
This separation allows intelligent controllers to be attached to the project without modifying the core platform systems while also allowing the platform simulation to evolve independently from the AI architecture.
My Role
I designed and implemented the platforming framework, developing the gameplay systems, player controller, physics, collision handling, animation systems, world management and application architecture that operate above the Engine Interface and SFML Engine Backend projects.
I am also establishing the architectural foundation for the redevelopment of the AI Game Controller as a reusable module. Once complete, this module will interact with the platform simulation through clearly defined interfaces rather than depending directly on application-specific classes.
The project remains under active development, with the current focus placed on rebuilding and validating the platform simulation before integrating the revised artificial intelligence systems.
Gameplay Demonstration
Title
Description.
Title
Description.
Title
Description.
Architecture Overview
Super Mario Clone forms the application layer of the wider architecture, consuming reusable services provided by the SFML Engine Backend through contracts defined by Engine Interface.
The application separates platform simulation into focused systems responsible for world management, character behaviour, physics, animation and gameplay logic while remaining independent from rendering and backend implementation.
The future AI Game Controller will be attached as an optional module above these systems, allowing autonomous controllers to observe the simulation, evaluate gameplay conditions and provide character input without becoming part of the platform implementation itself.
Core Gameplay Systems
The application is organised into three focused areas that combine reusable engine services with platform-specific behaviour. Each area maintains clear ownership of its responsibilities while supporting a modular simulation suitable for future AI integration.
World & Scene Management
Manages application states, gameplay scenes, level construction and object lifecycles. World systems organise terrain, entities, cameras and environmental objects while remaining independent from rendering, platform simulation and framework-specific services.
Platform Simulation
Implements character movement, gravity, jumping, collision detection/response and world interactions. Platform systems manage physics integration, grounded states and movement behaviour while remaining independent from rendering, scene management and animations.
Character & Animation Systems
Implements player state management, sprite animation, input-driven behaviour and gameplay feedback. Character systems coordinate animation, movement and interaction while remaining independent from world management, platform simulation and rendering services.
Together, these systems create a reusable platforming framework while preserving the architectural separation between gameplay logic, reusable engine services and backend implementation.
Engineering Principles
| Principle | Application |
| Separation of Concerns | Platform simulation, rendering, input, animation, world management and future AI behaviour are implemented as distinct responsibilities rather than being combined inside individual gameplay classes. |
| Dependency Inversion | Application systems depend on contracts provided by Engine Interface rather than directly depending on SFML or backend-specific implementations. |
| Modular Architecture | Gameplay, engine integration and future AI functionality are organised as independent modules that can evolve without requiring widespread changes across the codebase. |
| Single Responsibility | Focused systems manage specific behaviours such as movement, collision response, animation, level organisation and character control. |
| Reusable Engine Integration | Rendering, input, resources, timing and other framework services are consumed from the SFML Engine Backend rather than being recreated inside the application. |
| Interface-Driven Development | Stable interfaces define how application systems access engine services and will later define how AI controllers observe and interact with the platform simulation. |
| Composition Over Coupling | Gameplay behaviour is constructed by combining focused systems and components rather than relying on tightly coupled inheritance hierarchies or monolithic game objects. |
| Extensibility | The architecture is designed to support additional levels, character behaviours, environmental objects and controller implementations without restructuring the entire application. |
| Testable Simulation Design | Separating simulation behaviour from rendering and direct input dependencies creates opportunities to test movement, physics and AI decisions independently. |
| Incremental Development | The platform simulation is being rebuilt and validated first, allowing the revised AI Game Controller to be introduced once the gameplay environment provides stable interaction contracts. |
Key Design Decisions
Platform Simulation as a Standalone Application
The platforming systems are implemented independently of the AI Game Controller, allowing the gameplay environment to evolve separately while providing a reusable foundation for future autonomous agents.
Layered Engine Architecture
Gameplay systems remain within the application project while rendering, input, audio, resources and shared framework services continue to reside within the reusable engine layers.
Modular Character Systems
Movement, animation, collision handling and gameplay behaviour are implemented as focused systems with clearly defined responsibilities, reducing coupling between simulation components.
Shared Controller Interface
Character behaviour is being structured so that human input and future AI-generated input can operate through the same control pathway. This prevents AI behaviour from requiring a separate character implementation.
Future AI Integration
The application is designed so that intelligent controllers can later be introduced as interchangeable modules, enabling the AI Game Controller to become a reusable component rather than a standalone application.
Simulation Before Intelligence
The platform environment is being completed before the AI controller is rewritten. This ensures that the AI module will be designed against stable gameplay systems and clearly defined simulation data rather than inheriting the coupling of the original implementation.
Technologies
Development
C++ 20
Visual Studio 2022
Git
Git Submodules
Engineering Approach
Layered Architecture
Collision Management
Modular Gameplay Architecture
State-Driven Design
Scene Composition
Object Orientated Design
Platform Physics
Animation Systems
Modular Artificial Intelligence Integration
Separation of Concerns
Interface-Driven Development
Reusable Engine Integration
Development Roadmap
Platform Simulation
Reimplement and validate the movement, jumping, gravity, collision and environmental interaction systems previously contained within the AI Game Controller project.
Gameplay Framework
Develop the application states, scenes, world systems, character systems and animation architecture required to support a complete platform simulation.
Controller Abstraction
Establish a consistent control interface that can receive commands from human input, scripted behaviour or autonomous agents.
AI Game Controller Module
Rewrite the AI Game Controller as an independent submodule that can observe the platform environment, evaluate possible actions and control a character through the shared controller interface.
Integrated AI Platformer
Combine the completed platform simulation and modular AI controller to recreate and extend the functionality demonstrated by the original AI Game Controller project.
Engineering Outcome
Super Mario Clone demonstrates the ongoing development of a reusable platforming framework built upon a backend-agnostic C++ engine architecture.
By separating platform simulation from artificial intelligence, the project establishes a maintainable foundation that can support future gameplay features while enabling the AI Game Controller to be reintroduced as a reusable module rather than an application-specific implementation.
Although the project remains in development, its architecture already represents an important evolution from the original implementation. Platform mechanics, engine functionality and autonomous control are being divided into independent layers, creating a clearer and more extensible foundation for the completed system.
Application Gallery
Repository
Explore the source code to see how the architectural principles are implemented throughout the framework.
