Frameworks and tools
we build our games with.
Notes on the internal frameworks and tooling developed at ITPex: the tile-based game framework used by our puzzle and action games, and the supervised gameplay testing tools used to record and replay deterministic simulations.
Supervised Gameplay Testing
A set of custom tools for recording, replaying and inspecting complex gameplay scenarios under controlled conditions.
Games are particularly challenging to test because their behavior depends not only on which events occur, but also on when they occur. Input, network messages, physics and internal game systems can all generate events concurrently during the simulation.
The testing system addresses this by recording events together with their position in the simulation timeline, allowing a previously captured gameplay situation to be reproduced under controlled conditions.
- Events could be recorded at different abstraction levels. Device inputs and network messages could be captured directly, but the resulting game-level events could also be recorded independently.
- Events retained their original simulation timing. Replaying a session did not simply execute the events as fast as possible. They were injected at the same points in the simulation timeline in which they had originally occurred.
- Higher-level gameplay events could be tested directly. Instead of reproducing every input that caused a character to move, a test could replay the resulting command to move the character from one tile to another.
- The same infrastructure supported different testing scenarios. Depending on what needed to be investigated, a test could reproduce the original inputs or work at a higher level of the gameplay system.
A gameplay situation could be recorded once and subsequently reproduced whenever needed, making it possible to investigate problems, verify fixes and compare behavior across different versions of the game.
Testing interface
The tools included a dedicated interface for managing the recorded simulations. Testers could browse the available scenarios, inspect their stored descriptions and launch a selected simulation.
When a test was started, the appropriate game scene was loaded and the recorded session was automatically reproduced, allowing the tester to observe the same gameplay sequence under controlled conditions.
Tile-Based Game Framework
The reusable framework behind Fizzle Fighters, Buccaneer's Booty and the games currently in development.
The framework grew out of the synchronization work on Exploders and Fizzle Fighters. It provides a common representation for tile-based gameplay, so that different games can share the same simulation model, synchronization layer and testing infrastructure.
Games built on the framework describe their world as a grid of cells, and their logic as deterministic actions performed on those cells. This makes the simulation reproducible across clients and straightforward to record and replay.
Logical and visual position
For grid-based gameplay, the framework does not treat the rendered position of a character as its gameplay state. A character can be visually moving between cells while the synchronization layer still considers it to be at a specific logical position.
This distinction is particularly useful for collision detection and other gameplay calculations, which can operate on discrete, authoritative cell positions rather than on the exact rendered position of the character.
Confirmation and shadow
When the server confirms the movement, the logical position advances to the new cell. The visual movement, however, may still be in progress.
The framework therefore keeps the previous logical position as a shadow. This provides the synchronization layer with both the current authoritative state and the state from which the current transition began.
Most collision calculations can operate directly on the logical position. Other calculations can use a combination of the current logical position and the previous logical position represented by the shadow. This keeps gameplay calculations discrete and predictable while the visual representation remains continuous.
Interpolation
Authoritative confirmations arrive as discrete network events, but rendering happens continuously. The framework can therefore interpolate between successive confirmed positions instead of moving the character directly from one confirmed cell to the next.
The network determines the states that must be reached, while the client controls how those states are presented visually.
A deeper look at the multiplayer frameworks behind our games, including synchronization, networking architecture and reusable systems.