My Side Projects

A mix of game-jams, random mechanics, larger prototypes, and even a soon-to-be-released project.

Check them out!

Rogue Cell – Maplelike Games

Absorb, evolve, and conquer in this bite-sized arcade experience.

Rogue Cell is a short and satisfying arcade-like game about evolving your way up the microscopic food chain. You’ll swim through the dynamic primordial soup, absorbing other Cells and Mass, avoiding hazards and defeating stronger Cells, upgrading and evolving on a path to become the biggest and toughest organism.

Note: Rogue Cell is a game set to release in 2025 on Steam, under my own company, Maplelike Games. More information about the project will be posted on the Maplelike Games site.

- Cells use procedural meshes that “deform” based on a variety of criteria, including collision detection with other cells and cell velocity.
- Cells have a large number of variables to tune to control the springiness of the “cell walls” when deforming and recovering.
- Cells can resize dynamically, with a custom LOD-like solution for adjusting vertex count based on cell radius and camera orthographic size.
- Cells use a large set of variables to tune how they “float” through the primordial soup using a steering behaviour, achieving a sense of weight and mass at greater sizes.
- “Prey” cells prioritize collecting mass and will treat larger cells as hazards to steer away from.
- “Predator” cells prioritize the player first, followed by “Prey” cells, followed by mass, in a distance-based scoring algorithm.
- All art, minus UI, is done procedurally through a set of shaders and soft-body scripts.
- All “organic” objects use a shader that allows for cell walls and fluid-like blobs mimicking organelles, which churn and rotate as the cell moves.
- A lot of work was put into the atmosphere and polish, in an attempt to make the environment feel fluid and dynamic, with subtle particles, a shifting background, and giant “shadows” that drift by, using parallax to help give a sense of depth.
- A custom attribute system allows for upgrades to tweak existing values throughout gameplay, including player size, speed, mass-to-DNA conversions, and unlocking a variety of mechanics.
- Upgrades form the game’s main progression, using player cell size as the spine of the upgrade tree.

Maple 2D Framework

Maple 2D is a game framework written in C# using SFML.Net (the official binding for .NET). It is intended to be a “garden project” that I’ll develop over time, and eventually open source.

The current version of the framework is tailored to a PICO-8 inspired style, with 128x128 square aspect ratio rendering and optional letterbox graphics, though I plan to expand the framework to support any resolution.

- Maple2D uses my own take on the Entity Component System approach, separating Entities from Components, but allows Components to act as Systems if desired.
- Entities, much like GameObjects in Unity, can be assigned names, rendering layers, and components, using internal calls to the EntityManager (as entities don’t know what components they have) - this is done for workflow convenience.
- Entities can be destroyed, which will mark the Entity for “death”, and will gracefully handle the notifying and destruction of all attached components.
- Transform omponents allow for a complex hierarchy, and, like all components, are optional.
- A customizable render pipeline allows for “Renderer Features” to be created and injected into various phases of the render pass, which allows for unique shaders that make use of render buffers.
  - Bloom is a render pass that uses the “Final Color Buffer”.
  - Buffer textures can be requested (and modified) by the renderer feature, and passed into shaders during the requested pass.
- Cameras can use render layers as filters for what they can see, and can stack with multiple cameras.
- Scenes can be created as a collection of Entities and Components, as well as rendering details.
- Scenes can be loaded and unloaded at any time, cleaning up any Entities created (and registered) by the scene.
- Maple2D uses a “Canvas” for its UI, inspired by Unity’s Canvas. It is a UI system that features a unique set of CanvasElement components, which include additional information for all components used in UI.
- CanvasElements can resize dynamically when the screen size is adjusted, and can use anchoring to dynamically position as well.
- CanvasElements, much like a Transform component, allow for a complex hierarchy that is compatible with dynamic sizing and positioning.
- CanvaSprite components support 9-slicing of sprites, allowing for resizable panels using a single texture.