Projects

Selected programming projects from The Game Assembly, including my Unreal Engine AI specialisation project and several multidisciplinary team projects built in C++, custom engines, Unity, and C#.

Featured project

AI Companion Dog

Unreal Engine 5.5 · Pure C++ · 120 hours · Specialisation Project

For my specialisation project at The Game Assembly, I built a companion dog AI designed to feel more believable than a simple follow system. The goal was to create an AI character that could navigate, search, remember, and choose behaviours in a way that felt alive.

This was also my first Unreal Engine project. Because the assignment was a programming challenge, I avoided relying on Unreal's built-in AI and Blueprint systems as much as possible and implemented the core systems myself in C++.

Download on Itch View source code on GitHub

Hierarchical Pathfinding

Implemented HPA* style navigation by partitioning the world into clusters and reducing the search space compared with basic A*. Spatial lookup helped keep navigation responsive in more complex environments.

Context Steering

Built a movement system that samples directional options and weighs goal alignment, obstacle avoidance, movement momentum, and hazards, resulting in smoother and less robotic movement.

Scent Trail & Memory

Added a scent trail system where the player leaves decaying scent points. When the dog loses sight of the player, it can search through memory rather than simply stopping or snapping back.

Utility-Based Behaviour

Replaced rigid state switching with utility scoring for behaviours such as following, wandering, sniffing, and resting. Hysteresis helped prevent rapid behaviour flickering.

Tactical Minimap

Built a custom minimap/debug view showing player and dog positions, scent strength, behaviour state, and line-of-sight information to make the AI's decision-making visible during development.

Performance Optimization

Used distance-based LOD and update-frequency scaling so expensive AI systems ran only when needed, keeping the project stable at 60fps during continuous AI calculations.

What I learned

This project taught me that believable AI does not come from one complex system, but from several simpler systems interacting well. Pathfinding, steering, memory, utility evaluation, and fallback behaviours all had to work together. I also learned the importance of graceful failure: when pathfinding or a search decision fails, the AI should recover naturally rather than breaking.

Team Game Projects

These projects were developed at The Game Assembly in multidisciplinary teams of around 14–17 people, typically with 5–7 programmers. Each project ran for several weeks and gave me experience working with gameplay, AI, tools, animation, UI, rendering, and production workflows.

Project 8 — Local Multiplayer Arena Brawler

Custom Engine · C++ · Team of 15 · 9 weeks

A Towerfall-inspired split-screen archery brawler. I focused on special arrow mechanics, VFX, collision, and renderer-level debugging.

My main work included a laser/ricochet arrow with bouncing beam behaviour, a bomb arrow with line-of-sight blast checks, shader-driven VFX, per-player aim previews, sphere-sweep collision for fast arrows, homing fixes, and transparent VFX sorting in the deferred renderer.

The biggest challenge was making a very fast projectile bounce, damage along its full trail, and display correctly in split-screen without relying on simple physics-engine movement.

Itch build coming soon · Available for review on request

Project 7 — First-Person Shooter

Custom Engine · C++ · Team of 16 · 12 weeks

A tactical FPS where I focused on enemy AI behaviour and visual scripting integration.

I implemented enemy navigation, combat behaviour, raycast/pathtracing-based movement, obstacle-aware pathfinding, collision avoidance between enemies, and integration with the school's visual scripting framework so designers could modify AI behaviour more easily.

This project taught me how AI systems connect at a lower engine level and how important designer-facing tools are for gameplay iteration.

Project 6 — Diablo-Style Action RPG

Custom Engine · C++ · Team of 16 · 14 weeks

An isometric action RPG where I worked mainly on engine tools and animation systems.

I built the core AnimatedModelComponent, developed editor functionality for object selection and transformation, implemented destructible object logic, fixed editor stability issues, and helped configure the lighting pipeline.

This project showed me how much stability matters in tools programming: artists and designers need editor features that behave predictably every time.

Project 4 — Top-Down Adventure

TGE · C++ · Team of 14 · 8 weeks

An adventure game where I focused on UI systems, menu flow, animation integration, and game state management.

I worked on character and object animation, menu hierarchy, sprite integration, input mapping, mouse cursor functionality, state stack logic, and replacing placeholder UI with final assets.

This project taught me that UI programming is largely about predictable state flow: every interaction needs to be clear, reversible, and robust.

Watch gameplay video

Project 3 — Shape-Shifting Platformer

TGE · C++ · Team of 15 · 10 weeks

A 2D platformer built around shape-shifting mechanics, where I worked on gameplay, animation, health, pickups, and debugging.

I developed the animation handler system, integrated animations for player characters and enemies, implemented health and collectible systems, and contributed to core gameplay features including movement, jumping, and shape-shifting.

The main lesson was that core mechanics need extensible systems, because a feature that starts small can quickly become the foundation for the whole game.

Watch gameplay video

Project 2 — Mobile Puzzle Game

Unity · C# · Team of 14 · 8 weeks

A tile-based mobile puzzle game where I worked on enemy behaviour, camera systems, movement, particle integration, and playtesting.

I programmed monster AI that responds to player movement patterns, implemented dynamic camera zoom/follow behaviour, built tile-based movement with precise positioning, and connected VFX to gameplay events.

This project taught me how mobile constraints such as screen space and input style affect gameplay, UI, and camera design.

Watch gameplay video

Project 1 — Endless Runner

Unity · C# · Team of 13 · 6 weeks

My first team project: a jetpack-powered endless runner where I implemented core gameplay mechanics and audio integration.

I built the jetpack system with fuel management and physics-based movement, added background music and sound effects, programmed basic movement and jumping, and helped polish the game through playtesting.

This project introduced me to team programming and taught me how strongly code structure and communication affect the whole project.

Watch gameplay video

Development progression

Early projects

I started with core gameplay, Unity/C#, basic systems, team workflows, testing, and iteration.

Middle projects

I moved into more complex gameplay, animation, UI, state management, and deliberately tried new technical areas each project.

Later projects

I took on deeper C++ engine work, AI systems, editor tools, visual scripting, rendering issues, and custom-engine production challenges.