School & game dev

Unity game built as a team during my game development Bachelor (Gaming Campus, 3rd year).

Context

Team project on a busy shared repository, with integration branches per area (tools, gameplay) and pull request reviews between teammates.

What I did

Mostly tooling and systems: an LOD tool, the dialogue importer and graph editor, a gameplay puzzle, and putting the repository in order (tree, scene merging, continuous integration).

Links

Private repository (school).

Project architecture

A _Bootstrap scene initialises the services (ServiceLocator): JSON saves, audio, multilingual localisation. Scripts talk through EventChannels (ScriptableObjects) without knowing each other.

My contributions

• LOD Manager: editor tool (6 scripts) that generates and tunes model levels of detail.
• Dialogue system: CSV importer that finds each line by id wherever it is stored, and a GraphView graph editor recovered from an older repository and fixed: links dropping when a choice was edited, text field losing focus on every keystroke, nodes created in the graph without data.
• Firefly puzzle: the player approaches a firefly, it follows them, enters a broken lantern and repairs it.
• Repository organisation: restructuring in 7 pull requests (440 files moved without breaking a reference), Git setup script configuring Unity scene merging, continuous integration.

Team game built for the Gaming Campus Awards 25-26. My role: dev on the custom C++/Vulkan engine.

Context

Grand Projet Commun Bachelor 3A - 17 people across five departments (Tech, Art, Business, TV, Sound). Five-month production from January to late April 2026.

Concept

Hybrid management + action/exploration. You manage a Persephin village from an isometric drag & drop view, and run expeditions in a fixed isometric WASD view to gather resources, fight corruption and push Cali's story forward.

Five playable biomes (one per people), 5 hero classes, T1-T5 tier system on everything (resources, gear, traits), reroll via colored gems, embedded puzzles (Piano, Plate, Crate, Tangram, Memory), endless mode unlocked after zone 16.

Stack & engine

C++20, Vulkan 1.3, CMake + vcpkg. Custom engine: 5 libs (Framework, Render, Audio, Assets, Engine ECS) + scenes. Graphics pipeline with GLSL/SPIR-V shaders, compute pipeline for GPU particles. Tile-based procedural generation for expedition maps.

Links

Private school repo. No public demo before the final delivery on 29/04/2026.

Pitch

Cali, a humanoid creature from the Primoris people, crash-lands on the planet Hestia after an engine failure. She wakes up with no memory, taken in by the Persephins. With the help of Iris, a brave young Persephin, she discovers the planet is being torn apart by the Harmathys corruption - a defense mechanism triggered by the Primoris arrival, turning the once-peaceful inhabitants into aggressive creatures.

Genre & gameplay loop

Hybrid village management + action/exploration expeditions. The player alternates between two phases:

┌──────────────────┐         ┌──────────────────┐
│  VILLAGE PHASE   │ ◄─────► │ EXPEDITION PHASE │
│ (iso management) │ cycles  │   (action WASD)  │
├──────────────────┤         ├──────────────────┤
│ • Drag & drop    │         │ • Combat         │
│ • Buildings      │         │ • Puzzles        │
│ • Population     │         │ • Resource farm  │
│ • Heroes         │         │ • Bosses         │
└──────────────────┘         └──────────────────┘

Each expedition consumes a village cycle (1 ration per villager). The village expands from 3×3 → 10×10 parcels of 7×7 tiles thanks to map fragments brought back from expeditions.

Universe - 6 peoples

People	Region	Traits
Persephins	Central plains	Nomadic traders, social
Yōtl	Sand dunes	Warriors, honor code
Arynes	Crimson forests	Artists, festive
Kaprass	Mountains	Astrologers, secluded
Khétus	Coasts	Navigators, fishermen
Primoris	Space	Colonizers, advanced tech

Five peoples = five playable biomes with their own resources, enemies and atmosphere. The Primoris are the unwitting cause of the corruption.

Village mechanics

Five core buildings:

• Tree of Life - Central building, caps the level of every other building
• Housing - Raises villager capacity
• Hospital - Purifies corrupted villagers + heals heroes
• Forge - Crafts equipment (T1-T4) + rerolls stats via gems
• Barracks - Sends out excursions (1-3 heroes, autonomous)

Expedition mechanics

