AI & GAMEPLAY PROGRAMMER

Hamza Ben Said

Building robust systems, responsive controls, and immersive mechanics in Unity & Unreal Engine.

VIEW PROJECTS

PROJECTS

Click on a project to learn more

Academic Projects

pongo

Goodbye Pongo

6 MONTHS

Unreal Engine Windows Puzzle Adventure
Patch Me

Patch Me If You Can

7 WEEKS

Unity Windows FPS
Takaindest

Takaindest

6 WEEKS

Unity Mobile Casual Local Multiplayer

Game Jam Projects

Midnight Wishes

10 to Midnight

4 DAYS

Unreal Engine Windows Point & Click Narrative
Ramiel

Ramiel

48 HOURS

Unreal Engine Windows Stealth
Tatuchatoi

Tatuchatoi

1 WEEK

Unreal Engine Windows 1s-Person Adventure

Tools & Plugins

SM to ISM

Static Mesh Instances Converter

EDITOR TOOL

Unreal Engine C++ Editor Tool Optimization
CameraSpline: a camera on a spline rail following the player

CameraSpline

EDITOR PLUGIN

Unreal Engine C++ Camera Editor Tool

Software Projects

Snake Remake gameplay

Snake Remake

DESKTOP GAME

Python Pygame Tkinter
Multiplayer Tombola game screen

Multiplayer Tombola

CLIENT / SERVER

Java Swing TCP / UDP Multithreading

IoT Projects

Anti-Theft System hardware: Raspberry Pi, keypad and motion sensor

Anti-Theft System

IOT SYSTEM

Raspberry Pi ESP8266 MQTT MySQL PHP
Goodbye Pongo Background
ENGINE Unreal Engine 5
ROLE AI - Camera - Anim
TEAM 14 Members
DURATION 6 Months

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.

Trailer
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.

Pongo System — Gameplay Overview
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.

FEAR Priority 1

Pongo flees outside a safe escape distance using EQS. Continuously recalculates his path if the source moves.

CURIOSITY Priority 2

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.

Camera System — Gameplay Overview
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 spline metadata panel in Unreal Editor

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.

CameraSpline and RoomVolume in UE5 editor

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
GAMEPLAY LOGIC
Animation Blueprint
Checks whether the player is in front.
Sends target position and enable flag to the rig.
→
CONTROL RIG
Look-At Solver
Computes and distributes the rotation
across spine, neck, and head.
→
FINAL POSE
Character Output
Applied on top of the base animation,
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 toward the player
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.

SPINE 1
~15%
SPINE 2
~25%
SPINE 3
~35%
NECK
~60%
HEAD
100%

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.

Speed In = 10  ·  Speed Out = 10
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.

Strength = 2  ·  Critical Damping = 1

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.

Download Build
Patch Me Background
ENGINE Unity 2022.3
ROLE AI & Gameplay
TEAM 11 Members
DURATION 7 Weeks

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.

Trailer
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.

Download Build
Takaindest Background
ENGINE Unity 2022.3
ROLE Network & Gameplay
TEAM 11 Members
DURATION 6 Weeks

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.

Trailer
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.”

First Mini Game Gameplay Loop

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.

ENGINE Unreal Engine 5
ROLE Systems & Gameplay
TEAM 2 Members
DURATION 4 Days

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.

Trailer Walkthrough
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.

Ramiel Background
ENGINE Unreal Engine 5
ROLE AI & Gameplay
TEAM 5 Members
DURATION 48 Hours

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.

Trailer
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.

UNDETECTED
Accumulator at 0 — patrolling normally
SUSPICIOUS
Filling — player in FOV
DETECTED
Full — attack + alert allies

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.

Tatuchatoi Background
ENGINE Unreal Engine
ROLE Gameplay & Audio
TEAM 11 Members
DURATION 1 Week

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.

Trailer
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.

Dash

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.

Wall Run

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 ChangeSoundTrack on its BP_SoundTrack reference, 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 Event with a dynamically created event callback.
  • Death integration: On BeginPlay, the SoundTrack binds to the player's OnDie dispatcher. On death it triggers ChangeSoundTrackCustomFadeOut with 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.

ENGINE Unity
ROLE AI & Gameplay
TEAM 10 Members
DURATION 1 Week

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.

Trailer
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.

View on GitHub
ENGINE Unreal Engine 5
ROLE Gameplay & AI
TEAM 4 Members
STATUS In Development

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.

View on GitHub
ENGINE Unreal Engine 5
TYPE Editor Tool / C++
STATUS Version 1.1

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.

