Available now for junior gameplay and AI programmer roles

RobbeHijzen

Gameplay & AI programmer

I graduated from Breda University of Applied Sciences with a Master in Game Technology in 2026, where my research benchmarked five NPC behavior architectures with up to 2,000 AI pedestrians in Unreal Engine 5.7. I program gameplay and AI in C++, from enemy behaviors to custom navmeshes.

Live A* pathfinding. Move your pointer to set the goal.Live A* pathfinding. Tap to set the goal.

0 nodes expandedpath cost 0.0

Projects

My Master's research, team games built in Unreal Engine, and personal projects where I go deeper into AI and engine code. Open any project for the full breakdown of what I built.

Master's research

NPC Behavior Architectures at Crowd Scale

I built five NPC behavior architectures in C++ in Unreal Engine 5.7 and measured how each one performs with up to 2,000 pedestrians in Epic's City Sample.

Type
Master's research, BUas
Engine
Unreal Engine 5.7, C++
Crowd size
100 to 2,000 NPCs
Test runs
750, fully automated
  • The Behavior Tree had the fastest AI tick, but the State Tree gave the best frame rate
  • Below 500 NPCs, the choice of architecture made no measurable difference to frame rate
  • Utility AI needed 462 ms of AI time per frame for 2,000 NPCs with complex behavior, far too slow for crowds

Team projects

My Pet Cthulhu

A fast-paced speedrun game where you help Cthulhu escape the Tamagotchi he is trapped in.

Role
Gameplay & AI programmer
Engine
Unreal Engine 5.5, C++
Team
5 people
Time
3 months
  • A custom 3D voxel-based navmesh that the Boowy enemy uses for pathfinding
  • AI behaviors for the game's enemies
  • Player movement and the game loop

TimTim

Couch co-op wave survival for two players. Hold out against 20 waves of alien invaders.

Role
Gameplay & AI programmer
Engine
Unreal Engine 5.3, C++
Team
5 people, 3 months

Drift Shop

Drift a shopping cart through the aisles, grab everything on the list and reach checkout without crashing.

Role
Gameplay programmer
Engine
Unreal Engine 5.2, Blueprints
Team
6 people, 3-day game jam

Personal and course projects

NavMesh Generation

A voxel-based navmesh generator with A* pathfinding, running inside my own Vulkan engine.

Stack
C++20, Vulkan
Focus
AI navigation

AI Chess Engine

Chess built from scratch, then Monte Carlo Tree Search against Minimax with alpha-beta pruning.

3D Engine in Vulkan

My own renderer that automatically generates collision for any mesh you place in the scene.

Stack
C++20, Vulkan
Focus
Engine, collision

Toolkit

What I work with, and where you can see it in action.

AI programming

  • Behavior Trees
  • State Trees
  • Finite state machines
  • Utility AI
  • Enemy behaviors
  • A* pathfinding
  • Voxel-based navmesh generation
  • Minimax with alpha-beta pruning
  • Monte Carlo Tree Search

See it in my Master's research, My Pet Cthulhu, TimTim, NavMesh Generation and the AI Chess Engine

Performance and profiling

  • Unreal Insights
  • Automated benchmarking
  • Python data analysis
  • Statistical testing (ANOVA)

See it in my Master's research

Gameplay programming

  • Player movement
  • Input handling
  • Health and damage
  • Game loops
  • Spawning systems
  • UI functionality

See it in My Pet Cthulhu, TimTim and Drift Shop

Engine programming

  • Vulkan rendering
  • Instancing
  • Component and event systems
  • Automatic collision generation

See it in 3D Engine in Vulkan and NavMesh Generation

Languages

  • C++
  • C#
  • Python

Engines

  • Unreal Engine 5 (C++ and Blueprints)
  • Unity

Tools

  • Visual Studio
  • Perforce
  • Git and GitHub
  • Sourcetree
  • CMake
  • HacknPlan
  • Linear
Robbe Hijzen sitting on the rocks by the water

About me

Hi, I'm Robbe, a game developer from Leuven, Belgium, who specializes in gameplay and AI programming. C++ is my strongest language and I have a lot of experience in Unreal Engine, in both C++ and Blueprints, but I always love learning new languages and engines.