• 5 biomes × 4 zones + Endless mode unlocked after zone 16
• 5 hero classes: DPS, Tank, Healer, Gatherer, Treasure Hunter
• T1-T5 tiers on resources, gear and traits
• 6 gem colors for reroll (colorless = base material, colored = lock a trait)
• 5 puzzle types: Piano, Pressure Plate, Crate-Plate, Tangram, Memory
• Rich stat system: armor, strength, speed, fortune, luck, crit, combo, chain, range…

Tech stack

Tech	Version	Role
C++	20	Core language
Vulkan	1.3	Graphics pipeline
CMake	3.20+	Build system
vcpkg	latest	Dependencies
GLFW	3.x	Windowing
GLM	latest	3D math
RtAudio	5.x	Audio
stb_image	latest	Textures

Custom engine split into 5 GPC libraries: Framework (clock, transform, state machine), Render (Vulkan, textures, shaders), Audio, Assets (loader, macros), Engine (full Entity-Component-System pattern).

Tile-based procedural generation for expedition maps: pick a zone shape → link entry to exit → close walls → represent rooms as a tree for puzzles → collapse rooms.

Team & context

17 people spread across 5 departments: Tech, Art, Business, TV/Multimedia, Sound. 154+ commits on the code side.

Gaming Campus Awards 2025-2026 project - Bachelor 3A validation.

Date	Milestone	Status
03/02/2026	Pitch	✅
25/02/2026	MAAV (composers)	✅
27/02/2026	Pre-production	✅
29/04/2026	Final	⏳

A week of C++ multithreading with the Win32 API at GTech 3: daily exercises, then an arena where four threads split the map.

Context

Week of November 17 to 24, 2025. The course notes (theory, Win32 threads, thread safety) sit in Semaine Exo/Doc/. Individual work.

What I did

The four exercises of the week, then two versions of the SFML arena: TestMessage (balls that change thread when they change zone) and TestComplet (players, bonuses, fights and game over). Remote collision damage, zone transitions and rewards are sent as messages to the SafeQueue of the thread that owns the target entity.

Links

• 5---Multithreading (code on the Kiki branch)

Weekly exercises (Semaine Exo/)

Day	Exercise	Content
D1	WhackAThread	Console whack-a-mole: each mole is a thread (CreateThread), one thread spawns the moles, events go through a message queue
D2-3	SafeQueue	Bounded ring-buffer queue: CRITICAL_SECTION and two CONDITION_VARIABLEs (not full, not empty), blocking push, tryPush / tryPop, producer-consumer test
D3	CollisionDetector	Collisions between 50,000 spheres: single-threaded, then 2 and 4 threads, a progress monitor thread (Interlocked*)
D3-4	SafeCollision	Same detection as producers and consumers through the SafeQueue, five configurations compared, one with local accumulation of results

Final arena (Final/TestComplet)

Main thread: SFML rendering (800 x 600), game over, stats
ThreadManager
  └── 4 WorkerThreads, each with its entities and a SafeQueue<Message*>
        16 ms loop: messages -> update -> collisions -> transitions
Map: 4 x 3 grid of 200 px cells, cell -> thread (index modulo 4)

• 12 players, 8 bonuses (HP, speed, shield, damage). The last player alive wins.
• Local collision (two players on the same thread): damage and bounce computed in place.
• Remote collision: the lower-index thread applies it to its player and sends a CollisionMessage to the other thread, plus a KillRewardMessage if its player dies.
• Transition: a player that changes cell is serialized into a TransitionMessage, removed from its thread and rebuilt in the target thread. A player's color shows its thread.

Stack

Tech	Role
C++	Language
Win32 API	CreateThread, CRITICAL_SECTION, CONDITION_VARIABLE, Interlocked*
SFML 2.6.1	Arena rendering
Visual Studio	Build

3rd-year maths and physics work (Gaming Campus, 2025-2026), all rendered in the console.

Context

The engine maths course covered 3D-to-2D rotations and projections, with an ASCII donut as the common thread. The team exam asked to make that donut float and spin. The advanced physics module started with a week of integration exercises.

What I did

The course's ASCII renderer (meshes, projection, settings), the donut's orbit animation for the exam, and the Euler integration exercises.

Links

• The Floating Donut (public fork of the team repository)
• Math-GTech3 (engine maths course and labs)
• 9---Physique-Avancee-DirectX (advanced physics exercises)

