A modern C++ application that demonstrates layered game architecture, modular gameplay systems and reusable engine integration.
Pong is built as an application layer on top of EngineSFMLBackend and EngineInterface, showcasing how gameplay systems can remain independent from rendering and platform technologies. Rather than embedding engine functionality directly into gameplay code, the project organises states, scenes, AI, physics and match management into modular systems that leverage reusable engine services through clean architectural boundaries.
The project focuses on software engineering rather than game complexity, demonstrating how a simple game can be structured using scalable architecture, separation of concerns and reusable application frameworks.
Many small games evolve into tightly coupled applications where gameplay, rendering, input handling and framework code become intertwined. As projects grow, this coupling makes features more difficult to extend, test and maintain.
Pong addresses this challenge by separating gameplay systems from engine implementation. The application builds upon reusable engine abstractions provided by EngineSFMLBackend and EngineInterface, allowing gameplay logic, state management and AI systems to evolve independently of the underlying rendering and platform technologies.
The application is organised into modular gameplay layers responsible for state management, scene composition, gameplay systems and supporting utilities. Beneath the application layer, EngineSFMLBackend and EngineInterface are integrated as Git submodules, providing reusable engine services while remaining separate from gameplay implementation.
The project was designed to demonstrate:
- Modular gameplay architecture
- Layered application design
- Separation of gameplay and engine systems
- State-driven application flow
- Reusable gameplay components
- AI integration
- Scalable application structure
Although demonstrated through a Pong implementation, these engineering principles are transferable to larger game projects, simulation software and other interactive C++ applications.
- Layered gameplay architecture built on reusable engine modules
- Modular application states and scene management
- Human and AI-controlled gameplay
- Reusable collision and physics systems
- Match management and scoring systems
- Git submodule integration with EngineSFMLBackend and EngineInterface
- Extensible architecture supporting additional gameplay modes and features
- C++20
- SFML 3
- Visual Studio 2022
- Git
- Git Submodules
- Layered Architecture
- Modular Gameplay Systems
- Separation of Concerns
- State-Driven Design
- Scene Management
- Artificial Intelligence
- Object-Oriented Design
- Composition
- Reusable Components
- Engine Integration
- Gameplay systems isolated from rendering implementation
- State and scene driven application architecture
- Modular AI, physics and match management
- Reusable gameplay components
- Clean separation between application, engine and backend layers
- EngineSFMLBackend and EngineInterface integrated as reusable submodules
Pong demonstrates how a modern C++ application can be developed on top of a reusable engine architecture while maintaining clear separation between gameplay and engine functionality.
By building upon EngineSFMLBackend and EngineInterface, the application focuses entirely on gameplay systems, AI, physics and user interaction while relying on reusable engine services for rendering, input and platform functionality. This layered approach improves maintainability, encourages code reuse and provides a scalable foundation for larger game projects.