About me

Game Programmer | C++ & C# | Focus on systems & tool development for immersive gameplay.Currently in my 5th year of Master's studies at Rubika Supinfogame.What I value in games:
• Strong and coherent systems.
• Immersion supported by world logic.
• Mechanics that serve narrative consistency.

• Email
• LinkedIn
• CV
• GitHub

• Unreal
• Steam
• YouTube
• Spotify

Barrel Roll

2024-2026 / 15 people / 8 months

This is a rogue-like deckbuilder in which you play as a cowboy in a cyberpunk universe.
Chain fights to collect new bullets, create ever more powerful decks in your barrel and maybe you will become the finest trigger in the west ...

Role: System/Tools Programmer

Contributions: UI, System, Tooling, Engine.

Tools: Git, Unreal Engine 5, C++ & Blueprints, LGUI.

Published & available on Steam, nominated for the Pegasus Awards 26.

• See More

• Unity

Tous Pour Un

2025-2026 / 7 people / 9 months

A tactical & narrative RPG game where you control a squad of musketeers through grid fight and multiple-choice dialogue.
Save the king, stop the Prince of Condé's plot, and you might even save yourself and your team in the process.

Role : Solo Programmer

Contributions: Gameplay, 3C, System, Tooling, UI, AI.

Tools : Git, Unity 6, C#, Articy, Node Canvas, Odin Inspector/Serlializer, UniTask, NPOI.

End-of-study project of my 5th year at Rubika (WIP).

• See More

• Unity
• GitHub

Top Gun Simulator

2024 / 2 people / 3 days

A small aerial controller inspired by the Top Gun movies. Avoiding obstacles while staying below the ceiling limit to not be shot down by missiles.

Rôle: Airplane Programmer

Contribution: Gameplay, 3C, Game Design.

Tools: Git, Unity, C#.

Made in collaboration with Mathieu Mezier.

• Unity
• Itch.io
• YouTube
• Information

Deer Fox,

2025 / 6 people / 2.5 days

A cooperative tower defense game I played as a member of the "Crazy Linguini" team during the Franco-Belgian Game Jam (2nd edition).

The enemy is coming to destroy the mother tree, work with your ally to plant trees that will defend you against waves of ever-increasing enemies!

Rôle: Lead Programmer

Contributions: Gamplay, 3C, System.

Tools: Git, Unity, C#.

• Unity
• GitHub

Crowd simulation with steering forces

2026 / Solo / 2 Weeks

A small personal project in which I explore and implement Craig Reynolds' steering behavior to create my own version of the rats mechanics from Plague Tale.The project is implemented in 2D using a custom engine with the SDL2 library.The project controls about a hundred rats subjected to various continuous forces such as swarm cohesion, player pursuit, obstacle and light avoidance, all combined with basic physical constraints (drag, minimum/maximum speed).
The result is emergent, fluid, and natural behavior, without AI or pathfinding.

Tools: Git, C++, SDL2

Challenges: R&D, adapation and implementation of Steering behaviour model. Balancing of forces.

• Unity
• GitHub

Maze TOWER

2024 / Solo / 4 days

A project oriented towards procedural generation where the player must escape from a tower whose floors are renewed infinitely as he climbs and which are procedurally generated labyrinths according to different algorithms.

Tools: Git, Unity 6, C#

Challenges: R&D and implementation of various maze generation algorithms.

• Return

Barrel Roll

Data-oriented Architecture
Barrel Roll is a very systemic game that required a flexible and robust architecture that
emphasizing data compartmentalization through hundreds of inteconnected Primary Data Assets.

Random Generation : Bounties, Events, Rewards, ...
One of the main mechanics of Barrel Roll is the semi-random generation of bounties. Each time the player returns to the game's main hub, the system generates a list of upcoming bounties that the player can select based on their current level and previous bounies.

Levels & Game Loop Management
Manage the transition between the different levels of the game loop, ensuring that the correct UI is loaded during 2D levels, that the correct sub-levels are loaded during 3D battles, and that the Game Framework of each level is correctly configured.

Save System
Finding the right approach for the battle save/load system was not easy.
Finally, we used the principle of reflection to iterate at each turn over the fields of the relevant classes and save those with a specific attribute in a UE5 Save class.

Skip System
The skip system works simply by increasing the game speed. The complicated part comes from the fact that, by default in UE5, the speed of UI animations is not synchronized with the game speed. It was necessary to create a new parent class for UI objects in the engine and override some functions to enforce synchronization between the two.

Tooltips
The tooltip system is essential to understanding the game; it required work in global position calculation based on the local position of the hovered object, as well as in the display of a dynamic UI capable of displaying data from the hovered object.

Letterboxing
In the vast majority of cases, Barrel Roll's UI doesn't use a camera since most levels are 2D that are directly defined in the widgets viewport.
Without the automatic letterboxing provided by a camera, I implemented my own letterboxing system that calculates the maximum 16:9 ratio based on the window current resolution.

Drag & Drop with Arsenal Inventories
The player has three inventories in the game: a basic inventory for storing unused bullets and two barrel inventories for building bullet combos in combat.
The arsenal was one of the first features implemented for managing bullets.