Engine maths (November 2025)

DonutMath console program: mesh generation (circle, half circle, rectangle, square), projection to the screen and ASCII display. Screen size, mesh resolution, background and projection characters, screen and viewer positions set from command-line arguments.

"The Floating Donut" exam (January 2026, team of 3)

A torus generated, rotated and lit in ASCII, floating in orbit. My additions: the Vector3 struct, the orbit motion in the animation, and its settings in Settings.

Advanced physics (January 2026)

Numerical integration exercises in C++: explicit Euler, semi-implicit Euler, variable acceleration and a simple spring.

A parser for Wavefront OBJ 3D models and a generic tokenizer, written during the GTech 3 "Parser" module.

Context

Theory week from November 3 to 7, 2025: text parsing, binary parsing, .obj parsing, then an introduction to the FBX SDK and OpenGL. The repository keeps the module's name ("Parser FBX"); the code covers the tokenizer and the OBJ parser. The course slides and the provided projects (basicgl, bmp, parser) sit in Doc/.

What I did

The tokenizer and its test program, then the OBJ parser: data structures, line-by-line reading, the four face formats, index conversion, test files, CMake and README. Individual work.

Links

• 4---Parser-FBX (code in Semaine Exo/, Kiki branch)

OBJ parser

Supported lines:

Command	Content
v x y z [w]	Vertex (w defaults to 1.0)
vt u v [w]	Texture coordinate (w defaults to 0.0)
vn x y z	Normal
f ...	Face: v, v/vt, v//vn or v/vt/vn, triangles, quads and polygons
o name	Object name
#	Comment

File indices (1-based) are converted to 0-based; a missing index is -1. vp, s, g, usemtl and mtllib lines are skipped. An error returns false and a message with the line number (getLastError()).

ObjData
  ├── vertices   : std::vector<Vertex>
  ├── texCoords  : std::vector<TexCoord>
  ├── normals    : std::vector<Normal>
  ├── faces      : std::vector<Face>  (FaceVertex: vIndex, vtIndex, vnIndex)
  └── objectName

Tokenizer

