Hordes of Hel is a gripping roguelike horde-survivor game set in the dark realms of Norse Mythology.

Fight waves of enemies to earn divine blessings of ancient Viking Deities, explore hostile worlds and face powerful bosses.

Become a god-like warrior in this ultimate showdown.

The game was already in development for a year when I joined and my main responsibility became making sure the enemy AI would navigate towards the player in different environments.

This would involve modifying the existing obstacle avoidance system and adding a flow-field for navigation through difficult terrain using Unity's Burst compiler.

After a couple of months in I was assigned to do the porting of the project to the PS5 in 3 months time.

Quite the task for such a big project, but the codebase already contained legacy code that was made for ports to the PS4, which I could forward to the PS5 calls with some adjustments.

After the release there were still many things that needed to be worked on when it came to porting.

Things like console specific functionality, bugs and both performance and memory optimization would still keep me on porting for a couple more months.

Throughout the project, I became familiar with: Optimization tools that Unity provides; Memory management; uncommon features that the PS5 provides.

Védelem: The Golden Horde is a Real Time Strategy game set in 13th century Eastern Europe.

The Golden Horde is the biggest and deadliest Mongolian invasion that the world has ever seen.

As the last line of defense, you are called to save your lands against the Mongol empire.

They will ruthlessly attempt to pillage your economy and bring your Keep to ruin.

Manage the economy of your Castle, build new structures, find and exploit resources and expand your borders while mustering an army capable of repelling the Mongolian Invasion.

This student project is being made in my 3rd year and utilizes Unity DOTS.

Because of this, we can run a lot of units simultaneously while also holding 60 fps.

My main responsibility on this project was the behavior of the formations and units.

This included the different states they can go in, how to react in certain situations and the combat between formations.

I've also worked on the unit avoidance towards buildings and implemented the command and combat audio.

The main things I've learned from this project are: How AI state machines work; How to handle combat with units in formations ; How to work with experimental code with few documentation; How to work on a project through development phases; How to work in the Unity Engine

The game was awarded for best 3rd year programmed game at our school.

Definitely one of the biggest and complicated system that I’ve ever worked on till now and also the system I’ve been working on most of this project.

How it works is as follows: A formation can engage another formation in 3 conditions: Either by being ordered to attack another formation; Another formation is inside the formation engage radius while the current formation is in Idle State; or the formation is being attacked by another formation while in Idle State.

If the formation starts engaging another formation, it will walk towards the targeted formation until the targeted formation is inside the attack radius.

There are also 3 ways to make a formation stop engaging; The targeted formation lost its last unit; the current formation is ordered to move somewhere else; or the targeted formation is outside of the engage radius and the current formation wasn’t ordered to engage the targeted formation.

That engagement logic is the same for both ranged and melee formations, but after this they split in functionality.

As long as the targeted formation is inside the attack radius, all the archers in a ranged formation will attack as one group at once and they will target a random unit of the other formation to shoot at.

A melee formation works very different, as each melee unit will walk towards the closest enemy unit they can find.

The part where the unit can react to a unit in front of them is done by someone else and we called it Unit Perception.

When a unit finds an enemy unit in front of them, they will start doing damage at a time interval, until the other unit dies or is out of range.

If the formation engages a building the archers will fire towards the building’s location with a slight offset and melee units will walk towards the building's location.

The Unit Sense system will cast rays to see if the unit is in front of the building to start attacking the building until it is destroyed.

Enter the broken mind of Eliza de Moor, a once-celebrated singer, now trapped in the labyrinth of her own forgotten memories.

With the help of a new medicine, will you be able to piece together the mystery of your past?

The game was already made by another studio, but our company was tasked to finish the product so that it could be sold.

this included fixing bugs, optimizing the game to an acceptable amount and porting the game to both the xbox and playstation consoles.

I came halfway through the project and was primarily set to the porting of the game to the PS5 and later fixing bugs and optimization.

One of the challenging parts was that since the game was made entirely using Unreal blueprints and not with callbacks in mind, it became rather difficult to insert the required functionality needed to meet the console specific requirements.

Luckily the game would not be updated outside the company, so events could be added to hook on to.

Throughout this project, I became familiar with: Building a UE5 game for the PS5; Console specific implementations; How to adhere to the guidelines set for a game to be published on the PS5; Optimizing a game inside UE5 using its tools

This project was meant to explore any unknown territory and my focus was pointed towards AI related topics I haven't yet worked on.

The project is divided between two parts: One is creating a pathfinding system using an optimized flowfield, the other one is a crowd movement system using steering behaviours.

The project is made with the Unity Engine and uses DOTS for the systems that runs the agents.

The main things I learned from this project are: How to implement a Flow Field ; How to optimize a Flow Field; How to implement Steering Behaviors ; How to implement Grid Indexing ; How to test agent movement.

Gangstars is a turn-based strategy game focussed on heists.

The goal of the game is to finish missions with the most objectives completed while keeping most of your team alive.

The game was cancelled before being released.

First time working as an intern at a company.

Had the main responsibility over the AI in the game and also worked on some other systems.

Used the Utility-based AI architecture with weights for the decision making of the AI and simulated actions before actually performing them.

The main things I learned from this project are: How to make a Utility-based AI architecture; The usefulness of debugging tools for AI; How to work with C++ inside the Unreal Engine .

In Streamlined Mastermind, the player is in charge of planning bank heists.

With only limited information at the start, they can spend money to gather additional information about the building and guards, acquire better crew members and equipment, and create distractions.