stat initviews before and after Convert to HISM
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.

SM to Instances context menu in the Unreal Editor
Right-click → Actor Options → SM to Instances

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.

Reset To Static Mesh brings the actors back

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.

Convert Static Mesh To ISM node with every field of the settings struct
Convert Static Mesh To ISM
Revert ISM To Static Mesh Actors node with its two settings
Revert ISM To Static Mesh Actors

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.

Different Custom Primitive Data values stay separate after the conversion

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.

View on GitHub
ENGINE Unreal Engine 5
TYPE Solo Project
STATUS Version 1.1

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.

Camera Showcase
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.

Top view: the camera on its rail stays level with the player
The camera keeps the position of the player along 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.

Two overlapping rooms, each with its own camera, and the steps of a room change
Room volumes, camera stack and blend

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.

A rail with three points; arm length, pitch and bias blend between the points
Values blend along the rail (example values)

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.

Bias 0, 0.5 and 1: the camera frames the player, the halfway point or the object
The same scene with bias 0, 0.5 and 1

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.

Top view: the camera is pulled off the rail to respect the maximum distance
The camera leaves the rail to respect the limit

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.

Look At weight rises between flagged points while the bias used fades out
Look At and bias along the rail

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.

Two sway traces: smooth rocking and hand-held motion
Smooth and hand-held sway

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.

Zoom states and events with the player input blocked during the sequence
Zoom phases, events and input blocking

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.

Reference - Little Nightmares
Recreated with CameraSpline

Planet of Lana — Wishfully

Reference for the bias changes in puzzles, when the camera moves to the center of the room.

Reference - Planet of Lana
Recreated with CameraSpline

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 Demo
One walk through all seven rooms

The 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:

  1. Rail - the spline the camera moves on.
  2. Player - the camera follows its position along the rail.
  3. Bias point - the reference object that pulls the framing away from the player.
  4. 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.

The eight steps that compute the camera pose every frame, and the functions shared by game, preview and export
The pose of the camera, step by step

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.

Preview with Pilot Camera

Live values in the viewport

Select spline points and their values appear in the viewport HUD, ready to be edited live.

Editing values from the HUD

Jump between points

Jump from one point of the spline to another to check the shot at every step.

Jumping between spline points

Export to Level Sequence

The camera path becomes a Level Sequence with a CineCamera, ready to open in Sequencer and render.

Level Sequence export
  • 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

C++ Unreal Engine 5 Runtime module Editor module
  • Two modules: CameraSpline (Runtime) and CameraSplineEditor (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.
The runtime module CameraSpline and the editor module CameraSplineEditor, joined by a preview interface
The two modules of the plugin

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.

View on GitHub
LANGUAGE Python 3
LIBRARIES Pygame / Tkinter
TEAM Solo
CONTEXT Personal Project

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.

Snake Remake: a red snake and a green piece of food on the grid
Gameplay

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.

View on GitHub
View on GitHub
LANGUAGE Java
LIBRARIES Swing / TCP + UDP sockets
TEAM Solo
CONTEXT High-School Project

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.

Tombola client during a game: player card, last number and the 1-90 board
Client - game screen

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.

Tombola server window with the live log of a running session
Server - live log

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.

CLIENT → HUB

LIST CREATE JOIN LEAVE

HUB → CLIENT

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.

Tombola lobby with the list of available sessions
Client - lobby

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.

View on GitHub
View on GitHub
HARDWARE Raspberry Pi 4 / ESP8266
PROTOCOL MQTT over Wi-Fi
SOFTWARE Python / PHP / MySQL
FIRMWARE Arduino C++

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.

Web control panel with the alarm on and off buttons
Web control panel

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.

Web Browser
Login and alarm control
HTTP
Raspberry Pi 4
Web app (PHP) · MySQL · MQTT broker · Python controller
MQTT
ESP8266 Nodes
Keypad · Motion sensor · Ultrasonic sensor · LEDs and buzzer
Raspberry Pi 4 used as the central hub
Raspberry Pi 4 - central hub
Keypad wired to an ESP8266 board
ESP8266 + keypad
Motion sensor wired to an ESP8266 board
ESP8266 + motion sensor

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.

SENSOR → PI allarme/sensore

Ultrasonic readings: detected or not_detected

MOTION → PI allarme/movimento

Motion sensor events, handled by a listener on the Pi

PI → OUTPUT allarme/output

Commands for the LED and buzzer node: on or off

PI → LED 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.

Login form of the web application
Login page

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.

View on GitHub
Hamza Ben Said

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.