• tokenize: splits text into tokens (:, (, ), {, }, /, \, ", , and strings).
• segmentize: groups tokens into nested segments (parentheses, braces, quotes) with a stack.

Tests

• cube.obj: 8 vertices, 4 texture coordinates, 6 normals, 12 triangles.
• test-formats.obj: one face of each format, plus a quad.
• test.sh builds the parser and runs it on both files.

Stack

Tech	Role
C++17	Language
CMake / Visual Studio	Build (two executables: TestObjParser, TestTokenizer)

Desktop audio editor for WAV files with DSP effects, waveform visualization and real-time processing.

Context

School project GTech3, 6 weeks. Team of 3, role: DSP and audio engine developer.

Exploring digital signal processing fundamentals through a practical audio editing application.

School Requirements

• Parse and play WAV files
• Waveform display
• Implement at least 2 DSP effects
• Windows audio API, latency < 50ms

Our Implementation

Beyond the requirements (2 effects required):

• 4 complete DSP effects: EQ, compression, reverb, delay
• Non-destructive editing: preview before applying
• Advanced selection tools: sample-accurate cut/copy/paste
• Extended format support: 8/16/24-bit, mono/stereo

Links

• Private repository (school).

Architecture

Audio pipeline with chainable effects:

WAV File → Parser → [Effect Chain] → XAudio2 → Output
                         │
      ┌──────────────────┼──────────────────┐
      │                  │                  │
    EQ            Compressor           Reverb
 (Biquad)           (RMS)          (Convolution)

Tech Stack

Tech	Version	Role
C++	17	Core language
XAudio2	Windows API	Real-time audio engine
Win32/ImGui	-	User interface
WAV Parser	Custom	Audio file reading

Custom WAV Parser

• RIFF header parsing
• Formats: 8/16/24-bit, mono/stereo
• Chunk navigation and metadata
• Beyond the required 16-bit

DSP Effects Implemented

• Parametric EQ: Biquad filters per band
• Compressor: RMS detection with attack/release
• Reverb: Convolution basics
• Delay: Delay lines with feedback

Specifications

• Latency: < 50ms (Windows audio API)
• Non-destructive editing with preview
• Sample-accurate selection: cut/copy/paste

Three small programs written during the GTech 3 "Asset Engine" week, to learn how to read, validate and transform files byte by byte.

Context

One exercise per day, from the provided briefs (D1 "HexView", D2 "SafeReader"): read any binary file, then define a small format with a header and a checksum and read it defensively, never trusting the file. Individual work, October 20 to 23, 2025.

What I did

HexView in two versions (C with malloc/fread, then C++ with std::vector and a class), SafeReader with its generation and corruption tools, then CryptFile. All three are then gathered in ExoComplet, one standalone file per exercise (built-in menu for SafeReader and CryptFile), with a README and a build script.

Links

• 3---Asset-Engine (code on the Kiki branch)

The three exercises

Day	Program	Content
D1	HexView	Dumps a file 16 bytes per line (offset, hex, ASCII), saves the dump to .txt, edits a byte at an offset, saves the edited file
D2	SafeReader	Generates, validates and corrupts .safe files
D3	CryptFile	Encrypts and decrypts a file with a text key, symmetry test

.safe format (D2)

HEADER (16 bytes)
  magic    : 4 bytes (0x45464153, "SAFE")
  version  : 4 bytes (1)
  dataSize : 4 bytes
  checksum : 4 bytes (XOR then 1-bit left rotation, byte by byte)
DATA (variable size)

The reader checks the signature, the version, the declared size against the real size, then the checksum. The corruption tool breaks one field at a time to check that each error is caught: magic, version, size, checksum, one data byte, or a truncated file.

Cipher (D3)

• Encryption: 3-bit left rotation, then XOR with the key byte (((b << 3) | (b >> 5)) ^ key).
• Decryption: XOR, then the reverse rotation.
• The text key repeats over the whole file length.
• The symmetry test encrypts, decrypts and compares the result with the original file.

Two versions of HexView

• Classic C: fopen, fread, fwrite, malloc, free, typedef struct.
• C++: HexView class, std::vector, std::ifstream / std::ofstream, replacing a block of bytes.

Stack

Tech	Role
C / C++17	Language
g++ / Visual Studio	Build (compile_all.sh included)

High-performance math library using SIMD instructions for vector and matrix operations in game engines.

Context

School project GTech3, optimization competition, 4 weeks. Individual project.

Implementing math operations with SIMD intrinsics to achieve maximum throughput.

School Requirements

• Implement SIMD vector operations
• Benchmark vs scalar, minimum 4x speedup
• x86 intrinsics (no inline asm), SSE4.2 minimum

My Implementation

Beyond the required vectors:

• Complete hierarchy: Vec2, Vec3, Vec4, Mat4, Quaternion
• AVX in addition to SSE: 8 floats vs 4
• SIMD Quaternions: optimized rotations
• Optimized data layouts: SoA support
• Runtime dispatch: automatic CPU detection

Links

Code available on request.

SIMD Architecture

Type hierarchy with runtime dispatch:

┌─────────────────────────────────────────┐
│         Runtime CPU Detection           │
│    (SSE4.2 / AVX / AVX2 available?)     │
└──────────────┬──────────────────────────┘
               │
     ┌─────────┴─────────┐
     ▼                   ▼
┌─────────┐         ┌─────────┐
│  SSE    │         │  AVX    │
│ 128-bit │         │ 256-bit │
│ 4 floats│         │ 8 floats│
└─────────┘         └─────────┘

Tech Stack

Tech	Version	Role
C++	17	Core language
SSE4.2	x86 intrinsics	128-bit registers
AVX/AVX2	x86 intrinsics	256-bit registers
CMake	3.x	Build system

Types Implemented

• Vec2, Vec3, Vec4 (SIMD)
• Mat4 (SIMD)
• Quaternion (SIMD)
• SoA (Structure of Arrays) support for batch

Optimization Techniques

• Memory alignment (16/32 bytes)
• Data layout SoA vs AoS
• Cache-friendly patterns
• Branch elimination
• Runtime SSE/AVX dispatch

Benchmarks

Operation	Scalar	SIMD	Speedup
Vec4 dot	4 ops	1 op	~4x
Mat4 mul	64 ops	16 ops	~4x
Batch transform	N ops	N/4 ops	~4x

Unity demo built around a complete save system, made in October 2025 during the 3rd-year "Data persistence" module.

Context

The module was about saving and loading a game's state. The demo is a test bed: a first-person player with survival stats, an inventory and pickups, everything that needs saving.

What I did

The save system (multiple slots, metadata, auto-save), the save and load interface, the player controller and the inventory.

Links

Private repository.

Saving

• SaveSystem (singleton kept across scenes): JsonUtility serialisation into Application.persistentDataPath.
• 6 configurable slots plus an auto-save slot, each paired with a metadata file so the save list can be shown without loading everything.
• Auto-save every 120 s (adjustable), with an on-screen indicator.
• Saved data: health, hunger, thirst, stamina, experience, level, position, camera and player rotation, inventory.

Demo gameplay

• First-person controller: sprint, crouch, slide (costs stamina).
• Pickups, inventory (TAB), pause menu (ESC) with save and load.
• Debug keys to change stats and wipe the save.

Tooling

• GitHub Actions workflow building Unity (Windows, Android, WebGL).
• PowerShell scripts to build and clean the project.

C# console game made for the "C# basics" module of 3rd year (Gaming Campus, 2025-2026).

Context

The module asked for a complete console game in C# (classes, inheritance, interfaces). A week of exercises on an inventory and stats system (with its tests) came before the final project.

What I did

A space shoot'em up that alternates fights against waves and exploration phases, with a custom console renderer, a quest system, combinable elemental types, power-ups and a suite of unit tests.

Links

Private repository (school).

Architecture

GameManager
    ├── FightScene    → enemy waves, projectiles, abilities
    ├── ExploreScene  → exploration, chests, quest givers
    ├── Canvas        → console rendering (kernel32 calls via P/Invoke)
    └── QuestManager / Inventory / UIManagerStats

Systems

• Bitmask elemental types: four base types (heat, poison, ice, electric) and six combined types (viral, magnetic, radiation, corrosive, gas, blast), with effectiveness multipliers.
• Shooting modes: single, triple and side shot, described as lists of projectiles.
• Quests: eight objective types (kill, collect, talk, explore, reach a wave, survive, deal damage, use an ability).
• Stats and power-ups: stat modifiers and power-ups applied to the ship, choice between four ships.

Tests

Separate test project (TestSpaceSquad): combat, inventory, power-ups, projectiles, quests, stats, type effectiveness.

Stack

Tech	Role
C#	Language
.NET 8	Runtime, console application

Strategy RPG prototype built for Gaming Campus' "Jeu Libre" (free project) assignment, on a hand-written ECS engine.

Context

The Game Design Document (March 2025) describes a turn-based RPG where the player, captain of a ship in a mostly maritime semi-futuristic world, recruits a crew, explores islands and fights on land (hex tiles, dice rolls, initiative) and at sea. The engine was first built in an "ECS 2D" repository (SFML 2.5, March 2025), then moved to SFML 3.

What I did

Every commit in the repository is mine: the ECS engine (entities, components, systems, JSON databases), the naval exploration scene and the five island scenes, the hex-grid land combat scene, and the Game Design Document. This engine later became the base of the ECS Template.

Links

• JeuLibre (SFML 3 version)
• ECS-2D (first engine, SFML 2.5)

Architecture

Two-project solution generated by a SolutionGenerator (config/settings.json):

Engine (static library, SFML 3 linked statically)
    ├── Entity / EntityManager / EntityFactory
    ├── 37 components (Transform, Render, Combat, CrewMember, Navire, FogOfWar, TurnOrder…)
    ├── 34 systems + SystemManager
    └── JSON databases: actions, effects, items, loot, stats, tiles, spawners
Game (executable)
    └── 10 scenes: naval exploration, 5 islands, land combat, options…

Technical points

• Hex grid: directions and neighbours in offset coordinates (HexDirection, row parity).
• Turn order: queue sorted by total initiative (SystemTurnOrder).
• Maps: islands loaded from JSON files (TileMapLoader, nlohmann/json), one map file and one spawner file per island.
• Data-driven: actions, effects, items and loot tables described in JSON and loaded at startup.

Stack

Tech	Role
C++	Language
SFML 3.0.0	Rendering, window, audio
nlohmann/json	Data and maps
Visual Studio	Build (generated projects)

The C++ exercises and labs of the 2024-2025 year at Gaming Campus, from the first encapsulation day to an entity-component architecture.

Context

A series of small repositories, one per exercise or lab, over six months. The only team project is the SFML breakout from November 2024.

What I did

C++ OOP basics, a state machine, scenes on the LightEngine engine, threads, a TCP client and server, an entity-component architecture, and my version of the breakout game.

Links

• Encapsulation-C (basics and encapsulation)
• Exo-Full (review exercises)
• Exo-C-- (entity hierarchy)
• InventaireExo (inventory)
• CasseBrique-Final (breakout, one branch per member)
• Tp1-StateWeapon (state machine)
• Tp2-PvZ (Plants vs Zombies)
• Test-ShootEmUp (shoot 'em up)
• ExoThread (threads)
• ExoServClient (TCP client-server)
• TestDirectX (entity-component architecture)

The coursework

Period	Work	Content
Oct. 2024	Basics and encapsulation	Point, Entity, Player classes, IAlive interface, inheritance
Oct. 2024	Wrap-up exercises	Vector2, Integer, Entity → Mob / Player / BreakableObject hierarchy, World
Oct. 2024	Inventory	Console inventory with weights and a maximum capacity
Nov. 2024	Breakout (team of 3)	SFML: explosive, bonus and trap bricks, ball and paddle effects, file-based levels, menus, music
Nov. 2024	StateWeapon lab	Weapon driven by a state machine (State: Start / Update / End)
Nov. 2024	Plants vs Zombies lab	PvZ scene (plants, zombies) on the LightEngine engine (SFML)
Dec. 2024	Shoot'em up	Ship and enemies on LightEngine (SFML)
Jan. 2025	Threads	Thread class and child threads
Jan. 2025	Client-server	Winsock TCP server and client (socket, bind, listen, accept), one thread per side
Feb. 2025	EC architecture	Entity, Component, Transform, Renderer, then an optimisation pass

Breakout

Three versions (one per team member) merged into the same repository. The version on my branch has three special brick types, twelve ball effects (speed, size, piercing, random direction, invisibility, multiply, reverse, teleport, split…), four paddle effects, a level generator and manager, a main menu and a pause menu.

2D platformer developed as a team during the 1st-year "Mini Studio" project (April 2024).

Context

Group project on a shared repository, one branch per member (programming and art), merged into the main branch for the final hand-in.

What I did

Player movement (jump, glide, run, gravity), the camera, the parallax background, character animations and item pickup with an inventory.

Links

• JV-Mini_Studio (team repository)

Structure

carte.py / chapters.py     → menus, map and level select
main0.py … main3.py        → the four playable levels
editor0.py … editor3.py    → one level editor per level
level0_data.csv … level3   → saved levels (30 × 150 grid, 21 tile types)
Album0.py … Album4.py      → photo album
Parametre.py               → music and sound settings

My branches

From the history of my branches (Kiki_1, Kiki_2):

• camera following the player and disabling off-screen objects;
• jump, glide, run and gravity, computed with delta time;
• endless scrolling background and parallax;
• character animations;
• item pickup and inventory storage.

Game Design Document for an aerial adventure-exploration game: in a world drowned under an ocean of toxic clouds, the Veil, humanity survives on floating islands that the player travels by flying on a Souffleur.

Context

Personal project from April 2026, at the pre-production stage: the design document is written, the pitch deck, the prototype and the visuals are planned. It follows an earlier GDD, "Éolia", written the same morning, and reuses its market study.

What I did

The whole GDD (gameplay, world, level design, art direction, sound, tech, production), a market study and a brief on the legal framework, and the document's build chain.

Links

• Zephyria
• Éolia (earlier GDD)

The document

GDD v1.0 split into 20 modular parts (docs/gdd/parts/), compiled into a single document by a pandoc script:

Part	Content
Game design	Vision and pillars, core gameplay, world and narrative, progression and economy, level design
Production	Interface and UX, art direction, sound design, technical specs, roadmap
Studio	Business model, market analysis, team, budget, risks
Framework	Intellectual property, regulatory compliance, appendices

Gameplay loop

Micro (30 s – 2 min)   Observe → Pick a direction → Fly → Discover → Interact
Session (20 – 45 min)  Explore a zone → Story fragments → Sanctuary → New ability
Macro (12 – 15 h)      6 regions → Sanctuaries → The truth → Descend into the Veil → A choice

Sheet

Genre	Aerial adventure-exploration, third person
Target engine	Unreal Engine 5
Art direction	Watercolour cel-shading

Minecraft mod adding a full action-RPG layer: classes, skills, spells, equipment and dungeons.

Context

Personal project from February 2026, the first mod of a workspace dedicated to Minecraft modding (Fabric), with its build scripts.

What I did

The mod's game design, then its implementation in Java: class and resource system, skill trees, spells and effects, equipment, creatures, and dungeon generation with its scoring logic.

Links

• GitHub

Classes

Class	Resource
Berserker	Rage
Archmage	Mana
Shadow	Combo
Paladin	Holy Power + Mana
Necromancer	Souls
Druid	Essence

Content

• Spells: 109 spell classes in rpg/spell, 8-slot spell bar.
• Skill trees: 3 branches per class, one ultimate per branch, respec scroll.
• Equipment: class-locked legendary weapons, artifacts (rings and amulets), dedicated forge.
• Dungeons: generated from room templates, in a dedicated dimension, with score, timer and rank-based loot.
• Creatures: custom mobs and bosses with a boss bar.

Stack

Tech	Version
Minecraft	1.21.4
Fabric Loader	0.18.4
Fabric API	0.119.4
Java	21
Gradle (Loom)	build

Unity toolkit gathering the classic mechanics of a first-person horror game, ready to drop into a scene.

Context

Personal project started in November 2025.

What I did

About forty C# scripts organised by module (movement, horror, camera, AI, interaction, combat, audio), demo scene generators in the editor, the documentation and the tutorials.

Links

• unity-mechanics-toolkit

Modules

Module	Scripts
Movement	FirstPersonController, Sprint, Crouch, Lean (AZERTY)
Horror	FlashlightSystem (battery, flicker), SanitySystem
Camera	CameraShake, HeadBobbing, LookBehind (quick turn)
AI	AIStateMachine, VisionCone, PatrolBehavior (NavMesh), ChaseBehavior
Interaction	RaycastInteractor, DoorController, ExamineObject, HidingSpot, HighlightSystem
Combat	Health, MeleeWeapon, BlockDodge
Audio	FootstepSystem, HeartbeatAudio
Core	IDamageable, IInteractable, IKillable, IPoolable, GameEvents, extensions, ObjectPool, Singleton

Editor tools

Five demo scene generators (Tools > Unity Mechanics Toolkit > Create Demo Scenes): player, AI enemy, interactions, combat, and a horror showcase that puts everything together.

Distribution

UPM package (package.json, assembly definitions), architecture docs and four tutorials (player, AI, interaction, combat).

Universal Entity Component System engine in C++20. Modular architecture, reusable for all types of 2D games.

Context

ECS engine born from the second-year Jeu Libre project (March to May 2025), then extracted and published as a reusable template.

Goal: create a reusable engine as a base for other projects, with a clean and extensible architecture.

What it does

Supported game types:

• Real-time: FPS, platformers, action
• Turn-based: strategy, tactical RPG
• Grid-based: roguelikes, puzzles
• Hybrid: mode combinations

Architecture:

• Entities as pure IDs
• Components as data
• Systems for behavior
• Total logic/data decoupling

Demo: Pirate Space Explorer - complete game (30+ Components, 35 Systems) shipped inside the repo as a showcase.

Links

• GitHub
• Documentation

ECS Architecture

Pure Entity-Component-System architecture:

Entity (ID)
    │
    ├── Component A (Data)
    ├── Component B (Data)
    └── Component C (Data)
         │
         └── Systems (Behavior)
             ├── Active (continuous)
             ├── Reactive (event-driven)
             └── TurnBased (discrete)

Tech Stack

Tech	Version	Role
C++	20	Core language
SFML	2.5+	2D rendering
CMake	3.20+	Build system
Patterns	ECS, Factory, Observer	Architecture

Statistics

• 36 Components modular
• 35 Systems decoupled
• 8+ Modules: core, transform, graphics, gameplay, inventory, interaction, AI, audio, network

Collision Optimizations

Spatial hashing O(n) vs O(n²):

Entities	Brute Force	Spatial Hash	Speedup
125	125,000 checks	1,000 checks	25x
1000	500,000 checks	2,000 checks	250x

Memory Safety

• Smart pointers + RAII
• Memory pooling for frequent allocations
• Thread-safe with mutexes and atomics