Using this, the player can plan the crew’s actions to navigate them towards the vault and back out again while circumventing the guards. And your plan better be solid, because getting caught is not an option.

This student project took place in my 2nd year and was quite the challenging one.

As it was the first time for me to lead others and it was the first time a project was fully remotely due to the corona virus.

I was more of a general gameplay programmer in this project and was responsible for the process of the game as I was the programming lead.

The main things I've learned from this project are: How to manage things effectively between the group of programmers I led and the other leads; Effective use of flow control to reduce operations and increase performance in Unreal.

The game was awarded for best 2nd year programmed game and best 2nd year designed game at our school.

The player can buy information for the current heist level they’re in.

They can select a certain type of information in a catalogue and buy it if they have enough money.

A card with the level, type and number will spawn when bought and can be picked up.

The information that the player has bought can be placed on the pinboard.

The pinboard shows a blueprint of the current heist level.

When info is bought and placed on the right placeholder, it will show the corresponding info on the blueprint.

Always wanted to create pacman and I wanted to create a project in c++ without the use of an engine, so this was the perfect opportunity to do so.

The project is made with use of the SFML library to take care of the visuals.

The game is almost the same as the original pacman, the only difference is that the AI of the ghost is a bit harsher on the player in that they will try to surround the player to make it easier to catch the player.

This is done by gathering all the cells in the map that contain more than 2 directions characters can move to and finding the cells that are the most close to the player. Then each of the ghost will try to move to any of these cells that are the closest to them, but not the same as the other ghosts. When they've reached that cell they will move towards the location of the player to get the kill.

When the player picks up a power pill, they will try to run as far away from the player, while also trying to keep a certain distance from the other ghosts.

This game is made to resemble the game Raystorm, where the player has to shoot enemy ships while also dodging incoming bullets from the enemy.

This student project took place in my 2nd year and only consisted of programmers.

The goal of this project was to create a reference game in our own custom-made ECS engine.

My main responsibility was the gameplay part of the project, so this includes everything playable.

The main things I've learned from this project are: AI steering behaviors; How to structure code to an ECS; How to work closely with the people who provide systems for you;

As our game has different entities, which move following different sets of rules, I used Steering Behaviors to make the movement off entities look more alive and not so static.

For our game, the main purpose of the steering behavior would be to make the enemies move around in a way that it will look like they're spaceships and move in a certain path.

Also, some of the bullets of the enemies are directed towards the player location.

The steering behaviors that I implemented are Seek, Arrive and Path Following.

Sea of Slaps is a fast paced local multi-player experience in which ships on a rollercoaster must collect a unique coin on the map, hold it and defend it from the adversaries until they reach the required score to win the game.

In a form of a hovering hand on the map, the players can slap each other to stop the hand movements, slap the trains to push them backwards on the railroad or slap the arrows on the junctions to rotate their direction.

While they cannot control the ships directly, they can use all these elements to control their own ships, but also the ships of other players.

This student project took place in my first year and it was also the first time for me making a game in Unreal Engine 4.

The main things I've learned from this project are: How the basics of Unreal works; How to work on a project as a team; How to prioritize important things first.

This portfolio piece will mainly contain descriptions of systems/concepts used.

The main purpose of this project is not a game or simulation, but rather gaining familiarity into advanced coding concepts and understanding their utility.

Heavily inspired by a YouTube channel called git-amend , which provides examples of awesome concepts to try in projects.

Next to that it also serves as a base structure for future projects.

The code of the project is structured into 3 different sections: Core, Systems and Gameplay.

Gameplay depends on Systems, Systems depends on Core, the dependency is enforced by the use of Assemblies

Core: Main purpose is being the base layer for everything else, every project contains this full layer.

Systems: Main purpose is to transform data. Each system works independently of each other and should be able to be excluded from a new project.

Gameplay: Main purpose is game specific logic and would mostly not be taken into new projects.

Own base script which contains specific logic that every script should process.

Hides Unity's default method calls and directs it to custom method calls.

Does not provide an any Update methods unless explicitly added as an interface.

An added helper script throws warning when script do try to implement Unity's default methods calls.

Depending on if the object will be pooled, will not call any enable or disable methods calls if not yet pooled. This avoids logic running when the object is just being pooled.

I'm aware of disabling some features that normal behaviours provide, like making the function async, but I'll either add this later or will use the normal base.

Custom script that handles all update loops and replaces Unity's native call to its Update methods

Any Custom MonoBehaviour containing an update interface automatically registers itself in its respective update list when enabled and unregisters when disabled.

Depends on Unity and my Core modules

Provides interfaces which components can use.

Ideally, the interface is data only, this is to ease the process to transfer the system to use Unity's DOTS when needed.

The main purpose of these systems is to transform data of objects.

Communicates with other systems using the Event Bus.

The following are concepts which the project uses that are copied and altered from git-amend's channel.

Event Bus: Main purpose is to send events without having depending on one another. I use this mainly for independent systems.

Service Locator: Used as an entry point to get single instanced classes

HFSM: To help with AI state navigation, though will replace this with my own due to missing functionality that I want and the desire to create my own.

A system that handles steering and updating the movement of swarming agents. It provides logic that combines multiple forces like seek, avoidance, separation, alignment, and cohesion to drive agent velocity, position, and rotation.

The system iterates registered ISwarmMovable agents, finds neighbors, computes a weighted desired velocity from each enabled movement force, clamps steering by acceleration, updates position, and rotates the agent toward travel direction. The interface ISwarmMovable defines the state the system needs, including movement limits, target data, neighbor lists, and force configuration.