In Factorio, every machine has one job: the drill extracts ore, the furnace smelts it, the conveyor delivers the materials, and the assembler builds the product. None of them knows how the entire factory operates—yet together, they form a cohesive production line. Good game architecture functions similarly: each system solves its specific problem and passes the result to its neighbors, and new elements are seamlessly integrated into the chain without breaking it.In this course, you will combine individual features and tasks into a complete gameplay episode, adding progress saving and content variations. Then, as is common in real development, new requirements will emerge for the already functioning mechanics. You will have to decide whether a simple adjustment of settings is sufficient, whether a new component is necessary, or if the underlying connections themselves need to be re-evaluated. You will test every refinement against the game’s existing functionality, ensuring that nothing previously built breaks.

You will learn to implement system interactions, separate configuration from behavioral logic, create variations of mechanics based on a common foundation, and organize C++ modules. You will be able to save the game state, extend the project, refactor code, and verify changes using functional tests and performance metrics.The result is a game prototype featuring reusable systems for interaction, items, objectives, and progress saving. For your defense, you will demonstrate how the project can be expanded with a new mechanic or content variant. The package includes the source code, a system map, connection documentation, and testing results.

For UE developers and game designers with C++ experience who are ready to implement architectural decisions into working systems and develop the project without losing already implemented functionality.

8 weeks, 64 contact academic hours. Classes are in-person: C++ development, laboratory work, code review, testing, and culminating in a prototype defense. Homework is completed as part of the overall project—from initial system integration to final assembly.

Experience in designing game mechanics and implementing systems in C++ within Unreal Engine 5 is required—this could be from a personal small project or comparable practice.

You must be able to design mechanics states and relationships, work with UE5 components, interfaces, and events, implement systems in C++, debug them, and use Git.

To begin work, an architectural diagram and prototypes of the core systems are necessary. Either a personal project or a prepared academic foundation will suffice.

Recommended computer specifications: Windows 11, Intel or AMD processor with 4+ cores and 2.5 GHz, 32 GB of RAM, and a graphics card with 8 GB of video memory supporting DirectX 12.

Additionally, UE5, a compatible C++ development environment, Git, and internet access will be needed. Pre-made resources will be utilized to develop the game episode.

— Implement interaction between game systems in C++. — Externalize mechanics settings into data and create content variations within the core implementation. — Organize project modules and manage dependencies between them. — Coordinate the work of game systems and the interface during state saving and restoration. — Extend and refactor systems to meet new requirements while preserving established behavior. — Test system interactions, reproduce bugs, and evaluate optimization results. — Assemble the game prototype and demonstrate the reusability of its systems.

— A collection of interconnected game systems with standardized interfaces. — A library of game assets and actions, each with individual configuration sets. — A set of C++ modules detailing their integration. — A functional game prototype featuring an interface and progress saving. — An advanced iteration of the project that maintains all previous functionalities. — A suite of tests and comparative performance benchmarks. — A complete prototype, including source code and documentation for system reuse.

SYSTEM INTEGRATION
— Prototype development and initial architecture validation
— Interface and interaction agreement
— Event exchange via delegates
— Object initialization, subscription, and lifecycle management
— Handling of unavailable objects and invalid actionsMECHANIC CONFIGURATION VIA DATA
— Decoupling settings from behavioral logic
— Data Assets and data tables
— Variations in game content across the core implementation
— Configuration validationMODULES AND PROJECT DEVELOPMENT
— Organization of C++ modules and their dependencies
— Public interfaces versus internal implementation
— Component and shared service reuse
— System expansion based on new requirements
— Refactoring while preserving game behaviorMECHANIC INTEGRATION AND PROGRESS SAVING
— Integrating mechanics into the core game loop
— UI updates upon state changes
— Structure of game progress data
— Object identification during state saving and restoration
— Order of restoring related systemsPROJECT TESTING AND BUILD
— Functional and regression testing
— Performance measurement and optimization review
— Gameplay testing and project refinement
— Preparation of the build and documentation for system integration and extension