AI & GAMEPLAY PROGRAMMER
Hamza Ben Said
Building robust systems, responsive controls, and immersive mechanics in Unity & Unreal Engine.
VIEW PROJECTSPROJECTS
Click on a project to learn more
Academic Projects
Goodbye Pongo
6 MONTHS
Patch Me If You Can
7 WEEKS
Takaindest
6 WEEKS
Game Jam Projects
10 to Midnight
4 DAYS
Ramiel
48 HOURS
Tatuchatoi
1 WEEK
Tools & Plugins
Static Mesh Instances Converter
EDITOR TOOL
CameraSpline
EDITOR PLUGIN
Software Projects
Snake Remake
DESKTOP GAME
Multiplayer Tombola
CLIENT / SERVER
IoT Projects
Anti-Theft System
IOT SYSTEM
Project Overview
Goodbye Pongo is a 3D side-scrolling puzzle-adventure developed over 26 weeks as the final second-year project at DBGA with a team of 14 in Unreal Engine 5. Trapped in an ancient foreign temple, researcher Jane discovers Pongo — a powerful, emotional creature she can only communicate with through mysterious bongos. Their relationship evolves from captor and prize to allies as the player learns to read and leverage Pongo's emotional states. The core loop requires players to observe the environment and Pongo's behavior, collaborate with him to navigate puzzles, and watch out for emotional trigger objects and temple hazards. Every room introduces new objects that force the player to adapt strategy around Pongo's reactions.
Contributions
I was responsible for two major standalone systems: a fully data-driven, spline-based camera with a custom Editor plugin, and the complete AI architecture driving Pongos emotional behavior, companion logic, and player interaction.
Technical Breakdown
Pongo AI System
The AI is built entirely in C++ around a modular Behavior Tree architecture. A central "Brain" tree delegates to specialized sub-trees per state, all coordinated through a custom event bus implemented as a Game World Subsystem — keeping every system reactive without directly depending on the others.
System Architecture
AI Controller
- Owns and runs the Behavior Tree
- Manages all Blackboard keys
- Applies Bonding state changes
- Routes AI events via priority queue
- Saves and loads Pongo's stats across sessions
Pongo Character
- Drives movement speed per emotional state
- Gradually lerps fur color via dynamic materials
- Executes scripted jumps via Smart Nav Links
- Handles all object interaction types
- Hosts the Pet Bar component
AI Event Bus
- Subsystem-based decoupled messaging
- Any system can broadcast events without direct references
- Controller applies them by priority
- Events received mid-air are held in a queue
- Flushed automatically after landing
Emotional State Machine
Pongo has four emotional states — Fear, Curiosity, Rage, and Trust — each triggered by specific objects placed in the level and governed by a strict priority hierarchy (Rage > Fear > Curiosity > Trust). States are unlocked progressively through story events, giving designers full control over which behaviors are active at any point in the game.
Each trigger object in the level carries a sphere component that detects when Pongo enters its range. Before sending the emotional state event, a line trace from the object to Pongo's head checks for visual occlusion: if geometry is blocking the view, a polling timer fires every half second until line-of-sight is clear. This prevents emotional reactions from triggering through walls.
Pongo flees outside a safe escape distance using EQS. Continuously recalculates his path if the source moves.
Pongo navigates toward the object and plays a flavour interaction. Switches focus if a new curiosity object enters range.
Bonding System
Pongo's behavior evolves throughout the game through a Bonding value that drifts up and down depending on what the player does. The value is always clamped within a range tied to the currently unlocked emotional state. When a new state unlocks, the active range shifts — if the current bonding value already falls inside the new range it stays where it is, otherwise it's raised to the new minimum to avoid regression.
Within each emotional range, designers define breakpoints. Every time the bonding value crosses one of these thresholds — upward or downward — a corresponding set of behavioral parameters is applied atomically to the Blackboard. These parameters cover things like how close Pongo stays to Jane when following her, how long he keeps following before stopping, how wide he roams during idle strolling, and how much time he waits before wandering off on his own.
- Color feedback: Pongo's fur color gradually lerps based on state through a dynamic material instance. Emotion colors always take priority over bonding colors and restore on exit.
- Bonding sources: Puzzle completion, petting, and entering fear zones all contribute to the bonding value through a dedicated Behavior Tree task.
- Persistence: The bonding value is saved and reloaded across sessions via the Game Instance.
Companion Behavior & Bongo Commands
When not in an emotional state, Pongo listens to four bongo commands progressively unlocked through story progression: Come Here / Stop, Interact, and Go There. Each command maps to a boolean flag on the Blackboard that the Brain Behavior Tree checks via its main selector. Emotional states always override player commands — the tree evaluates them at higher priority branches.
The Come Here command is handled by a Behavior Tree Service that ticks at a high frequency, continuously projecting the player's world position onto the navigation mesh and updating Pongo's movement destination. A follow-duration timer starts once Pongo gets within a configurable minimum distance of the player — when the timer expires, movement stops and the command flag clears automatically.
Stroll of Fear — active before curiosity unlocks — is managed by a second BT Service that monitors how far Jane is from Pongo at all times. If Jane stays beyond a maximum range for a configurable delay while Pongo is idle, the service performs a physics overlap to check whether any Safe Point actor is nearby. If one is found, Pongo starts walking toward it. The timer resets cleanly on every relevant state change — Pongo moving, Jane returning to range, or no safe point being available.
Pet Bar System
The petting mechanic is managed by a standalone Actor Component attached to Pongo. When Jane pets him, the component clamps the bar, evaluates whether the current level falls in the Reassured, Unconcerned, or Annoyed range, and immediately broadcasts two events: one for the new pet status and one for the corresponding movement speed multiplier. Two independent timers are (re)started — one for gradual bar decay over time, one for resetting the speed boost when it expires.
- Reassured: Speed boost and bonding increase. Re-petting during an active boost restarts the timer rather than stacking the effect.
- Unconcerned: Smaller speed boost and slight bonding gain.
- Annoyed: Pongo flees via EQS to a point away from Jane, using a donut-shaped query that weighs distance from the player. Commands are ignored during the escape. Bonding decreases.
Scripted Jumps via Smart Nav Links
Pongo can only jump in areas explicitly scripted by the level designer through Smart Navigation Links. When the pathfinder routes Pongo through one of these links, the link notifies the character and triggers the jump logic.
The jump arc is calculated using Unreal's projectile velocity suggestion with a designer-tunable arc factor (ranging from flatter/faster to higher/slower). A vertical offset is added to the destination to produce a believable parabola. Pongo's movement mode is forced to falling before launch. If an AI event arrives while Pongo is airborne — a bongo command, an emotional trigger — it's held in a queue on the controller and applied on the very next frame after landing.
Environment Query System
Pongo's movement decisions across behavioral states are driven by several EQS queries, each using custom context objects that read actor references directly from the Blackboard to keep the queries decoupled from hardcoded scene references.
Stroll Point
Generates candidates in a circle around Pongo. Scores them by alignment with the player's forward direction and path length — keeping Pongo from wandering too far or in obviously wrong directions during normal idle strolling.
Escape Point
Generates candidates in a circle centered on the fear source. A custom C++ EQS test scores each point by how far it sits from every emotional trigger sphere in the level — points inside any sphere score zero, fully clear points score maximum. Unreachable points are discarded and the shortest valid path wins. Activated when Pongo enters the Fear state.
Annoyance Point
Uses a donut-shaped generator with inner and outer radius read from the Blackboard. Scores candidates by navigation cost (lower is better) and distance from the player (greater is better) — finds reachable spots away from Jane without wandering too far. Activated when Pongo is over-petted.
Safe Point
Rather than running a full EQS query, the Stroll of Fear BT Service checks for Safe Point actors directly in C++ using a physics sphere overlap. This avoids the query overhead and lets the service enable or disable the Blackboard flag synchronously in the same tick. Only if a valid, reachable safe point exists does Pongo start walking toward it.
The custom C++ EQS test used in the escape query iterates every emotional trigger object in the scene and measures how far each candidate point sits from the nearest sphere boundary, normalized against a configurable max clearance value. This ensures Pongo's escape destinations are always clear of stacked trigger volumes — preventing him from fleeing directly into another fear source.
Camera System
The camera system is a self-contained C++ module paired with a custom Editor plugin. Runtime logic, per-point data storage, and the editor interface live in three separate layers — each independently maintainable and invisible to the other two.
System Architecture
Camera Spline Actor
- Placed in the level, one per room
- Owns the spline and its metadata
- Interpolates camera data by spline distance
- Listens to room enter/exit events
Camera Actor
- Handles runtime camera movement
- Projects the player onto the spline geometry
- Drives bias and location interpolation
- Activates and deactivates per room
Spline Metadata
- Stores camera data per spline point
- Implements the full UE spline metadata interface
- Handles point add, insert, remove, duplicate, fixup
- All curves stay in sync at all times
Editor Plugin
- Custom Details panel in the spline editor
- Per-point field editing with live preview
- Actor picker for bias targets
- Full undo/redo support
Per-Point Spline Metadata & Editor Plugin
Custom Details Panel — per-point camera data in UE5 editor
Each point on the spline stores a full set of camera parameters: rotation (pitch, yaw, roll), spring arm length, lateral and vertical offsets, and three independent interpolation speeds for bias, location, and rotation. A separate slot also stores a reference to an actor the camera should bias its framing toward at that specific spline position.
All parameter curves are kept in sync at all times. Adding, inserting, removing, duplicating, or copying a spline point updates every curve atomically and re-indexes all keys in one pass. A recovery method also handles desyncs caused by editor crashes, copy-paste operations, or mid-edit undo chains — padding any missing entries with the last known value and trimming any excess.
- Adding a point: Inherits values from the previous endpoint as sensible defaults, avoiding sudden visual jumps when extending the spline.
- Inserting a point: Inherits values from the point at the insertion index, then re-indexes everything downstream.
- Duplicating a point: Produces a full copy of all parameters and the bias actor reference at the target index.
A dedicated Editor module injects a custom panel directly into Unreal's spline editing interface. When a designer selects a spline point, the panel shows editable fields for every camera parameter alongside the standard point transform controls — rotation, spring arm length, offsets, interpolation speeds, and bias actor.
- Multi-select support: When multiple points with different values are selected, the panel shows "Multiple" in the relevant fields rather than a misleading single value — matching Unreal's standard multi-edit behavior.
- Undo/redo: Every parameter change is wrapped in a scoped transaction, making all edits fully undoable via Ctrl+Z without any extra setup by the designer.
- Actor picker: The bias actor field uses a filtered object picker that restricts selection to valid scene actors and applies the change immediately to the metadata.
- Live preview: After any change, the viewport refreshes in real time so designers see the updated camera framing without leaving the spline editing mode.
Spline Projection & Position Solving
The camera doesn't simply snap to the nearest spline point. Both the player and the bias target are mapped onto the spline's curved geometry through a two-step projection-and-correction algorithm — necessary because spline arc-length doesn't correspond linearly to the spline's input key values.
First, each position is projected onto the straight corridor axis of the room using a dot product, producing a normalized progress value. That value is multiplied by the total spline length to get an initial arc-length estimate. Then the actual spline position at that distance is compared to the projected corridor point, and the estimate is corrected once by the signed error along the corridor direction. A single correction pass converges accurately for the vast majority of corridor geometries.
- Offset handling: Lateral and vertical offsets are applied in the spline's local rotation space rather than world space, keeping the framing visually consistent regardless of how the spline is oriented in the level.
- Distance guard: If the camera drifts too far from the player in 2D, only the lateral component is clamped — depth and height are preserved from the spline — so the camera never slides sideways while staying on the intended path.
Projection solver — debug visualization in editor
Camera Bias System
The camera doesn't always frame the player at center. A per-point bias value shifts the framing toward a reference actor — for example, biasing the frame toward Pongo when both characters need to be visible at once. Each frame, the active bias is smoothly interpolated toward the spline-driven target value, producing gradual, cinematic transitions as the player moves along the room.
When no reference actor is assigned at the current spline position, the bias fades back to zero gracefully. A secondary low-pass filter is also applied to the reference actor's own position, absorbing sudden teleports or fast movements of the bias target so the camera never snaps unexpectedly.
Camera Bias — weighted framing between player and reference actor
Room Event Integration
Each camera is bound to a specific room and only activates when the player enters it. The spline actor subscribes to a room event subsystem at startup and receives enter/exit notifications by matching the incoming room's level name against its own — allowing multiple cameras to coexist in the same scene without interfering.
When a room activation arrives, the camera broadcasts a change event with a configurable blend time so the Player Controller can smoothly transition the active view. An edge case is handled at startup: if the player spawns inside the room volume, the camera activates immediately without waiting for a movement-triggered event.
Room setup — CameraSpline actor and RoomVolume in editor
Player Look-At System
A procedural Look-At system built in Unreal Engine Control Rig. Pongo orients his head, neck, and torso toward the player fluidly and realistically — no hand-keyed animations required. The system is fully parametric and controllable at runtime from the Animation Blueprint.
Look-At Control Rig
System Pipeline
Sends target position and enable flag to the rig.
across spine, neck, and head.
blended with full undo support.
Look-At Detection
Before enabling the rig, the Animation Blueprint checks that the player is actually in front of Pongo. The check computes a dot product between Pongo's forward vector and the normalized direction toward the player — a value that goes from 1 (directly ahead) to -1 (directly behind).
Direction = Normalize(PlayerLocation - CharacterLocation)
// Dot product with forward
Dot = dot(CharacterForward, Direction)
// Threshold
Dot > 0.5 → Look-At enabled
Dot ≤ 0.5 → Look-At disabled
The 0.5 threshold corresponds to roughly 60° from straight ahead. This prevents Pongo from rotating his head more than 90° laterally or attempting to look behind himself, always keeping the pose anatomically plausible.
Control Rig Structure & Aim Solver
The Control Rig uses three control nodes. The first represents the target position in world space, received at runtime from the Animation Blueprint. The second is the control that feeds the Aim Solver node, oriented toward the target along the character's forward axis. The third adds an optional rotation offset to the torso, contributing to the natural multi-bone spread.
The Aim Solver reads the target position in Location mode and produces the base rotation that is then distributed down the bone chain.
Rotation Distribution
Rather than rotating only the head, the total look-at rotation is distributed across the full bone chain with progressive weights. The spine contributes a small amount, the neck contributes more, and the head carries the bulk. This is the detail that makes the movement feel like a real body rather than a pivot on a single joint.
Interpolation & Spring Behavior
Two layers of interpolation sit on top of the raw rotation to eliminate any rigid or instantaneous movement.
Alpha Interpolation
Controls the global weight of the look-at effect as the system switches on or off. Instead of snapping, the head gradually turns to follow the player and gradually releases when they step behind Pongo.
Clamped to [0, 1]
Spring Interpolation
Simulates the physical weight of the head. When the player moves quickly, the head follows with a slight overshoot and settles back — the same elastic behavior you'd expect from something with actual mass.
Rotation Constraints & Animation Integration
Each bone in the look-at chain has rotation constraints applied to prevent anatomically impossible poses — particularly in edge cases where the spring overshoot would otherwise push a joint past its natural limit. The constraints preserve the bone's offset from its rest pose rather than forcing an absolute rotation, keeping the result consistent regardless of the base animation playing.
In the Animation Graph, the Control Rig node is inserted as a post-processing layer on top of the base animation. The flow is always: play the movement animation, then apply the look-at rig, then output the final pose. Two values arrive from the Animation Blueprint every frame — a boolean indicating whether the look-at should be active, and the player's world-space position as the target.
Skills & Takeaways
What I took away from building the AI, the camera and the look-at system of a 14-person production.
Behavior Tree AI in C++
A central Brain tree with a sub-tree per state, Blackboard keys and EQS queries for stroll, escape and safe points.
Event-driven architecture
An AI event bus built as a Game World Subsystem, with a priority queue, so systems never reference each other.
Editor tooling
A custom Details panel for spline metadata, with multi-select, undo/redo and live preview.
Spline camera maths
Player projection on the spline, per-point metadata and bias, driven by room enter and exit events.
Procedural animation
A Control Rig look-at with an aim solver, rotation distribution and spring interpolation.
Persistent state
Bonding and stats saved and reloaded across sessions through the Game Instance.
Project Overview
Developed as the final first-year project, the brief required to develop a complete FPS built around a randomly assigned profession. We randomly choose the "Tailor" theme and and ended up creating Patch Me If You Can, a fast-paced first-person shooter where the tailor profession dictates every mechanic. Players navigate an arena filled with corrupted puppets, using a specialized toolkit to survive and restore order through precision-based gameplay. Instead of traditional ballistics, the primary weapon is a "Needle Gun" that fires a specialized projectile to tether enemies. Players must manage resource collection (Patches, Buttons, Zippers) to trigger restoration sequences through a modular QTE system.
Contributions
I developed the enemy AI system, including a modular FSM, a perception layer, and a decoupled input system. I also integrated the Unity Job System to handle parallel processing for distance, sensory, and stealth validation.
Technical Breakdown
AI & Gameplay Systems
The enemy AI, input architecture, multithreaded performance systems, and custom editor tooling that form the core of the game's technical foundation.
PATROLLING
INVESTIGATION
ESCAPING
Core Architecture & Locomotion
The gameplay relies on a decoupled Input System powered by Unity’s Action Assets. This architecture acts as a seamless bridge between player commands and a shared interface, allowing dynamic input switching between gameplay, cutscenes, and menus without hardcoding dependencies.
AI & Performance Optimization
Enemy behavior is governed by a modular Finite State Machine, designed to provide clear state transitions while remaining scalable as the system grows in complexity. The architecture follows a decoupled approach where perception and behavior are handled independently, allowing each layer to evolve without introducing tight dependencies.
The perception system combines vision and hearing to drive AI decision-making:
- Vision: Field-of-view based detection with raycast obstruction checks to validate line of sight.
- Hearing: Noise-based triggers that generate investigation states and awareness spikes.
- Awareness System: Detection is time-based rather than binary, allowing gradual transitions between states.
To ensure stable performance with multiple active agents, the system leverages multithreaded parallel processing via the Unity Job System for computationally expensive operations:
- Parallel Distance Calculation: Multithreaded evaluation of player-enemy proximity.
- Sensory Evaluation: Distributed processing of vision and hearing checks across frames.
- Stealth Validation: Optimized dot product and sphere-cast calculations for instant stealth-kill validation.
From a design perspective, the system was built around the following key principles:
- Decoupling: Perception systems are separated from behavior logic to reduce coupling and improve scalability.
- State Modularity: States are structured through interfaces to prevent monolithic logic and keep each state focused.
- Awareness Modeling: Detection is gradual and time-based, improving realism and player readability.
- Extensibility: The architecture is designed to support future migration to Behavior Trees or Utility AI systems.
- Debuggability: The system allows clear visualization of perception data and state transitions for easier iteration.
AI Runtime Structure
Player Stimuli
- Movement speed
- Noise generation
- Position in FOV
- Stealth interaction range
Perception Layer
- Vision checks
- Raycast obstruction validation
- Noise evaluation
- Stealth-kill validation
Decision Core
- Awareness accumulation
- Threat assessment
- State transition logic
- State resolution
Behavior Output
- Patrolling
- Investigation
- Escaping
- Audio / OST feedback
Rather than relying on a strictly linear pipeline, the AI is structured as a set of interconnected layers. Player-generated stimuli feed the perception systems, which in turn update the decision core through awareness accumulation and state evaluation.
The resulting state then drives enemy behavior and propagates feedback back to the player through movement, animation, and audio cues. This layered structure improves readability, scalability, and debugging.
This layered flow helps keep the AI readable and maintainable: the player generates stimuli, the perception layer evaluates them, awareness determines how serious the threat is, and the state machine selects the appropriate behavior. This makes the system easier to tune, debug, and extend with new states or future decision-making layers.
Skills & Takeaways
What I took away from building enemy AI and its performance layer in Unity.
State-machine AI
A modular FSM with interface-based states: patrolling, investigation and escaping.
AI perception
Field-of-view vision with raycast checks, hearing, and time-based awareness instead of instant detection.
Multithreading
The Unity Job System for parallel distance, sensory and stealth-kill validation.
Decoupled input
Action Assets behind a shared interface, switching between gameplay, cutscenes and menus.
Project Overview
As the first mobile project at DBGA, the brief required the development of a casual mobile game with local multiplayer dynamics featuring at least one single-mechanic minigame unified by a common theme. Our team developed Takaindest, a 2D casual local multiplayer game themed around "extreme kindness". The core loop focuses on fast-paced matches and frantic action, rewarding players with Darumas that unlock cosmetic skins. The game centers on a synchronized reaction mechanic where players don't attack, but must respond to randomized visual cues to perform helpful actions. Each minigame is designed for landscape mode with a dual-input split-screen system: the left side for Player 1 and the right side for Player 2. This requires players to manage timing and reflexes simultaneously on the same device while maintaining a competitive balance through a best-of-five round structure.
Contributions
I contributed to the development of all three mini-games, with a primary focus on the first one, Check Mates. I built the round system, including victory and draw conditions, making it compatible with every mini-game, and implemented event-driven communication through the proxy architecture. I also developed the cloud-enabled Addressables loading system using Unity Cloud Content Delivery, as well as the audio manager, in-game currency system, and monetization flow.
Technical Breakdown
Check Mates
Check Mates, the first mini-game of takaindest. It’s a fast-paced duel where two players swipe sequences on opposite sides of the same device, testing memory and reflexes. I defined rules for rounds (best of 5), victory conditions, input management, and error handling, ensuring smooth feedback and competitive balance. The mechanic emphasizes simultaneous play, quick decision-making, and humorous visual rewards to fit the game’s theme of “extreme kindness.”
Game Architecture
The proxy-based decoupling pattern, round management system, and cloud-enabled content delivery pipeline that underpin the entire project.
Proxy-Based System Architecture
The project is structured around a proxy-based architecture designed to decouple core systems and reduce direct dependencies between gameplay components.
Instead of allowing systems to communicate directly with each other, interactions are mediated through centralized proxy layers, ensuring better control, scalability, and maintainability.
- System Isolation: Core systems (Player, Audio, AI, UI) do not communicate directly but through proxies.
- Centralized Access: Proxy classes act as controlled entry points to shared systems.
- Loose Coupling: Reduces hard references between components, improving flexibility.
- Modular Design: Systems can be modified or replaced without breaking dependencies.
This approach was particularly useful for managing interactions between:
- Gameplay logic and audio feedback systems
- Player actions and global game state
- UI updates and underlying gameplay systems
By introducing proxy layers, the architecture avoids tight coupling and enables a more scalable system design, especially as the project grows in complexity.
Round System
Modular Round Manager in Unity that controls all match phases — from countdown and round management to winner declaration. The system integrates a dynamic timer, score tracking, draw/victory/game-over logic, and supports monetization and persistent saves. Communication between systems is handled through an event-driven proxy system, where the Round Manager dispatches events (round start, round end, game over) received only by interested components. This decoupled design keeps the architecture scalable and maintainable. Real-time adaptive audio and UI elements (announcer voices, round music, victory/draw messages) ensure a polished, reusable gameplay framework.
Network Architecture
I developed a cloud-enabled scene loading system that uses Unity Cloud Content Delivery to provide seamless live content updates. The system manages remote catalog updates, ensuring that new assets and scenes can be delivered to players without requiring a full application rebuild or store resubmission. This architectural decision was driven by the need to avoid frequent build updates when adding new minigames and cosmetic content, as well as to keep the application size under the 100MB limit defined by the project brief. By combining asynchronous loading, memory-safe unloading, and a dynamic UI flow, players experience smooth transitions and reduced load times. The architecture follows a network-driven, modular approach: the client communicates with Unity Cloud to retrieve updated content bundles, while the UI reflects download progress, error states, and ready-to-play notifications in real time. This allows for continuous delivery of new levels, seasonal content, or patches directly to the game. In addition, the system is optimized for scalability, enabling integration with remote configuration, analytics, and content versioning. This approach not only improves performance and player experience but also streamlines the production pipeline, empowering developers to deploy new content instantly across platforms without disrupting gameplay.
Skills & Takeaways
What I took away from building the shared systems of a mobile minigame collection.
Proxy architecture
Player, audio, AI and UI talk through proxy classes, which keeps the systems loosely coupled.
Reusable round system
One round manager (countdown, score, win, draw, game over) shared by every minigame through events.
Remote content delivery
Addressables with Unity Cloud Content Delivery, so new minigames and skins arrive without a new build.
Mobile game services
Audio manager, in-game currency and monetization flow, with persistent saves.
Project Overview
Midnight Wishes is a narrative point-and-click built in 4 days for the GMTK Game Jam 2026 in Unreal Engine 5. The player opens on a blank note and writes their own wish, then lives through five short New Year's Eve vignettes — a beach, a hospital rooftop, a parking lot, a lakeside gathering, a family dinner — each hiding one correct sequence of interactions among several plausible ones. Once every memory has been visited, the game reveals every character's wish on a wall of paper notes and hands the player a lighter: burn the notes that were "earned" correctly, and any wrong ones simply refuse to catch fire. Get it all right and the five scenes reunite for a shared midnight, followed by the chance to burn — and let go of — the player's own wish.
Contributions
I was responsible for the full programming side of the project: the tag-driven scene progression architecture shared by all five memories, the point-and-click interaction and hover system, the wish-writing and note-burning meta-game that bookends the experience, and the loading screen transition between levels.
Technical Breakdown
Scene Flow & Progression
A Game Instance Subsystem tracks every memory's progress across level loads, drives which level opens next, and manages a dedicated retry pass for scenes the player got wrong — all without any per-level hardcoding in the Game Mode.
System Architecture
Game Flow Manager
- Game Instance Subsystem, persists across levels
- Registers each scene's progress by Wish ID
- Resolves success/failure and queues a retry pass
- Stores the player's own written wish
Game Mode
- Binds to the flow manager's level-change event
- Activates the tagged scene camera on load
- Runs the per-scene countdown timer
- Guards against double-resolving a scene
Loading Screen
- Opens fully opaque before the first tick
- Hides the fresh level loading underneath
- Fades out only once the scene is ready
- Cycles rotating hint phrases while held
Retry Queue & Level Sequencing
After the first pass through all five memories, any scene the player failed is queued for a dedicated retry pass rather than restarting the whole game. The next level to load is resolved through a single function that checks whether a retry pass is active: if so it drains a queue of only the failed levels; otherwise it walks the full level list in order. When the retry queue empties, control returns automatically to the notes screen.
A guard flag on the Game Mode prevents a scene from being resolved and advanced twice — useful since both a successful interaction chain and the countdown timer running out can independently trigger scene resolution.
Loading Screen Transitions
The loading widget runs two independent state machines in its tick. The first is a simple opacity fade covering the screen transition itself. The second governs a rotating hint phrase, supporting either a cross-fade or a typewriter reveal, and avoids repeating the same phrase twice in a row by tracking the last one shown. While the screen sits fully black and idle, a timer automatically cycles to the next phrase.
The Game Mode spawns this widget already fully opaque before anything else happens on
BeginPlay, so the player never sees a flash of the freshly loaded level — the
actual scene only starts once the fade-out has fully completed.
Data-Driven Scene State Machine
Every memory — from the beach's blanket-then-lighter puzzle to the family dinner's ketchup pentagram — runs on the exact same state machine, driven entirely by a per-scene transition table rather than bespoke Blueprint logic.
Tag-Based Transition Table
Each scene owns a data asset describing its puzzle as a table of transitions: current state + incoming action tag → next state + an event tag to broadcast. When the player interacts with an object, the controller looks up the matching row for the scene's current state; if none exists, the interaction is simply ignored — which is what makes clicking objects "out of order" safe by design rather than something that needs to be explicitly blocked.
A matched row can flag the transition as a failure (wrong sequence), a success, or scene-ending, and can point to a Level Sequence to play for its event tag — covering things like the antenna-turning "no signal" buzz on the hospital roof or the star lighting up on the beach. Reaching the scene's designated success state marks it complete and reports the result back to the Game Flow Manager by its Wish ID.
Point & Click Interaction Layer
A custom Player Controller traces under the cursor every frame using Unreal's built-in deprojection, with optional debug drawing of the ray, impact point, and hit normal for tuning click targets during development. Enhanced Input maps a single click action that, on the object currently under the cursor, forwards to a lightweight interactable base class.
Every interactable object carries just one property — a gameplay tag identifying its action — and forwards it to the active scene controller on click. This keeps level design fully decoupled from puzzle logic: placing a new interactable and tagging it correctly is enough to wire it into the transition table, no per-object scripting required.
A dedicated hover widget follows the currently hovered interactable's world-space hover point, projected to screen space every frame, giving the player a consistent visual cue across every scene regardless of camera angle. Input can also be globally toggled — used to lock interaction during countdowns, sequences, and scene transitions.
Wish & Burning Note System
The meta-game that opens and closes the experience: writing a wish, then dragging a lit lighter across a wall of paper notes and watching the wrong ones refuse to catch.
Wish Input
The opening screen is a character-limited text field: input beyond the configured cap is truncated live and reported back through a Blueprint event, so UI feedback (e.g. a red flash at the limit) can be handled independently from the truncation logic itself. On submit, the wish text is handed to the Game Flow Manager, where it's stored for the finale.
Draggable Lighter
The lighter widget follows the cursor every tick, converting the absolute mouse position into its parent panel's local space and clamping it to the panel bounds so it can never drag off screen. Igniting it plays a short animation before the flame becomes active; while unlit, every watched note is explicitly told it isn't being touched by fire, so no burn progress can accumulate before the flame is actually live.
Once lit, the widget checks every registered note's screen-space bounds against the flame's current position each frame using widget geometry hit-testing — no physics or collision involved, since this is a straightforward UI-space overlap.
Burnable Notes
Each note accumulates burn time only while the flame overlaps it and it hasn't already burned; moving the flame away resets that progress rather than pausing it, so a note has to be held continuously for its full duration to succeed. A note flagged as belonging to the wrong wish rejects the flame immediately instead of accumulating anything — broadcasting a failure result the moment it's touched rather than after a delay.
Successfully burning a note reports its result — whether it was correct, which memory it belongs to, and whether it's the player's own wish note — to the widget orchestrating the finale, which reacts differently depending on which of those three is true.
Finale Orchestration
On entering the notes screen, one burnable note widget is spawned per memory that hasn't already been burned in a previous visit, and slotted into a named UMG slot matched to its Wish ID — so a scene the player retried and finally solved simply stops respawning its note. Each spawned note is registered with the lighter so it starts reacting to the flame immediately.
The player's own wish note stays disabled until every memory's note has been burned — checked against the persistent state kept by the Game Flow Manager, not just the notes currently on screen, so the check still holds correctly across a retry pass. Burning it triggers the ending; a separate action lets the player kick off a full restart of the game's progress.
Skills & Takeaways
What I took away from programming a complete narrative game in four days.
Game Instance Subsystem
A flow manager that persists across levels, tracks every scene by Wish ID and queues a retry pass.
Data-driven state machine
Each scene is a transition table in a data asset: state and action tag in, next state and event out.
Gameplay Tags
Interactables carry a single tag, so level design stays separate from puzzle logic.
Point-and-click input
Cursor tracing, Enhanced Input and a hover widget projected from world space to screen space.
Transitions and UI
A loading screen that hides the level load, with fades, rotating hints and a typewriter option.
Jam delivery
The whole programming side of a two-person team, finished in four days.
Project Overview
Ramiel: The Mimic Demon is a third-person stealth game built in 48 hours for the Global Game Jam 2026. You play as a Botchling — a cursed creature whose mother and unborn self were killed by order of the castle king. Ramiel grants you a second chance to return, reclaim your body, and embrace your demonic powers to infiltrate the castle and reach the king who condemned you. The game offers two paths to vengeance: kill every soldier and confront the king directly, or find the cursed relic, possess the corrupt priest, and manipulate your way to the throne. The choice is yours.
Contributions
I was responsible for the complete AI systems for all enemy types, the player's mimic and possession mechanics, and the combat system. I also handled the team and faction setup, along with the overall game flow, including win conditions and dual-ending logic.
Technical Breakdown
Enemy AI System
Two enemy types built in C++ on a shared base, with a full AI Perception setup, team affiliation, and a proximity-scaled gradual detection meter.
AI Architecture — Two Enemy Types
The game has two distinct enemy types, each built in C++ on a shared base that handles common infrastructure — spline-based patrol waypoints, team affiliation, and the AI Perception configuration. Both enemies use Behavior Trees driven by Blackboard flags, with their controllers handling all detection logic and Blackboard writes in C++.
THE PRIEST
A pure sight-based detection enemy. The moment the Priest spots the player he
broadcasts a noise event at his own location with a configurable radius —
alerting every Soldier within range simultaneously. He then faces the player
and plays his shout animation until the player leaves his line of sight.
The alert flag resets when the player is lost, so he can raise the alarm
again on the next sighting.
The Priest is also possessable — when the player carries the relic and interacts
with him, control transfers to the Priest character, unlocking the alternate ending.
THE SOLDIER
A dual-sense enemy that combines sight and hearing. On top of standard FOV
detection, Soldiers receive noise events — meaning the Priest's shout pulls
them directly to his location. In combat, the Soldier chooses between melee
and a ranged throw based on distance. The ranged attack uses the player's
current velocity to compute a lead vector, giving it mild predictive tracking
rather than firing straight at the player's feet.
Soldiers also respond to the player's Investigate state: when they lose
sight of the player they move to the last seen position before returning to patrol.
Perception System & Team Affiliation
Perception is configured entirely in C++ on the base controller. The sight sense covers a 5000 unit radius with a 90° peripheral angle, configured to detect enemies and neutrals but not friendlies — preventing soldiers from reacting to each other's presence. Soldiers additionally have a hearing sense with a 2000 unit range and a short stimulus age, used to receive the Priest's alarm noise event.
Team affiliation is handled through Unreal's Generic Team Agent interface, implemented on both the AI base character and the player character. Each entity carries a team ID; the attitude check returns Hostile, Friendly, or Neutral based on whether the IDs match. Friendly stimuli are filtered out of perception callbacks, keeping the AI event handlers clean and focused on real threats.
Gradual Detection Meter
Detection isn't instant — the Soldier builds up awareness over time while the player is in its field of view. Every frame the player is visible, an accumulator increases at a rate scaled by proximity: the closer the player, the faster the fill. When the player leaves the FOV, the accumulator drains at a separate configurable speed. Once the accumulator reaches its maximum, the Soldier fully detects the player and alerts nearby allies.
The normalized value of this accumulator is broadcast every frame as an event on the Soldier character — driving the detection indicator on the player's UI in real time without any direct coupling between the AI and the UI.
Player Systems
The mimic transformation mechanic with its three stealth edge cases, and the two-option combat system including the charged spring attack.
Mimic Ability & Stealth Visibility
When near a valid object, the player can transform into it. The AI detection system queries the player's current state through a Blueprint interface implemented on the player character. This interface exposes two questions: is the player currently transformed, and is the player currently moving?
The Soldier's detection tick uses this information to decide whether to accumulate awareness. If the player is transformed and stationary and was not seen transforming, awareness accumulation is suppressed entirely — the Soldier looks right past the player without reacting. Three edge cases are handled explicitly:
- Transform while visible: If the Soldier already has the player in its FOV when the transformation happens, it sees the change and marks the player as spotted — no stealth benefit.
- Moving while transformed: Moving objects attract attention. A transformed but moving player is still treated as visible.
- Full detection carries over: Once the accumulator is full and the player is marked as seen, the transformed state provides no additional cover — the Soldier is already in full alert.
Player Combat — Melee & Spring Attack
The player has two attack options. The basic melee is a close-range strike that kills enemies in one hit — as does being hit, making every engagement high-stakes. The second option is a charged spring attack: the player holds the right mouse button and pulls the mouse backward to charge; releasing launches the character toward the nearest enemy in the aim direction, killing on impact. The farther the pull, the longer the travel distance.
Both attacks play through animation montages with socket-based collision windows. During the active hit frames, a collision trace fires from the weapon socket; on contact the target receives damage and a gameplay event that triggers hit reactions and, if lethal, triggers the death sequence through a Blueprint interface both enemy controllers subscribe to — cleanly separating the kill signal from the AI state cleanup logic.
Game Flow & Dual Endings
Two parallel win conditions tracked simultaneously, with possession transferring full player control to the Priest character for the alternate ending.
Game Flow & Dual Endings
The game tracks two parallel win conditions simultaneously. The first: all enemies are dead and the player reaches the king's chamber. The second: the player finds the relic, possesses the Priest, and walks to the king as him.
Possession works by transferring the player controller from the Botchling to the Priest character — the Priest's Blueprint handles the Possessed event, switches the active view target with a blend, hides the original body, and re-maps all input to drive the Priest's movement and camera. From the outside, the player is now literally walking as the enemy. Reaching the king in this state triggers the manipulation ending, while doing so with the original body and an empty castle triggers the slaughter ending.
Skills & Takeaways
What I took away from building AI, stealth and combat in a 48-hour jam.
Enemy AI in C++
Two enemy types on a shared base, using Behavior Trees driven by Blackboard flags.
AI Perception and teams
Sight and hearing senses, and team affiliation through the Generic Team Agent interface.
Gradual detection
A proximity-scaled awareness meter, broadcast as an event to the UI without coupling.
Stealth mechanics
A mimic ability that reads the player state, with edge cases for transforming and moving in view.
Combat
A melee attack and a charged spring attack.
Game flow
Win conditions and dual-ending logic.
Project Overview
Tatuchatoi is a first-person adventure and platformer set on a stylized, corrupted island. Developed in just one week with a team of 11 members, the challenge was to create a cohesive first-person experience blending atmospheric exploration with environmental hazards and platforming challenges. Guided by the enigmatic "Old Clairvoyant", players must wield the mystical Fire Scepter to navigate a series of twisted trials, ignite the Flames of Rebirth, and attempt to outsmart Fate itself. The core gameplay loop tasks the player with finding and lighting various braziers scattered across distinct zones, including a graveyard, a dense hedge maze, and surreal floating neon platforms. Survival requires precise jumping mechanics and sharp reflexes to dodge hazards like rotating laser grids.
Contributions
I implemented the player movement mechanics, including dash and wall run, along with the reusable Audio Actor Component and the zone-based soundtrack system. I also contributed to the majority of the puzzles.
Technical Breakdown
Player Mechanics
Dash and wall run — two movement abilities built in Blueprints with multi-condition validation, velocity-based impulse, and clean state reset on exit.
Player Mechanics — Dash
The dash validates multiple conditions before committing — checking grounded state,
no active dash, and valid input. Once triggered, it reads the current movement direction,
applies a velocity impulse, and sets a Dash Timer that will cancel it.
Player Mechanics — Wall Run
Wall running uses a Sphere Trace cast laterally to detect
surfaces tagged Wallrun. On hit, gravity is zeroed and the wall run direction
is computed via cross product between wall normal and world up vector,
validated against the player's forward via a dot product — a
SelectInt node picks left or right based on the sign.
The wall jump computes a rotated launch vector from the wall normal, fires
AddImpulse, and immediately calls StopWallRunning
which restores gravity and resets the state.
Audio Architecture
A reusable Audio Actor Component with six purpose-built functions, paired with a zone-driven OST crossfade system decoupled from level geometry.
Audio Component
Instead of scattering audio nodes across every Blueprint, I built a reusable Audio Actor Component with six functions the rest of the project could call without duplicating logic:
PlaySound
Plays only if AudioComponent isn't already playing to prevents overlap.
PlaySoundAtOnce
Stops the current sound and immediately plays the new one — for interrupting audio mid-play.
PlayRandomSound
Picks a random entry from a Sound array — used for varied SFX on repeated interactions.
PlaySoundOneTimeAtLocation
Same one-shot logic with Play Sound at Location for spatialized world-space SFX.
StopSound
Clean stop for looping sounds on state exit.
Soundtrack System — Zone-Based OST with Crossfade
The OST changes dynamically as the player moves through zones, split across
BP_SoundTrack and BP_SoundZone to keep the music
manager decoupled from level geometry.
-
BP_SoundZone is a Box Collision actor placed by designers. On overlap begin/end,
it calls
ChangeSoundTrackon itsBP_SoundTrackreference, passing the assigned audio. - ChangeSoundTrack guards against redundant changes and mid-transition calls, then sequences a FadeOut on the current track followed by a timer FadeIn on the new one.
-
FadeOut / FadeIn use UE's native audio fade nodes with configurable duration floats,
sequenced via
Set Timer by Eventwith a dynamically created event callback. -
Death integration: On
BeginPlay, the SoundTrack binds to the player'sOnDiedispatcher. On death it triggersChangeSoundTrackCustomFadeOutwith a fade — bypassing zone logic for immediate audio feedback.
Skills & Takeaways
What I took away from building movement and audio in a one-week team jam.
Movement mechanics
Dash and wall run in Blueprints, with condition checks, velocity impulses and a clean state reset.
Surface detection
Wall running uses a lateral sphere trace on surfaces tagged as runnable.
Reusable audio component
An Audio Actor Component that any actor can use.
Zone-based soundtrack
Designer-placed sound zones with fade-out and fade-in crossfades, and a reaction to player death.
Project Overview
The Bubble is a horror exploration game built during a one-week game jam with a full team of 10. The player navigates an oppressive environment while being hunted by an AI entity that reacts not just to proximity, but to the world around it — teleporting through the level and tracking down collectibles as a way to corner the player. Rather than a simple chase enemy, the AI was designed to feel unpredictable and aware, reacting to events in the world rather than just following the player's position. The teleport mechanic in particular was meant to create sudden, disorienting encounters that break the player's sense of safety. My responsibilities covered the enemy AI system and part of the gameplay logic, including the collectible and teleport systems that feed directly into the enemy's decision-making.
Contributions
I built the enemy AI system, featuring a three-state patrol/chase/attack loop, a stuck-state recovery system, and event-driven reactions such as collectible redirection and teleport relocation.
Technical Breakdown
The Bubble was my first experience building an AI system under a real jam deadline, within a large team. The scope was intentionally limited, but the constraints pushed me to think about event-driven design and how enemy behavior can extend beyond simple player-tracking.
Enemy AI System
A lightweight three-state FSM — Patrol, Chase, Attack — driven by sphere overlap checks and a stuck-timer fallback that prevents the enemy from freezing mid-path.
Enemy AI — State-Based Behavior
The enemy operates on a simple but effective three-state logic evaluated every frame: Patrol, Chase, and Attack. State transitions are driven by two sphere overlap checks — a wider perception range and a tighter attack range — keeping the system lightweight and easy to tune without a formal FSM framework.
- Patrol: The enemy picks a random point on the NavMesh within a configurable radius and walks toward it, then picks a new one on arrival.
- Chase: When the player enters the perception range, the agent calculates a full NavMesh path before committing to the chase — falling back to patrol if the player is unreachable. A stuck timer prevents the enemy from freezing indefinitely if the path becomes invalid mid-chase.
- Attack: At close range, the enemy locks its destination, faces the player, and fires attacks at a fixed interval.
Event-Driven World Reactions
The AI reacts to world events through static C# delegate events — collectible pickups redirect its walk target, and teleport triggers bypass level geometry entirely.
Event-Driven World Reactions
The most interesting part of the AI isn't the chase — it's how it reacts to world events through a decoupled event system. Two delegate events drive this behavior:
- Collectables.OnCollected: When the player picks up a collectible, the enemy immediately redirects its walk point to that position — as if it heard the interaction. This creates a tension loop where collecting items draws the enemy closer.
- Teleport.OnTeleport: When a teleport trigger activates, the enemy's navigation agent is disabled, the enemy is moved to the teleport destination, and the agent is re-enabled. This lets the enemy bypass level geometry and appear in unexpected locations, breaking the player's spatial expectations.
Both events are subscribed and unsubscribed cleanly in the standard enable/disable lifecycle callbacks, avoiding stale listeners across scene reloads.
Collectibles & Manager
Each collectible runs a distance check against the player every frame, managed by a central collectible tracker, which iterates the list in reverse to safely remove entries mid-loop. On collection, the pickup event fires before the object is destroyed — ensuring the AI receives the world position before the reference is gone. It's a small detail, but it matters for event ordering correctness.
Skills & Takeaways
What I took away from building my first AI under a real jam deadline.
State-based AI
Patrol, Chase and Attack on the NavMesh, with a full path check before the chase starts.
Stuck recovery
A stuck-timer fallback that keeps the enemy from freezing mid-path.
Event-driven reactions
The enemy reacts to collectible pickups and teleports through events, with no direct references.
Event ordering
The pickup event fires before the object is destroyed, so the AI always gets a valid position.
Project Overview
The project is built around a set of modular gameplay systems designed to be scalable, maintainable, and easy to extend over time. Rather than focusing only on features, I used this project to explore production-oriented architecture in Unreal Engine, with particular attention to gameplay abilities, AI behavior, wave management, and clean separation between systems.
Contributions
I designed and implemented the core architecture: a custom GAS setup with attribute set hierarchies and damage execution logic; data-driven character configuration; and a tag-driven input component. I also developed the TPS shooting system, an AI controller with Detour Crowd integration, the wave pipeline (Subsystems-based), and the UI component architecture.
Technical Breakdown
Gameplay Ability System
Custom ASC with tag-based input routing, attribute set hierarchy, PostGameplayEffectExecute damage flow, and a custom ExecCalc for stat-scaled damage.
Gameplay Ability System (GAS)
Combat and character progression are built around Unreal Engine’s Gameplay Ability System.
Instead of using it only as a plug-and-play framework, I used it as the foundation for a more
structured and scalable combat architecture.
Abilities, attributes, and combat interactions are organized in a data-driven way, allowing different characters and enemies to share the same core logic while still supporting unique behaviors and playstyles. This made it easier to expand the project without tightly coupling combat rules to individual actors.
A major focus was building a clean flow for damage handling, stat scaling, and state transitions such as death, while keeping gameplay events reusable across different systems like UI, AI reactions, and visual feedback.
Input & Character Data
Fully data-driven character configuration through PlayerData, EnemyData, and selection assets, paired with a tag-driven input component supporting one-shot and hold abilities.
Data-Driven Character Configuration
Character setup is fully data-driven, with classes, abilities, and combat parameters configured through reusable assets rather than hardcoded values. This approach keeps the gameplay layer flexible and makes it much easier to create or rebalance characters without rewriting logic.
The same structure is shared across both players and enemies, which helps maintain consistency between different gameplay entities while reducing duplication and improving iteration speed.
Tag-Driven Input System
Input handling is designed to be modular and ability-friendly, allowing gameplay actions to be mapped through tags instead of relying on rigid direct bindings. This makes the input layer much easier to scale when introducing multiple classes, unique abilities, or alternate control behaviors.
By separating player actions from concrete implementation details, the system stays flexible and supports a cleaner connection between input, abilities, and gameplay feedback.
Shooting & AI System
Dual-trace TPS shooting with angle validation and minimum distance guard, plus a Behavior Tree–driven AI controller with Detour Crowd avoidance.
Shooting System
The shooting system was designed to ensure that aiming feels accurate from the player’s perspective while remaining reliable in third-person combat situations. To achieve this, the aiming logic takes both camera direction and weapon position into account, reducing common issues such as shots clipping into nearby geometry or feeling visually inconsistent.
This approach improves readability and responsiveness in combat, especially in close-range situations where player expectation and actual projectile behavior can easily fall out of sync.
AI Controller & Crowd Avoidance
Enemy behavior is built around Behavior Trees, with the controller layer responsible
for initialization, shared logic, and coordination between movement and decision-making.
A key focus was making enemies feel readable while still behaving well in group combat. To support this, I integrated crowd-aware navigation so multiple enemies can move and reposition around the player without constantly colliding or stacking unnaturally.
This helped create cleaner combat spaces and more believable enemy pressure, especially during larger wave encounters.
Wave Pipeline & Infrastructure
A modular wave pipeline across three World Subsystems, an IPoolable-based object pool for enemies and projectiles, and a delegate-driven UI architecture decoupled from gameplay.
Wave & Round System
The wave system is built as a modular gameplay flow that separates round progression, enemy spawning, and spawn-point selection into distinct responsibilities.
This structure makes it easier to scale encounter complexity over time, since new wave rules, enemy compositions, or pacing adjustments can be introduced without rewriting the entire combat loop.
The result is a cleaner encounter pipeline that supports replayable combat and gives the project a stronger roguelite-style progression structure.
Object Pooling
To improve runtime performance during combat-heavy encounters, the project uses object pooling for frequently reused gameplay actors such as enemies and projectiles.
Instead of constantly spawning and destroying actors during each wave, gameplay objects are recycled and reset between uses. This reduces overhead and helps keep combat more stable during intense moments with multiple enemies and repeated attacks on screen.
This was especially important for maintaining smoother pacing in a wave-based structure where the same gameplay entities are repeatedly reused.
UI Architecture
The UI layer is designed to stay loosely coupled from gameplay logic, so combat systems can communicate important state changes without creating direct dependencies between characters and widgets.
Health updates, damage feedback, and ability state changes are exposed through a reusable communication layer, allowing the interface to react cleanly to gameplay events while keeping the core systems independent.
This approach made the UI easier to maintain and better aligned with the overall goal of building scalable, production-style systems.
Skills & Takeaways
What I took away from building a scalable combat and wave architecture.
Gameplay Ability System
A custom ability system component, attribute set hierarchy, damage flow and stat-scaled execution calculation.
Data-driven design
PlayerData and EnemyData assets shared by players and enemies.
Tag-driven input
Gameplay tags route input to abilities, for one-shot and hold actions.
Third-person shooting
Dual-trace aiming with angle validation and a minimum distance guard.
AI at scale
Behavior Trees with Detour Crowd avoidance for group combat.
Production architecture
A wave pipeline across three World Subsystems, an object pool for enemies and projectiles, and delegate-driven UI.
Project Overview
SM to ISM is an Unreal Engine editor tool I built to batch-convert placed Static Mesh Actors into Instanced or Hierarchical Instanced Static Mesh components. It groups the actors by itself, so scenes with lots of repeated props need far fewer draw calls without any manual sorting.
- Right-click in the level editor, or call it from Blueprint, Python or a build pipeline.
- Groups by mesh, materials, level and Custom Primitive Data compatibility.
- One-click revert to individual, movable actors, with Undo/Redo support.
- Works with ISM or HISM, chosen as a setting.
Contributions
Designed and implemented the full grouping/conversion logic, the Blueprint-exposed API, the revert-to-actors workflow, and the Custom Primitive Data handling described below.
Performance Impact
Test scene: 2,450 static mesh actors (two meshes repeated on a grid), Nanite disabled,
Unreal Engine 5.6. The overlay is stat initviews, which shows what the
renderer has to process every frame to decide what is visible.
| Before | After Convert to HISM | |
|---|---|---|
| Actors in the levelObjects placed in the level, as counted by the World Outliner. | 2,459 | 11 |
| Processed primitivesRenderable objects the engine has to look at every frame. | 2,470 | 22 |
| Occlusion queriesGPU tests that ask whether an object is hidden behind another one. | 2,461 | 13 |
| Visible static mesh elementsStatic meshes that survive culling and are actually drawn. | 2,453 | 3 |
| Compute View RelevanceCPU time spent deciding how each object must be rendered. | 3.55 ms | 0.03 ms |
The scene looks identical before and after: the conversion only changes how the meshes are submitted to the renderer. Every individual actor is a primitive that must be culled, tested for occlusion and set up for drawing on each frame. Grouping identical meshes into two HISM components removes almost all of that per-primitive work.
The gain is on the CPU side and grows with the number of actors: in a larger test (about 12,100 actors) the median frame time went from 13.9 ms to 10.1 ms and draw calls from 1,199 to 227. In GPU-bound scenes, or with Nanite meshes, the frame time changes very little.
Technical Breakdown
Grouping & Conversion
Selected actors are grouped by static mesh, material set (order-independent), level and Custom Primitive Data compatibility, so a mixed selection can be run through the tool without any manual sorting. Each group becomes a single ISM or HISM component (the choice is exposed as a setting), preserving shadow, LOD, lightmap and Custom Primitive Data from every source actor.
ISM vs HISM
ISM keeps management overhead low and has no spatial structure: every instance is considered every frame, which suits objects that move or spawn/despawn often at runtime. HISM adds a BVH on top, so entire branches of off-screen or occluded instances can be skipped without per-instance testing. It is built for large, mostly-static instance counts like foliage, rocks or debris fields.
Revert Workflow
Any converted group can be expanded back into individual, movable Static Mesh Actors with a single call, restoring mesh, materials, shadow/LOD/lightmap settings and Custom Primitive Data on each recreated actor. So a convert → revert → re-convert through the level editor doesn't lose anything.
Blueprint & Settings
The same conversion is exposed as Blueprint functions that take a settings struct, so it can run from an Editor Utility Widget or a build script, not only from the context menu.
Custom Primitive Data & Engine-Level Considerations
A material can read a Custom Primitive Data slot in two different ways: through a Per Instance Custom Data node, where every instance in the same ISM/HISM can hold its own value, or through a generic Custom Primitive Data read, where the value is shared by the whole component. A converter that doesn't distinguish the two will silently produce wrong visuals the moment two actors with different values for the second kind end up grouped together, since the engine has no way to give them different values once merged. The tool inspects each material's expression graph to classify every Custom Primitive Data index this way, and folds that classification into the grouping key itself — actors whose shared values don't match are automatically kept in separate ISM/HISM components instead of being merged into one with lost data.
Separately, SetCustomPrimitiveDataFloat() — the API used to set this data
from C++ — is explicitly
documented as run-time only and not serialized: a value set
this way renders correctly right away, but is lost on the next level reload, on
entering Play In Editor, or in a packaged build. To fix this properly rather than work
around it in the editor session only, the tool attaches a small helper component that
stores the values as a real, serialized property and reapplies them whenever the
actor's components register — covering editor load, PIE and packaged builds with a
single mechanism, and giving the data one authoritative place to live and be edited
afterwards.
Skills & Takeaways
What I took away from building an editor tool that other developers can run on a real scene.
Editor tool development
A right-click action plus a Blueprint and Python API, with settings and Undo/Redo support.
Rendering optimisation
ISM and HISM trade-offs: instancing, BVH culling and far fewer draw calls.
Material graph analysis
Reading expression graphs to tell per-instance from shared Custom Primitive Data.
Engine internals
A serialized helper component, because the C++ setter for Custom Primitive Data is runtime-only.
Non-destructive workflow
A revert that restores mesh, materials, shadow, LOD, lightmap and data on every actor.
Project Overview
Camera Spline is an Unreal Engine 5 plugin for the majority of side-scrolling and 2.5D games. The camera runs on a rail, a spline, and follows the player through the room. Every room has its own camera and volume, and entering a room blends the view to that camera with an ease in / ease out transition.
The goal is to create a cinematic camera that is still fully controllable by the player, and to speed up the development process by providing real time preview of the runtime camera in editor, without needing to compile and run the game.
Contributions
Designed the camera, then built the runtime camera, the editor tools and the Level Sequence export.
Tools: Unreal Engine 5, C++, Slate, Sequencer, Python / Blueprint API
Camera Design
The camera is built from a few rules. Each one is drawn here from above, as it works in the plugin.
Following the player
The camera slides along the rail to stay level with the player. Past either end of the rail it holds its last position, so it never leaves the room.
Rooms
Every room has its own camera and volume. Entering a room blends the view to that camera, with an ease in / ease out. Leaving it brings the previous camera back. Players in the same room share its camera. Split screen and respawn are handled, and the logic can be limited to specific levels.
Values per point
Every spline point stores its own values: distance, offset, rotation, bias, follow speeds, maximum distance, Look At and sway. They blend from one point to the next, so one rail can frame a corridor and a big room differently.
Bias
Bias moves the framing from the player (0) toward a reference object in the scene (1), to show a puzzle, a door or an enemy. The framed point sits between the two, and every point has its own bias speed.
Depth
A maximum distance between camera and player keeps the player in view. When the rail is farther away, the camera leaves it and moves forward, so the near side of the room leaves the frame. When the player comes back, the camera returns to the rail.
Look At
At the flagged points the camera turns to face the player. Between a flagged and an unflagged point the effect fades in or out. Where Look At is on, the bias fades out, so the two never fight.
Sway
A light camera motion, from a slow rocking like a ship to a nervous hand-held feel. Intensity, amplitude, frequency and irregularity are set per point. It sits on the camera, so it never moves the pivot or the bias.
Timed zoom
The zoom runs over time, with a curve for the way in and one for the way out. It can block the player input and sends an event at every phase, so gameplay can react. When it ends the camera returns to the distance the rail asks for.
References
Each reference is shown next to the same moment recreated with the plugin.
Little Nightmares — Tarsier Studios
Reference for the atmosphere and for a camera that follows the character.
Planet of Lana — Wishfully
Reference for the bias changes in puzzles, when the camera moves to the center of the room.
Camera Examples
A single walk through seven rooms. Each room is filmed by a different kind of camera, and all of them are built with the same tool: one CSP Camera, one spline, one room volume. When the player steps into a room, the view blends to that room’s camera. A sign on the wall names the style and shows the setting that makes it work.
The level shows the range of the plugin without any custom code per camera. The difference between a Limbo-style side view and a Resident Evil corner shot comes down to the values on the spline points: arm length, pitch, yaw, offsets, bias and sway.
Download Build DemoThe Rooms
01 · Side-scroller
A classic 2.5D side view on a straight rail, with layers of pillars, trees and hills behind the path. It is the baseline, in the style of Limbo and Planet of Lana.
02 · Behind the player
A corridor where the camera follows from behind and above, looking down the path, as in Crash Bandicoot. Same component, different yaw and pitch.
03 · Top-down
An open arena with hedges, a pool and pillars, seen from high above at a steep pitch. The rail keeps up with the player as they move around.
04 · Fixed angle
A dark room in the style of Resident Evil. Two cameras sit high in opposite corners, each filming the half of the room away from it. Crossing the middle cuts between them with no blend. Bias set to 1 towards an anchor fixes the pivot, so the camera stays put while the player moves.
05 · Dynamic framing
A low corridor opens into a tall hall and narrows again, like the halls of Metroid Dread. Arm length, height and lateral offset change point by point: tight in the narrow parts, pulled back and up in the hall with the player off-centre.
06 · Vertical
A staircase up to a terrace. The spline rises with the stairs and the camera tilts down more as the player climbs, so height changes need no extra logic.
07 · Cinematic reveal
A bridge leading to a giant monument. Along the bridge the bias towards the monument grows, the shot widens and rises, and a light handheld sway is added. The bias is limited so the player stays in frame in both directions.
What It Shows
- Per-point camera settings. Arm length, pitch, yaw, Y/Z offsets, interpolation speeds and sway, all set on the spline points and interpolated between them.
- Bias. Pulls the frame towards a point of interest (rooms 05 and 07), or locks the camera in place (room 04).
- Room volumes and transitions. Each camera owns a room. Entering one blends to its camera in 1.2 s, or cuts instantly when the blend is 0 (the fixed-angle room).
- Editor preview. Every camera has a stand-in player walking its path. Select a camera and press Play in the Camera Preview tab to see the shot and tune it with live values, without entering Play mode.
- No Look At. Every shot is built from position, rotation and bias alone, to show how far the basic settings go.
Technical Breakdown
How It Works
Four elements decide where the camera is:
- Rail - the spline the camera moves on.
- Player - the camera follows its position along the rail.
- Bias point - the reference object that pulls the framing away from the player.
- Camera - placed with the values of that point of the spline.
Every frame the pose is computed in eight steps. The steps in color are the two that change the shot the most.
Editor Tools
The camera can be tested and tuned without leaving the editor.
Camera Preview
The Camera Preview tab runs the camera path with a fake player. Pilot Camera shows the camera in the main viewport.
Live values in the viewport
Select spline points and their values appear in the viewport HUD, ready to be edited live.
Jump between points
Jump from one point of the spline to another to check the shot at every step.
Export to Level Sequence
The camera path becomes a Level Sequence with a CineCamera, ready to open in Sequencer and render.
- Preview tab - play, pause, reset and jump to the previous or next point.
- Stand-in player - follows the playhead, with an optional lateral movement to test the bias.
- Viewport options - Preview Window, Pilot Camera and Hide Spline (while the camera is selected).
- Point HUD - the values of the selected point, shown in the viewport.
- Export Sequence - bakes the run into a Level Sequence with a CineCamera.
Same camera in editor and game
The preview shows exactly the camera of the game, because game, preview and export compute the pose with the same functions.
Technical Details
- Two modules:
CameraSpline(Runtime) andCameraSplineEditor(Editor). The runtime only knows a preview interface, so it does not depend on editor code. - Per-point values are curves stored in the spline metadata. The camera actor reads and writes them from Blueprint and Python, for example to build cameras from a script.
- A world subsystem runs the rooms: it finds the local players by itself, works with any game mode and needs no tags.
- Project Settings: automatic camera activation can be turned off, and the room logic can be limited to some levels.
- Blueprint events for entering and leaving a room, a new player, a camera change and every zoom phase.
- The point HUD and the live-edit camera refresh only when the selection or a value changes.
Skills & Takeaways
What this project took me from the idea to a tool other people can use.
Unreal Engine C++ architecture
Runtime and editor modules kept apart: the runtime only knows a preview interface, so nothing editor-side ships in the game.
Editor tooling
Slate preview panel, component visualizer and viewport integration, with undoable edits.
Spline and metadata APIs
Custom per-point data stored as curves in the spline metadata, readable from Blueprint and Python.
Camera maths
Projection onto the room axis, distance correction on curves, bias, look-at weighting and smoothing.
Gameplay framework integration
A world subsystem with a view-target stack per player: split screen, respawn, any game mode.
Sequencer pipeline
Camera runs baked into a Level Sequence, using the same pose code as the game and the preview.
Project Overview
Snake Remake is the classic Snake game, written in Python with Pygame. The snake moves on a sizeable grid, grows every time it eats the food, and the run ends when it hits its own body. There are no walls: the snake re-enters from the opposite edge.
When a run ends, a Tkinter dialog shows the final score and a new run starts as soon as it is closed. The snake is steered with the arrow keys or WASD, and the window can be resized freely: the board always stays square and centered.
Technical Breakdown
Object-Oriented Structure
A Cube is one cell of the grid: it stores its position, direction and
color and knows how to draw itself, including the eyes on the snake's head. A
Snake owns the list of cubes and handles input, movement, growth and reset.
Small helper functions take care of the grid, the food, the score dialog and the
window redraw, so the main loop stays short and readable.
Turning Without Per-Segment State
When the player changes direction, the turn is stored in a dictionary keyed by the cell where it happened. Every segment applies the stored direction when it reaches that cell, and the entry is removed once the tail has passed it. The whole body follows the head around corners with a single pass over the cubes, and the edge wrap-around is handled in the same loop.
Food, Growth & Collisions
Food appears on a random cell; positions already occupied by the snake are rejected and drawn again, so it never spawns inside the body. Eating adds a new cube behind the tail, placed according to the tail's direction. Every frame the head is compared with the rest of the body: a hit ends the run, shows the score (the snake's length) and resets the snake.
Resizable Rendering
The window is resizable. On every frame the board is sized from the shorter side of the window, centered, and the cell size is recomputed, so the scalable grid scales cleanly at any size. The game loop is capped at 10 frames per second, which sets the speed of the snake.
Skills & Takeaways
What I took away from rebuilding a classic in Python.
Object-oriented design
Small Cube and Snake classes, with helpers that keep the main loop short.
Algorithmic thinking
Turns stored by grid cell, so the body follows the head without per-segment state.
Game logic
Food placed by rejection sampling, growth behind the tail and self-collision checks.
Responsive rendering
A board sized from the shorter window side, centered, with a fixed frame rate.
Project Overview
Multiplayer Tombola is a client/server version of the Italian Tombola, a bingo-style game, that I developed during my high-school programming studies. A central hub server manages the players and the game sessions, draws and broadcasts the numbers, hands out the cards and decides who wins Ambo, Terna, Quaterna, Cinquina and Tombola.
Players use a Swing client with a lobby, where they choose a name and create or join a session, and a game screen with their card, the 1–90 board, the latest number and real-time notifications. The server and the client can be packaged as standalone Windows applications with an embedded Java runtime.
Technical Breakdown
Client / Server Architecture
A hub server accepts TCP connections and runs one handler per client in a cached
thread pool. Every game is a GameSession that runs on its own thread, so
several sessions can be played at the same time.
Shared state is protected with thread-safe collections, synchronized join and leave operations and atomic flags for the connection state. The server also has a Swing window with a live log and counters for players and active sessions, and it runs headless when no display is available.
Network Protocol
Client and hub talk through a small text protocol: every message is a single line whose
tokens are separated by a pipe, the first token being the command. A shared
Protocol class builds and parses the lines and replaces any pipe typed
by a player, so a name can never break the message format.
LIST CREATE JOIN LEAVE
SESSIONS WELCOME PLAYERS BOARD
START NUMBER PRIZE WINNER
GAME_OVER ERROR
LAN Discovery
On a local network nobody has to type an address. The hub announces itself every second
with a UDP datagram, sent to the global broadcast address, to the broadcast address of
every active network interface and to localhost. The client listens on the discovery
port and connects to the first hub it hears; when no announcement arrives, for example
with a remote server, it falls back to the host and port set through the
TOMBOLA_IP and TOMBOLA_PORT environment variables.
Game Rules & Prizes
Each player receives a card of 15 distinct random numbers from 1 to 90, laid out on 3 rows of 5. The creator of a session chooses how many players it waits for and how many seconds pass between two draws. The server draws the numbers and, after a short pause that lets every client update, checks the cards.
The prize is decided by the most marked numbers on a single row: two for Ambo, three for Terna, four for Quaterna and five for Cinquina, while marking all 15 numbers wins the Tombola and ends the game. Each prize is awarded only once per game, to every player who reaches it on the same draw, and new games can be started without restarting the server.
Desktop Client
The Swing client switches between two screens with a CardLayout. The
lobby has the player's name, the list of sessions with their player count, kept up
to date by polling the hub, and a dialog to create a new session.
In the game screen the player sees their card, a 90-number board that highlights the drawn numbers and the last one, a large display of the latest number and the current prize. Winners are announced with pop-ups that close by themselves.
Skills & Takeaways
What I took away from building a networked multiplayer game from scratch.
Client/server architecture
A hub with a cached thread pool, one thread per game session, and thread-safe shared state.
Network protocol design
A line-based TCP protocol with sanitized fields, built and parsed in one shared class.
LAN discovery
UDP broadcast on every network interface, with an environment-variable fallback for remote servers.
Desktop UI
A Swing client with a lobby, a game screen and a CardLayout switch.
Game rules logic
Prize detection per row, each prize awarded once per game, with simultaneous winners.
Packaging
Standalone Windows applications with an embedded Java runtime.
Project Overview
The Anti-Theft System is an IoT project built around a Raspberry Pi and several ESP8266 boards. The Raspberry Pi is the central hub: it runs the MQTT broker, the MySQL database and the web application. The ESP8266 nodes read the sensors (ultrasonic distance, motion and a keypad) and drive a red and a green LED and a buzzer, all over Wi-Fi.
A login-protected web application arms and disarms the alarm from a browser, and every request is stored in the database together with the user, the time and the IP address it came from.
Technical Breakdown
System Architecture
The Raspberry Pi is the single source of truth. The ESP8266 nodes are small, simple clients: they either publish a sensor reading or react to a command, and all the decisions are taken on the Pi, which also keeps the alarm state in the database.
MQTT Messaging
Devices never talk to each other directly: everything goes through the broker on the Raspberry Pi, using a few topics. A Python controller (paho-mqtt) listens to the sensor topic and, for every reading, checks in the database whether the alarm is armed before sending a command to the output node. When it starts, it also publishes the initial LED state.
allarme/sensore
Ultrasonic readings: detected or not_detected
allarme/movimento
Motion sensor events, handled by a listener on the Pi
allarme/output
Commands for the LED and buzzer node: on or off
led/stato
Initial LED state, taken from the last alarm status
ESP8266 Firmware
Each node is an Arduino-style sketch that connects to Wi-Fi and to the broker through
PubSubClient, with a reconnect loop that keeps retrying if the connection
drops.
The ultrasonic node fires the sensor, measures the echo time with
pulseIn and converts it to centimeters. About twice a second it publishes
detected when something is closer than 50 cm and not_detected
otherwise.
The output node subscribes to the command topic: on lights
the green LED, any other message switches to the red LED and sounds the buzzer with
tone().
Web Application
The web app is written in PHP. A login form creates a session, the control panel is reachable only with a valid session, and logging out destroys it. From the panel the user turns the alarm on or off.
Each request is handled by a PHP script that stores the new state in MySQL with prepared statements, together with the logged-in user, the time and the client's IP address.
Database & Logging
Every arm or disarm request is saved as a new row in a MySQL table: alarm state, requesting user, timestamp and IP address. Rows are never overwritten, so the table works as a log of who changed the alarm and when, and the most recent row is what the Python controller reads as the current state of the alarm.
Skills & Takeaways
What I took away from connecting hardware, a broker and a web app into one system.
IoT architecture
The Raspberry Pi as single source of truth, with simple ESP8266 clients.
MQTT messaging
Broker topics for sensors and commands, and a Python controller built on paho-mqtt.
Embedded firmware
Arduino C++ with Wi-Fi and broker reconnection, ultrasonic timing and a buzzer.
Secure web basics
Session login, prepared statements, and a log of user, time and IP for every request.
Full-stack integration
PHP, MySQL, Python and hardware working as one system.
About Me
Hi, I am Hamza. I'm a young game programmer with a strong passion for computers and video games. I have a technical background in IT and studied at the Digital Bros Game Academy, where I specialized in game programming. I have experience in various programming areas, including web development, applications, video game development, and electronics boards. My main interests have focused on AI, game systems and the development of production-support tools, such as tools for designers.