For my Master's research I compared how five NPC behavior architectures perform with crowds of up to 2,000 pedestrians in Unreal Engine 5.7. I'm now looking for a full-time role as a gameplay or AI programmer.

Education

  1. 2025 – 2026
    Master Game TechnologyBreda University of Applied Sciences, Breda, NetherlandsResearch: NPC behavior architectures at crowd scale
  2. 2022 – 2025
    Bachelor Digital Arts and Entertainment, Game DevelopmentHowest University of Applied Sciences, Kortrijk, Belgium

Hiring a gameplay or AI programmer?

I'm available for junior roles and happy to talk about your team and your game. Email is the fastest way to reach me.

Based in Leuven, Belgium

NPC Behavior Architectures at Crowd Scale

A controlled performance comparison of five NPC behavior architectures for crowds of up to 2,000 pedestrians in Unreal Engine 5.7, carried out for my Master's at BUas.

Overview

Open-world games need large crowds of pedestrians to make their cities feel alive, yet there was no controlled comparison of how the common NPC behavior architectures perform at that scale. Studios usually choose one on intuition.

I implemented five architectures in C++ on top of Epic's City Sample: a flat finite state machine, a hierarchical FSM, a State Tree, a Behavior Tree and Utility AI. All five follow the same behavior specification and share perception, movement and animation, so the decision-making framework is the only thing that changes. Each one was tested at three complexity levels (4, 10 and 18 states) and five crowd sizes from 100 to 2,000 NPCs, with 10 runs per condition and 750 runs in total.

Key findings

  • Below 500 NPCs, the choice of architecture had no measurable effect on frame rate. At 100 NPCs every system ran at 73 to 74 FPS.
  • The Behavior Tree had the lowest AI decision time, yet the State Tree delivered the best frame rate, 33.75 FPS against 27.18 for the Behavior Tree at 1,000 NPCs. Timing one component on its own can point you to the wrong architecture.
  • The State Tree scaled best at higher complexity. Going from 1,000 to 2,000 NPCs multiplied its cost by about 1.7 instead of 2.
  • Utility AI scores every action on every tick, which makes it impractical for crowds. It reached 462 ms of AI time per frame at 2,000 NPCs with complex behavior, about 25 times the Behavior Tree.
  • The flat FSM consistently outperformed the hierarchical one. At 2,000 NPCs with complex behavior, the hierarchical FSM cost 45% more.
At 1,000 NPCs, medium complexity. Best value per column in bold.
ArchitectureAI time (ms)Frame rate (FPS)

How cost grows with crowd size

For each architecture I fitted AI time ∝ Pn across the five crowd sizes. Every system scaled sublinearly (n < 1), and the lower n, the better it scales.

Scaling exponent n per complexity level. Lowest per column in bold.
ArchitectureSimpleMediumComplex
State Tree0.9000.7930.763
Flat FSM0.8520.8840.899
Hierarchical FSM0.8550.9110.935
Behavior Tree0.8820.9450.923
Utility AI0.9280.9250.922

What I built

  • Five behavior systems in C++: flat and hierarchical state machines built on an Enter, Execute and Exit state interface, an event-driven Behavior Tree, a compiled State Tree, and Utility AI with response curves and hysteresis
  • A replacement for the City Sample's Mass AI crowd pipeline, keeping Zone Graph lanes, animation and traffic as shared infrastructure
  • A custom spawning system for reproducible tests and a shared perception system that gives every architecture identical input
  • Behavior specifications for 18 pedestrian states, from fleeing and sitting to photographing landmarks and reporting crimes
  • An automated pipeline that runs every test headless, records Unreal Insights traces, exports them to CSV and analyzes them in Python
  • Statistical analysis with a three-way ANOVA and Bonferroni-corrected Welch's t-tests

What I would test next

  • The same comparison with LOD systems active, since every NPC got full AI processing here
  • The State Tree running inside Unreal's Mass AI framework
  • Matched evaluation scheduling and a range of tick rates, to separate scheduling cost from architecture cost
  • Hybrid setups, such as Utility AI choosing actions and state machines executing them

Paper

A Comparative Performance Analysis of NPC Behavior Architectures for Crowd-Scale Pedestrians in Open-World Games, written for my Master Game Technology at Breda University of Applied Sciences, 2026.

