Unreal Engine on Maceage's Blog

Completing My Unreal Engine Course

Sun, 07 Dec 2025 00:00:00 +0000

After what feels like an eternity, I have finally reached the end of my Game Programming Foundations course that I started back in March!

I can honestly say it has been an absolutely incredible journey, and I’ve met some amazing people along the way.

The Journey

When I first started, I was nervous about the course and unsure if I would be able to keep up. Those nerves turned out to be unfounded – but it certainly wasn’t all smooth sailing.

Unreal Engine: Miscellaneous

Wed, 05 Nov 2025 00:00:00 +0000

After learning all about testing and profiling, the final week of my Game Programming Foundations course was a capstone - exploring various aspects of Unreal Engine development that hadn’t been covered in earlier lessons, or needed consolidation: the Environment Query System (EQS), Data Tables (again), Networking and Multiplayer, and Online Subsystems and Services.

Notes below – and fair warning, this is the longest and most fragmented of the series.

Setting Up Tantrumn

The course started with a practical project: building from the Tantrumn source (Unreal’s third-person reference character).

Unreal Engine: Testing and Profiling

Wed, 29 Oct 2025 00:00:00 +0000

After last week’s state machines, this week was about testing and profiling: the [Automation Test Framework]https://dev.epicgames.com/documentation/unreal-engine/automation-test-framework-in-unreal-engine, functional and unit testing, and performance analysis with Unreal Insights – the discipline that keeps everything built so far from quietly rotting.

Notes below.

Automated Testing

The starting questions: what can go wrong, and what do you test to build your test cases?

The motivating example from the course: a third-person stealth game whose core feature is AI perception. You want to guarantee AI sight always works. But with a large world and many levels containing spawners, testing a change by playing through the entire game is tedious – so you set up tests to make sure the major feature isn’t broken.

Unreal Engine: State Machines

Wed, 22 Oct 2025 00:00:00 +0000

This week followed on from the AI fundamentals and dove into state machines – the design pattern that gives AI behaviour its structure .

For future reference, the example project for this week’s content was committed and uploaded here:

sawnoff-studios/state-machine-demo

Introduction to State Machines

A state machine is a design pattern that allows an object to change behaviour based on its internal state: distinct behaviours (states) with explicit rules for switching between them.

Unreal Engine: Introduction to AI

Wed, 15 Oct 2025 00:00:00 +0000

After last week’s deeper dive into game effects, this week was AI fundamentals: AI Characters, AI Controllers, and the Navigation System (NavMesh) – the three pillars of making entities that can think, move, and collide.

Rather than re-invent the wheel, I took advantage of the existing codebases and examples from the course and uploaded them to the following repositories for future reference:

Notes below.

The Key Elements of AI

AI Character – the entity in the game world. Humanoids typically derive from the Character class (getting movement, health, collision); non-humanoids (drones, tanks) from Pawn
AI Controller – the “brain” for AI actors (move, attack). Distinct from the AI Character and exists separately – the same controller/pawn split the player side has had since the controllers week
Navigation System (NavMesh) – AI characters rely on the NavMesh to understand traversable space and calculate paths from A to B

What the split buys you

Delegation of tasks: the controller issues commands (move to this location), the character executes them
Separation of awareness: the character physically exists in the world; the controller handles high-level decision-making
Classic example: an AI guard patrols an area → the guard “sees” the player → the controller abandons patrolling and chases

Adding the NavMesh

Place a NavMeshBoundsVolume (Volumes section) to designate the nav mesh area - the volume acts as a container for the NavMesh
Paths are built automatically from the geometry inside the volume; green areas are walkable surfaces
Walls, stairs, and uneven terrain are all taken into account
View it by pressing P, or the Show Navigation console command

View modes and debugging

A RecastNavMesh actor is created automatically when the NavMesh is added – this does the actual generation work. Useful view modes on it:

Unreal Engine: Game Effects

Wed, 08 Oct 2025 00:00:00 +0000

After covering the complex but incredibly powerful Gameplay Ability System last week, this week revisited game effects – a deeper look at Niagara Systems, Niagara Emitters, Sound Effects, and MetaSounds.

Niagara VFX

Niagara VFX is the primary tool for particle effects in modern Unreal, using both CPU and GPU resources. C++ manages graphics libraries, threads, and system resources, while procedures and tasks are grouped in Niagara Emitters. Each Niagara System can run and manage multiple Niagara Emitters.

Unreal Engine: Gameplay Ability System

Wed, 01 Oct 2025 00:00:00 +0000

