Die O'live

Die O’live was created for the 10-day GameDev.tv Game Jam 2025. The game follows an olive that must survive waves of insects before being eaten down to the pip.

The project was built in Unreal Engine using the PaperZD plugin, exploring 2D gameplay implementations inspired by games such as Octopath Traveler. Core mechanics include 8-directional movement, dodging, and twin-stick shooting and melee attacks using cocktail sticks.

The game features three enemy types that spawn in escalating waves. All programming and all art assets (with the exception of the health icons) were created by me within the 10-day jam period.

Available Here

Flush Royale

Flush Royale is a turn-based poker deck-building roguelike developed in Unity, built around the idea of combining poker mechanics with tactical, wizard-themed combat and answers the question of what wizard gambling could look like.

The game features a fully functional poker phase, including an AI opponent that evaluates its hand strength and plays accordingly. Alongside this, the combat phase is built on a pointy-top hex grid, with custom movement logic for both ground and flying units.

In addition to programming, I have created original art, unit animations, and mixed music utilising the Dorian mode in FL Studio to support the game’s theme and atmosphere. While the project is still in development, it currently serves as a sandbox for experimenting with poker-driven mechanics, AI behaviour, and grid-based combat systems.

Happy Hippo Café

The Happy Hippo Café is a PSX-style horror game developed in Unreal Engine, inspired by childhood memories of The Rainforest Café and games such as Five Nights at Freddy’s.

The project includes custom textures and a hippo animatronic model created by me in Blender. From a programming perspective, the hippo enemy is driven by a behaviour tree that handles idle, search, and chase states, transitioning into a capture animation when the player is caught.

The game also features vents the player can crawl through and parkour-based challenges required to collect items and escape, with all gameplay systems implemented using Unreal Engine’s Blueprint system.

Vehicle Zombie Demo

This project is a third-person arcade prototype developed in Unity, focused on building and integrating multiple physics-based gameplay systems.

I implemented a custom player controller using a Rigidbody and raycast-based hover system, designed to give movement an arcade feel while remaining stable over uneven terrain. The controller separates ground and air acceleration and calculates jump velocity dynamically to ensure a consistent jump height.

The vehicle system is an arcade-style car controller built around per-wheel raycasts for suspension, steering, and acceleration. I extended a tutorial foundation into a more modular system by replacing linear acceleration with a torque-based engine driven by an animation curve, implementing per-wheel slip-cancelling forces, and improving suspension using real displacement values. The car supports rear-wheel drive by distributing engine force only to grounded rear wheels, with the code structured to allow other drivetrains to be added later.

The player can enter and exit vehicles via trigger volumes, with player controls and camera behaviour transitioning dynamically to avoid controller conflicts.

To add gameplay pressure and test performance, I implemented a swarm-based enemy system inspired by games like Vampire Survivors and Megabonk. Enemies use simple Rigidbody movement and steering behaviours instead of NavMesh, allowing large numbers of zombies to move, fall, and collide naturally. A separation force prevents clustering, while a central spawner manages enemy counts and spawn locations. Each enemy reports its own death back to the spawner to keep the system modular and scalable.

This project primarily serves as a technical sandbox for experimenting with physics-based movement, vehicle systems, and performance-conscious AI behaviour, with an emphasis on modular code and iterative tuning through playtesting.

Procedural Dungeon Generator

This project is a procedural dungeon generation system developed in Unity, designed to explore different approaches to generating readable and varied dungeon layouts.

I began by implementing a random walk algorithm to generate organically shaped rooms. Floor tiles are placed based on the walk path, with walls automatically generated around the resulting floor area to visualise the space. I then added a corridor system that detects dead ends and spawns rooms at corridor endpoints, ensuring that corridors always lead somewhere meaningful. Corridors are dynamically widened from one tile to two tiles by adding neighbouring cells based on corridor direction.

To improve layout readability and reduce overly messy generation, I implemented a binary space partitioning (BSP) algorithm. The dungeon space is recursively divided into sub-regions using random horizontal and vertical splits, while enforcing minimum width and height constraints. Rooms are generated within these regions to ensure consistent spacing and prevent overlap.

Rooms are connected using a centre-based pathfinding approach that links each room to the nearest unconnected room while avoiding redundant connections and loops. This ensures all rooms are reachable while keeping corridor paths efficient and logical.

Throughout development, generation parameters such as room size, walk length, and split constraints were exposed using serialized fields, allowing rapid iteration and tuning directly within the Unity editor.