Battle Transition Map
This is probably the feature I'm most proud of in terms of UI. Between each fight, the player goes through a transition level, which displays an animated map representing their progress that changes dynamically depending on their progress, the boss of the current bounty, or the generated event choice.

Battle Events
Between bounty fights, players can spice up their adventure with events generated based on their build's capabilities. Each event offers the player a choice, a mini-game, or a unique opportunity that could give them an advantage or a disadvantage in their game.

Options Management
The implementation of options that the player needs to control their game; some are provided by UE5 and must be made accessible (window mode, graphics quality, etc.). Others are created by the developers (tutorial on/off, skip, sound volumes, etc.).

Mid-project Blueprint to C++ transition
Barrel Roll began as a student project with only Blueprint classes; as the project progressed, it became necessary to convert some of the existing classes to C++.Today, all blueprint classes have a custom C++ parent and a part of the function is implemented inside (generally the most heavy ones and those that cannot be implemented in blueprint).

UE5/VS22 Debug
You know that guy you call when your computer or editor don't want to work? That's me.

Build Management & Steam publishing
As build manager, I was responsible for building the game at regular intervals (usually once a week) to ensure that recent developments hadn't caused any hidden issues in the editor, and if so, to identify and fix them.
From the moment the game was released, I was also one of the people responsible for updating the build on Steamworks and posting announcements on Steam for each update.

• Return

Tous pour un

Articy:Draft X
As storytelling is one of the pillars of this game, we use an external application as a source of narrative truth and a working environment for the Game Designers.Dialogues created in Articy are then imported and implemented as visual novels or speech bubbles, depending on the type of scene in which they are read.

Odin Inspector
This package is used in various aspects of development to facilitate serialization and displaying in the inspector. However, its greatest utility lies in the creation of two Unity panels that centralize:- The static values for all classes in the project.
- The dynamic values of classes instantiated during runtime.These two panels allow for efficient configuration and debugging of all aspects of the game.

Node Canvas
This package is used in this project to implement an FSM + BT behavior system (see AI Programmer section) for AI that is easily configurable by Game Designers.

NPOI
This is an open-source .NET library that allows you to read and write Microsoft Office files (Excel, Word, PowerPoint) without needing to install the Office Suite on your machine.It is used here to import data from scriptable objects into an Excel file and vice versa to facilitate data configuration.

UniTask
Given the large amount of async required for the project, we decided not to use coroutines or .NET Tasks.Instead, we used the UniTask library, whose API is almost identical to .NET Tasks, except that it is optimized for the Unity Game Loop and therefore performs better under heavy usage.

Reactive Gameplay Event System
Tous Pour Un is a tactical game that aims to recreate the energy of the musketeers in its battles.To replicate this dynamism on a turn-based grid with a small team, a system was needed that could react and adapt the gameplay to the evolving combat in real time.It works by storing events, each with its own success/failure conditions, which are evaluated based on signals sent by entities on the grid as the battle progresses (A injured B, C moved here, etc.).The main advantage lies in the fact that when an event concludes, it executes a corresponding list of instructions (called effects and configurable by GDs in the settings panel created with Odin) which allows it to interact with the world as we want (for example, by triggering a dialogue, playing a VFX, instantiating new enemies, active a next event, etc.).This system is used for implement most of the dynamic combat aspects such as objectives, passive abilities, challenges, narrative events, etc.

Tactical Grid
One of the most complex and important systems in the game is the grid on which combat takes place.The grid is a game object designed to be placed directly onto any level design. Depending on its configuration (width, length, height, cell size, etc.) and the layers applied to the level design components, it creates a 3D space in which the grid's entities can move, interact, fight and evolve.In addition to this, there is highlighting. The grid must efficiently support several layers: the dynamic highlight of the player-controlled character, which can change with each mouse movement; and static highlighting, such as cell edges or level objectives, which rarely change.

2D Characters in a 3D World
The characters on the grid, whether musketeers or enemies, are 2D objects in a 3D environment, so they must be able to orient themselves in all four directions.To make this possible, each character has two Live2D puppets, each with its own animator.
Alternating between displaying the puppets and their positive and negative scales, while synchronizing their animators, allows any direction on the grid to be displayed.

Precalculated Actions
In combat, certain actions must be performable by both controlled and automated characters (assault, kick, walk, etc.).
To predict the consequences of these actions when calculating AI behavior and to display the highlight, the logic behind these actions is separated into two distinct classes.
The first class is responsible for precisely calculating the effects of the action on the grid (who is affected, how, what the user's final cell is, etc.), and the second class takes the first class as a parameter to apply the calculated effects to the grid.

UI Pooling
Tous Pour Un uses only one main canvas and its UI is divided between static UI (VN, Menus, HUD of battles, ...) and dynamic UI (life bars, speech bubbles, ...) mainly used in battle which is managed via the pooling pattern to instantiate/remove and place pieces of UI according to the needs of the gamplay.

A* & Dijkstra Pathfinding
To move around the grid, controlled and automated characters need efficient tools for orientation. A* allows for the creation of paths, and Dijkstra's algorithm is used to calculate range.

FSM + BT Behaviours
Characters not controlled by the player must be able to act on their own; the combination of Finite State Machines and Behaviour Trees of Node Canvas composed of Custom actions that implement my precalculated actions allows the creation of behaviors and their assignment to the grid characters according to needs.