Last week was inventory systems; this week, the Gameplay Ability System (GAS) – the framework that gives designers and artists a way to compose abilities, effects, and attributes without writing bespoke code for every interaction.

GAS is famously one of the more complex systems in Unreal – the course eased into it with a well-known example: the Half-Life gravity gun. The gun has the ability to lift; the wooden crate has the ability to be lifted – a target→source relationship.

Unreal Engine: Inventory Systems

Wed, 24 Sep 2025 00:00:00 +0000

Following on from last week’s deep dive into character movement, this week was inventory systems and their implementation in Unreal Engine.

I’ll be honest: I didn’t think it was worth the time creating a dedicated repository for this week’s work, since the exercise was more about interface patterns than persistent gameplay code.

Notes below – and like the mathematics week, much of this content draws more heavily than usual from the course material itself.

Unreal Engine Design Patterns

Tue, 16 Sep 2025 00:00:00 +0000

This post isn’t from the Game Programming Foundations course itself, but from my own reading alongside it – notes taken while reading Game Development Patterns with Unreal Engine 5 – Stuart Butler & Tom Oliver, a tour of design patterns as they apply specifically to Unreal Engine.

Anti-Pattern Problems (and Their Solutions)

The Moving Box Problem

Naive: check every tick whether the box has arrived at its location
Better: a Timeline lerping between two locations – more performant, no per-tick comparison needed

The Rotating Box Problem

Unreal Engine: Character Movement

Wed, 27 Aug 2025 00:00:00 +0000

With last week’s visual and audio effects wrapped up, this week was all about how players actually move: the Character Movement Component (CMC) – the machinery that’s been quietly doing all my movement work since week two – and the Mover Plugin, the experimental system slated to eventually replace it.

There’s also a link to a repository demonstrating the practical half of the week: implementing wall-running.

Commits for this week:

Character animation demo repository: sawnoff-studios/character-animation-demo
Wall-running demo: sawnoff-studios/wall-running-character-demo

Notes below – with the caveat that much of this week’s content is drawn more heavily than usual from the course material itself.

Unreal Engine: Visual and Audio Effects

Wed, 20 Aug 2025 00:00:00 +0000

While last week covered animation and animation montages, this week was juice: the legacy Cascade particle system and its successor Niagara, sounds, sound cues and MetaSounds, camera shake, post-process effects, and force feedback.

Updates were committed to sawnoff-studios/niagara-system-demo as I followed along – notes below.

Cascade (Legacy Particle System)

Add via the Add button → Add Feature or Content Pack → Miscellaneous → Cascade Particle System (Legacy)
Open a particle effect and enable/disable modules via checkboxes
Worth learning a little anyway: concepts carry across to Niagara

Cascade to Niagara Converter

The plugin can convert Cascade systems, but results are generally error-prone
Warnings on opening (e.g. scale being off); it can attempt to automatically fix issues

Niagara Emitters

Emitters are like blueprint nodes – modular, reusable components – and unlike Cascade, you can access them individually
Create an Emitter and pick a template to start from

Selecting and configuring properties:

Unreal Engine: Animation and Montages

Wed, 06 Aug 2025 00:00:00 +0000

Last week was UI; this week, animation – and it’s a big one: input controls, skeletal meshes, animation graphs, jumping, blend spaces, montages, sockets, notifies, aim offsets, and finally shooting.

This was the first week when everything from the series so far converges into something that actually resembles a game.

Heads up for anyone following the links: this week a new repository was started for the second project, since the course moved on from the first:

Unreal Engine: User Interface

Wed, 30 Jul 2025 00:00:00 +0000

Last week was collision; this week, User Interfaces – covering both the legacy Slate framework and the newer UMG (Unreal Motion Graphics) system.

Given my prior experience with Windows Forms and WPF in the .NET world, there wasn’t a huge amount of genuinely new learning here. Most of it was mapping familiar concepts onto Unreal’s equivalents – so this post is shorter and sparser than usual, and mostly serves as a reference to myself of where things live.

Unreal Engine: Collision Detection

Wed, 23 Jul 2025 00:00:00 +0000

Last week was all about how objects communicate; this week, quite possibly the most important topic in game development: collision. Types, custom channels, visualising, debugging, and detection.

As ever, my changes were committed to the repository as I followed along, with my notes below.

sawnoff-studios/first-project

Collision Types

Every component’s Collision Preset (Details panel, right side) determines how it interacts with everything else. Conceptually it’s like a Venn diagram of three responses:

Unreal Engine: Communication

Wed, 16 Jul 2025 00:00:00 +0000

