Skills Developed

• c++ to blueprints
• pathway algorithms
• landscape algorithms
• UI implementation
• Save & loading system

Link to up-to-date project: Up-to-date build

—Project-In-Progress—

04/03/26

Huge changes to project since November with the main changes being:

• Tighter focus on path generation instead of multiple layers
• All path techniques integrated into project (Perlin Worms, DLA & Cellular Automata)
• Save & loading system implemented to use generated map layouts on demand
• Player character implemented for playtest & exploring generated layouts
• Specific tiles added that trigger the end of a level or move player to next layer of map layout
• Playtest UI and system implemented

Map Generation

Landscape, region and layer generation remains similar to the November build, with the main changes being how the path generation is performed. Can now specify which pathway algorithm is being used as well as its unique parameters. When specified, the layout can then be saved to a data asset file which can then be used for loading and testing.

Island detection & Joining

With the addition of multiple pathway techniques, a problem arose that the algorithms can generate pathways that were non-contiguous and isolated from each other. To fix this, a method of island detection using a flood-fill technique called Breadth-First Search (BFS) was implemented. After islands are detected a method was then employed to join them by:

• calculating the centroids of the islands (noting that this can produce incorrect tiles if the island shape is concave)
• drawing a line between island centroids and returning all grid coords fall within that line (requires converting Even-Q grid coords to cube coords)
• changing these returned tiles into path tiles

Path Generation

Drunkard Walk implementation remains the same but have added the following algorithms:

Perlin Worms

Modifies the Perlin noise function used by generating the landscape into a set amount of user defined “Worms” that create pathways either at random points within the grid or joins these worms together to create a singular pathway. Number, length, frequency and seed parameters can all be adjusted to change the behaviours of these worms. Island detection & joining is applied after generation to ensure valid layout.

Diffuse-Limited Aggregation (DLA)

Employs multiple specific drunkards walks around a starting “Seed” area to generate the pathways. Each walker travels until it comes into contact with a path tile, in which its previous tile becomes a path and the walker dies. Process is repeated until a layout size has been met. 3 types of DLA are implemented:

• Inwards: Walks are performed at random points throughout the map and travels towards the seed area.
• Outward: Walks are performed at random points within the starting seed area towards the map boundaries.
• Central: Similar to Inwards but a line is drawn from walkers starting point to the centre of the map and the walker follows this route.

Cellular Automata

Considers all tiles within a grid as either Path or non-Path. Changes the state of these tiles depending on the states of the surrounding neighbouring tiles. Many rules exist for this type of generation but only two methods are implemented within the project. Currently only considers immediate neighbours (1 tile away) and can progress iteration of generation to produce differing layouts.

• Wolfram codes: system that determines the existing tiles state based on the outcome of its Northwest, Central and Northeast neighbours. A config parameter was added that allows the editor to alter all possible neighbour states (8 combinations) and their resultant state. With this system known wolfram codes can be entered and performed on the current map layout.
• Game of Life: considers all neighbouring tile states to determine the current state according to the number of Path tiles (alive) or non-Path (dead) tiles. This depends on the following adjustable parameters:
  • Death limit: determines number of dead tiles needed to kill central tile if it was alive.
  • Birth limit: determines number of alive tiles needed to make central tile also alive.

Playtesting

UI environment:

In-game environment: For the dissertation side of the project, a build is created that employs a testing environment containing a UI and multiple saved layouts for participants to explore. The goal of the environment is for the player to explore the layout with a controlled character and reach a specified exit tile. Questions about the layouts are then asked of the particpant regarding the nature and suitability of the layout.

Currently this aspect of the project is for internal University use only but may be opened up in the future.

27/11/25

This project will look at the effectiveness of multiple procedural generation technqiues in generating a cave system for isometric games. Goal of project is to create a continuous game map by stacking multiple layers of procedural generated levels.

Link to 27/11/25 build: Demo

The current formation structure:

pathway generation

Uses drunkards walk to generate a path from a designated start point until a specified path size or iteration limit has been met. Iteration ends when path is no longer able to proceed (all surrounding neighbouring tiles have already been visited) or has met path size.

landscape generation

Uses UE defualt perlin noise to adjust all height values of landscape tiles. This can be adjusted by modifying the noise scale and the height multipler which governs the max height of the generation.

Region generaion

Voronoi regions are created by using seed locations planted at random within the grid. TIles calculate and are assigned to the seed location they are closest to. Number of seeds can be adjusted but currently there are only 5 unqiue biomes immplemented.

