On the Bubble

Creating a custom engine for a Monkey Ball-like game

About this project

On the Bubble is an ambitious student project where me and 12 developers are working on creating a Monkey ball-inspired game. To achieve this, we're building the game from scratch using a custom engine. This engine uses pathtracing for stunning visuals and custom physics for precise and responsive gameplay. Additionally, we're implementing a user-friendly level editor, allowing players to create and share their own levels seamlessly.

Once our project reaches a playable state, we plan to release it on Steam as an Early Access title. During this phase, we'll actively gather feedback from our community to improve and refine the game. Our goal is to deliver a fun and polished experience for the full release.

This is a student project made during my 3rd year at Breda University of Applied Sciences.

My contributions to the project

During this project, I mostly worked on developing the engine. My biggest contributions will be listed below:

GameObject management: Implementing the systems required for creating, removing and updating game objects. These GameObjects are stored in the ObjectManager, which updates all objects in the level and manages their lifetime. Game objects are the base class for all objects in the engine that can be used in the game. All game objects can have models, which, when loaded, are properly represented in the renderer as well.

Custom iterators: In order to make looping over all GameObject easy, a custom iterator has been implemented. The iterator is similar in usage to the one used by the Standard Library functions and is compatible with range-based for loops.

Pointer stability: While developing the GameObject manager, pointer stability was taken into account. GameObjects are stored in a vector using unique pointers.

Custom serialization/deserialization: A custom serialization/deserialization system has been implemented. Level saving and loading is used in the game for switching between the levels, as well as saving and loading levels in the editor. I've spent a lot of thought and work into making the serialization/deserialization API as easy to use. The result of this is that only one function is required (per object type) to serialize/deserialize specific variables.
Some more details about the serialization/deserialization system can be seen below.

Saving and loading variables using one function: Variables can easily be marked as serializable using one function call. This function handles both the saving and loading of the data when a level is either saved or loaded from disk. The decision was made to handle both this functionality in one function in order to make it as easy as possible to save and load data. It also turned into a great learning opportunity, as I learned more about template metaprogramming and creating an easy-to-use serializer.

Factory class: When deserializing, objects are created through a factory class. Object types are stored as a string in the save file, which is used to create the correct object type during the deserialization phase. The object factory uses the string to create a new object pointer, which is then stored in the ObjectManager.

Great integration into GameObject systems: The serialization/deserialization system was implemented at the same time as the GameObject management, which means that the two systems work very well together.

This screenshot is taken from an early gameplay demo. The level that can be seen in the image was loaded from a save file.

FileIO: I implemented the functionality for creating, deleting, reading and writing files on both Windows and PS5.

Cross-platform API: Since Windows and the PS5 use different APIs for manipulating files, two different implementations are required. I implemented the cross-platform API, as well as the different implementations for both platforms. The cross-platform API allows users to use the same functions to manipulate files on both platforms. This was a great learning opportunity, as I learned how to work with the file system on PS5.

Level files saved to common directory: On Windows, level files are saved to the common Appdata directory. This is especially useful during Windows development, as it allows for easy sharing of level save files between different configurations.

Level management: I implemented the functionality for loading and switching between levels.

Automatic unloading of unused assets: When switching between levels, the level system compares the required assets between the two levels and check what assets need to be loaded and which ones can be unloaded. This is done to minimize the memory usage over time.

A screenshot demonstrating some of the tools in the engine.

Launch parameters: I added support for launch parameters, which are used during debugging, as well as by our automatic CI/CD system.

Easy to use: Users can easily check if a launch command is passed into the program by using the Contains function. If the launch command is found, values can be retrieved using the GetInt , GetFloat and GetString functions. These functions return the values belonging to the launch commands (if they can be found).

Cross-platform: Launch parameters work on both Windows and the PS5.

More details about these contributions can be found below.

A screenshot of an early render of a level.

This project is still in-development so more features might be added in the future.

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Quick overview

Project Type: Custom Game Engine

Platform: Windows (Steam), PS5

Tools: C++

Role in Team: Engine Programmer and Lead

Project Duration: 1 year

Release Date: Q2 2024

Team size: 13

Role in Team: Engine programmer and Lead

Coming soon!

On the Bubble will soon be released on Steam and on GitHub as an open-source project.