After covering the common mathematics and equations that underpins game development, this week was back into Unreal Engine proper – this time to learn the various ways objects talk to each other. Casting, interfaces, and event dispatchers/delegates turned out to be one of those topics where the choice of mechanism matters as much as the mechanics themselves, because each one trades flexibility against coupling.

As ever, I’ve been committing changes to the repository as I follow along:

Unreal Engine: Mathematics for Games

Wed, 09 Jul 2025 00:00:00 +0000

Last week I covered actors, components, and blueprints, and this week was a slight divergence away from Unreal Engine itself.

If, like me, your relationship with vectors ended at school maths lessons, this week was a rude awakening in the best possible way. Nearly every gameplay behaviour - knowing whether an enemy is behind you, where a grenade lands, how high a jump goes - reduces to a handful of operations on vectors.

Unreal Engine: Actors, Components, and Blueprints

Wed, 02 Jul 2025 00:00:00 +0000

Following on from controllers and game modes, this week was about actors, components, and blueprints – the object model that underpins basically everything in Unreal.

As ever, I’ve been committing changes to the repository as I go – notes below.

sawnoff-studios/first-project

Game Objects: Renderable and Non-Renderable

Not everything in a level is something you can see. Useful mental split:

Renderable: enemies, players, pick-ups, props, projectiles, scenery
Non-renderable: waypoints, volumes, triggers, sounds

Inheritance vs Composition

Inheritance (“is a”):

Unreal Engine: Controllers and Game Modes

Wed, 25 Jun 2025 00:00:00 +0000

Following on from last week’s introduction to the Unreal editor, this week was all about controllers and game modes – how Unreal decides what the player is, where they spawn, and how input reaches the pawn.

As I’ve been following along with the course, I’ve been committing changes to the repository as I go, so you can see the state of the project at each stage of the series:

sawnoff-studios/first-project

Here are my notes from this week’s content.

Meeting my Unreal Engine mentor

Wed, 18 Jun 2025 00:00:00 +0000

This week marked a milestone in my Game Programming Foundations course at CG Spectrum: my first mentorship session with Firas Hosn, who leads the Unreal Engine modules.

Having worked at Silicon Knights, Ubisoft, Build A Rocket Boy, and Splash Damage across AAA titles like Call of Duty, Watch Dogs, Far Cry, Splinter Cell, and Too Human, Firas brings decades of experience to the virtual classroom.

Going into the meeting, I’ll admit I was a little starstruck – but I’d also prepared a notebook full of questions about Unreal Engine versions, Blueprints versus C++, and how large-scale games actually get built.

Unreal Engine: Introduction to Unreal

Wed, 18 Jun 2025 00:00:00 +0000

Following on from the C++ portion of my course, it’s time to dive into the world of Unreal Engine. This week’s focus was on getting familiar with the engine’s interface and understanding its core concepts.

Here are my notes from watching the content for the first week of Game Programming Foundations.

Getting Started with the Editor

The F key focuses the camera on your selected object – essential for navigating big levels quickly
The Outliner panel shows every object currently loaded in your level
You can replace the default map and set it as your startup map (found in Project Settings → Maps & Modes)
World origin sits at 0,0,0 - good to know when placing objects
Unreal’s units are in centimeters, not meters
Hold Left Alt + drag to duplicate objects in the viewport
Dragging objects onto others in the Outliner assigns parent-child relationships

Setting Up Git LFS

Unreal’s asset files (*.uasset, *.umap) are large binaries that’ll break regular Git repos fast. You need Git LFS:

Delving into C++

Sun, 11 May 2025 00:00:00 +0000

As mentioned previously, a prerequisite of the CG Spectrum Game Programming Foundations course is a basic understanding of the C++ programming language.

My programming experience has mostly been with higher-level languages. I started with Visual Basic before moving on to Java and then C#.

Of those, I’ve always found C# particularly intuitive, but I’ve also wanted to learn C++ for a long time.

Since I already had a solid understanding of the core principles, I saw little value in taking extensive notes on concepts I was already familiar with, and instead committed code to:

Learning Unreal Engine

Fri, 28 Feb 2025 00:00:00 +0000

From my early days of using computers, starting with the green-screened Amstrad CPC-464, followed by the vivid colour graphics of the Amiga 500, portable playability of the Nintendo Gameboy, sheer joy of the local player-enabled Super Nintendo Entertainment System and then the many complexities of a 486 desktop PC, video games have always held a special place in my heart.

As a lifelong gamer I’ve always been curious about this form of software entertainment and the experiences they provide for millions. With more and more video games having the graphical fidelity of blockbuster movies, I’ve always had a deep interest in wanting to know how they work under-the-hood.