Level formation

Combining each of the previous techniques generates a map with random characteristics

World formation

Specifying how many layers to generate will perform the level formation for each layer. The result is that each layer will have its own unque properties.

Current development notes

At time of this post, all layered levels will share the same generation parameters (output still random) but will be individually assigned in later builds Perlin noise is currently normalised to give a flat base, this is for testing and will be reverted in future builds. Other notable developments are in the readme of the project files.

Skills Developed

• Creating controller functionality
• Reiterating on past code
• Animation blueprints
• Sound attenuation fields/attributes
• Light attenuation fields/attributes
• Identifying optimization areas

Continuing the project from DES315 my team (Bonny Bandits) have improved upon “Synaptic” during the summer and have showcased our game to the public at the Dundee Contempoary Arts (DCA) building during its annual Drop-in and Play event.

Link to the build used at the event: DCAFinalBuild

Breakdown

Goals

During DARE feedback from the mentors and discussion with the team members it was decided that we would iterate on:

• Retool narrative
• Record new narrative lines
• Redesign playable levels into a more shorter, segemented design
• Adjust target behaviours and add new ones
• Adjust weapon mechanics
• Add controller support

As system programmer for the team my job was to retool the systems to accomodate these proposed changes, starting with the major one:

Level activation

Since the levels where being redesigned into shorter more intense segments the previous target activation system needed to be expanded upon.

Previously, upon activation, the level barriers would query the game world for all objects with the target interface. While this worked for the beta build it was very resource intensive and would not scale well.

targets detected by barrier

To remedy this, the barrier was modified to include an activation volume in which it will query this space for the targets. This allows each level to be split into segments and allows the designer to add/remove as many targets as necessary.

As a consequence of this change, it was found that with the addition of these segments (and the number of targets increased dramatically) performance started to drop. In investigating this problem it was found that it was the number of targets being rendered in the game level were causing the performance issues. To fix this, a spawner object was created that did not render anything in-game. It allowed the designer what target to spawn, when to activate the target and which (when applicable) track for the target to traverse on.

Diary Page unlocks

Another system to iterate on was the diary page unlock system. Previously, a set number of pages to unlock (determined by designer) were assigned to each level and unlocked pages where then signaled to the game mode when the player travels back to the main hub area. For this new segmented design, a singular lore page is unlocked after the end of each shooter segment. This page is then able to be displayed in game when the player interacts with a new object (statue) and also unlocks the entrance to the next area.

Statue in-game

Skills Developed

• Project Management (Jira, gantt chart)
• Cross disciple collaboration
• Data table usage
• Game mode and game mode component creation
• Interaction interfaces
• Blueprint usage
• Protoyping VFX
• UI logic
• Audio narration progression

Link to the beta build: beta build

Breakdown

University group project simulating a studio environment to produce a playable demo with the brief “Fire Walk with Me” A lynchian genre.

Made in UE 5.4 my role was system programmer and was responsible for creating aspects of the game that governed:

• Target behaviour
• Wave formations (target activation)
• Level loading
• Audio narration
• Object Interactions

Skills Developed

• C++ in UE 5
• Exposing C++ code to blueprints
• Niagara VFX systems
• Applying physics to objects
• Skeletal mesh sockets
• UI & input logic
• Weapon state machines

Link to the mechanics project

Third year Uni project that uses UE 5 to create a weapon system that allows the player to pick up available weapons and modify their behavior depending on the location within the players inventory.

The player can drag and drop equipped weapons (in inventory) to change the weapon behavior on the fly and cause additional interactions with the weapons in game.

Skills Developed

• Unity
• C# coding
• Inventory management
• UI logic
• Level logic (timers, level triggers)

—Document-in-Progress—

Game developed during AGDS Freshers Jam 2024
Link to Magnus Library

Key notes

Developed inventory system that governed the addition and sequence of books for each level.

Skills Developed

• Entity Component System (ECC) architecture
• Further C++
• Procedural level generation
• Box 2D usage
• Haptic feedback (Controller)

—Document-in-Progress—

Second year group project developed using university in-house game engine (Skateboard) for the PS5. Recording listed above does not include audio. Project files are unlisted due to NDA.

Keynotes

Developed level progression system that pans camera to new segment of the map when a player reaches the edge threshold. Developed multiple level layouts and a system that randomly picks between them to produce unique games. Developed multiple platform types to add variation within each layout.