Gameplay from My Pet Cthulhu: pixel-art enemies charge down a neon circuit-board corridor Watch the trailer

My Pet Cthulhu

A fast-paced speedrun game where you help Cthulhu escape the Tamagotchi he is trapped in.

Overview

Cthulhu rides in your backpack while you race from room to room and environment to environment to break out of the simulation, and the Tamagotchi does everything it can to stop you. You parkour past acid pits and wind fans, fight three enemy types (Punchi, Sclero and Boowy), improve your times and collect every medal.

The core mechanic is the insanity meter. Every kill makes Cthulhu more insane, which speeds up the whole game but makes the enemies far scarier. The meter drains over time, so you choose between clearing levels patiently and rushing through enemies.

What I built

  • Player movement
  • AI behaviors for the enemies
  • A custom 3D voxel-based navmesh that Boowy uses for pathfinding
  • The game loop
  • Many smaller gameplay features
TimTim title card reading Greetings from TimTim over a forest at night Watch the trailer

TimTim

Couch co-op wave survival for two players. Hold out against 20 waves of alien invaders.

Overview

Made with four other students for the Game Projects course at DAE. Each of the 20 waves is harder than the last. Players pick Slanky or Big Tim, two characters with their own ability that speeds up wiping out the invaders.

What I built

  • Input handling
  • The health and damage system
  • AI behaviors for the aliens and the cows
  • Exploding barrels

Drift Shop

Drift a shopping cart through the aisles, grab everything on the list and reach checkout without crashing.

Overview

Made in three days for Unwrap Jam 2024. Crash into an aisle and your run is over. Every completed list is replaced by a new one, so you can keep shopping for as long as you survive.

What I built

  • Grocery item handling
  • UI functionality
  • The enemy spawning system

NavMesh Generation

A voxel-based navmesh generator with A* pathfinding, running inside my own Vulkan engine.

Overview

The world is voxelized and every voxel is checked for whether an AI agent could walk on it. Walkable voxels are turned into a graph of nodes that A* can search. To test the result, the demo picks a random start and end point and draws the path between them; press R for a new pair.

I optimized the generation for speed on purpose, because the next step is dynamic obstacles that change the navmesh at runtime.

What I built

  • Voxelization of the scene and per-voxel walkability tests
  • Conversion of walkable voxels into a node graph
  • A* pathfinding to validate the generated navmesh
  • All of it on top of my own Vulkan engine, which handles rendering, the camera and objects

Next steps

  • Dynamic obstacles
  • Settings for agent radius, step height and slope angle
  • Multithreaded generation
Robbe playing a game against his chess AI

AI Chess Engine

For this research project I built chess from scratch, then had Monte Carlo Tree Search play Minimax with alpha-beta pruning 250 times.

Overview

The game came first. I implemented every rule of chess, including the unusual ones, using bitboards and masks to keep move generation fast. Both AIs share one evaluation function that scores material, piece combinations such as the bishop pair, pawn structure and mobility. I tuned the Minimax search depth and the MCTS iteration count so that both sides spent roughly the same time per move.

Result

Minimax won convincingly. MCTS played some explosive games but blundered often, at one point giving up its queen for a pawn, because its selective search can skip a critical reply. Minimax always finds the best move within its search depth, so it rarely blundered.

What I built

  • Complete chess rules and move generation with bitboards
  • Minimax with alpha-beta pruning
  • Monte Carlo Tree Search with UCB1 selection
  • A shared evaluation function and the 250-game test setup

3D Engine in Vulkan

My own renderer that automatically generates collision for any mesh you place in the scene.

Overview

It started as an assignment at DAE and grew into a personal project with two parts. The engine handles all communication between CPU and GPU to render meshes, with instancing, a component system and an event system.

On top of that sits the collision generation. Give a mesh a CollisionComponent and it subdivides the mesh, octree style, into axis-aligned bounding boxes. A CollisionFixer then resolves every overlap each frame, so a player character with movement and gravity can walk around the scene without passing through anything.

What I built

  • A Vulkan rendering system with instancing
  • Component and event systems
  • Automatic collision generation with octree-style AABBs
  • Collision resolution and a player character with movement and gravity