About Me

Following the development of my own game engine and the design of a custom handheld console—featuring a distinctive magnifying glass shape and rotary encoder—the next step was to create a game prototype designed to work in full synergy with the hardware.

The resulting game draws direct inspiration from Atari-era classics such as Pong, Breakout, and Tempest, reimagining them within a three-dimensional tunnel space—a cylindrical structure that echoes the polygonal geometries of Tempest and I, Robot.

Skills: Game Design, Game Development, Godot Engine, GDScript, Blender

This project is a custom 2D/3D game framework built in C++ on top of openFrameworks.

It provides a modular structure for handling 2D shapes, animations, collisions, input and task handling in a real-time system, making it a base for experimental game development and interactive prototypes.

Here you can find my code on Github for code reviewing. You will also find a bin folder where you can simply get the little game I made with it for you to try.

Since the full project size exceeds the file limits of Github. You can find the full Visual Studio solution here on my Mega link.

The framework was designed with modularity and extensibility in mind, showcasing core concepts of real-time code architecture.

There are two main categories of classes:

Engine Classes

These classes are meant to be as reusable as possible and implement core features needed on most games:

• Task Schedule Manager: This class acts as a simple cooperative scheduler. Tasks are executed only when iterateAllTaskSchedules() or callTaskByID() is explicitly called from the main loop. This schedule executes them only if their interval has elapsed.
• Input Dispatcher & Manager:
  • Dispatcher: InputDispatcher implements the Observer pattern and the publisher role. It allows multiple InputManager instances to subscribe to a given GameStateManager and receive input events (mouse move, mouse press, key press).
  • Manager: InputManager implements the Observer subscriber role in the event system. It allows clients to register and remove callbacks for specific input events (mouse move, mouse press, key press). When an event occurs, the corresponding callback is invoked if present.
• Shape: This class is a base graphical entity that can be drawn and animated. It stores position, velocity, rotation, colors, and dimensions.Animation and movement logic are delegated to an internal AnimationEntity (read below).
• Animation Entity: AnimationEntity manages the animation state of a Shape. It supports moving toward a coordinate at a fixed speed or duration, continuous free movement, and rotation toward coordinates or velocity. Typically, a Shape owns an AnimationEntity and delegates animation logic to it.
• Collision Manager: This class is to test collision between two vector-based shapes. It's very accurate since it doesn't work with hitboxes but it checks for any intersection between shape outlines.
• Raycast Evaluator: RaycastEvaluator encapsulates raycasting-based 3D collision detection by internally applying the Müller-Trumbore intersection test. It provides methods to test intersections between moving shapes and mesh faces, calculate hit points and normals, and optionally compute rebound directions (reflection vectors).

Specific Game Classes & Subclasses

• GameStateManager: Central orchestrator of the game loop.
  • Manages WAITING, RUNNING, and GAMEOVER states.
  • Coordinates player, enemies, bullets, collisions, and audio.
  • Sets up scheduled tasks and dispatches input events.
  • Handles gameplay logic such as scoring, combos, and life/boundary management.
• Bullet Controller: this class manages the lifecycle of bullets fired in the game. It handles spawning bullets from entities, assigning them velocity and animations, updating their state, and removing those that go out of the playable screen boundaries.
• Enemy Manager: this class handles the creation, update, and rendering of enemy shapes (Foes). It can spawn enemies at random positions along a circular boundary, orient them toward the center, animate their movement, and optionally auto-spawn new enemies at a configurable rate and speed.
• Trippy Background: TrippyBG is a silly name, I know. It's a visual effect manager that spawns and animates semi-transparent shapes. It randomly places circles on the screen, makes them grow over time, and removes them when they exceed a maximum size, producing a dynamic, psychedelic background.

In addition to the game engine, I also designed and implemented an Arduino-based game controller equipped with a rotary encoder , which communicates via USB with the engine through serial data packets .

Source code of the Arduino firmware and its related game engine function is available on Github following this link.

Key Features

• Modular Entity Component system.
• Cooperative Task Scheduler for timed tasks.
• Flexible Input System built upon the Observer pattern, supporting callbacks and external controllers.
• Simple but extendable Collision Handling.
• Basic State-Machine logic.

Tech Stack

• Language: C++17
• Multimedia Framework: openFrameworks
• Build: Visual Studio (virtually cross-platform with openFrameworks)

Advanced C++ Techniques Used

• Lambdas & STL algorithms (remove_if, any_of) for clean event handling and data structures cleanup
• Smart pointers (shared_ptr, unique_ptr) for safe memory management
• STL containers (vector, unordered_map, array) to manage entities and events efficiently
• Observer pattern via InputManager / InputDispatcher for event-driven design
• Custom scheduler using lambdas for timed game tasks

Purpose

• A learning and showcase project for C++ real-time systems development.
• A portfolio piece demonstrating OOP design patterns (Observer, Dispatcher-system design, Scheduler).
• A foundation for building more complex games or prototypes.

This project implements a small game engine for Arduino with a 16x2 LCD display. It demonstrates graphics, input, and game logic management using a cooperative mini-scheduler, showing skills in embedded C++ concurrent programming, and low-level hardware control.

Source code is available on Github following this link.

Key Features:

• Custom sprites on LCD.
• Game logic with player, obstacles, and scoring.
• Cooperative mini-scheduler for input, graphics and game update tasks.
• Modular entity-based class design for clarity and maintainability.

This project is intended as a portfolio demonstration of embedded C++ skills and microcontroller programming.

The handheld console I designed is based on the Raspberry Pi 5 single-board computer. Its distinctive feature is its magnifying-glass-shaped form, which invites the player to peer into a secret and otherwise inaccessible world.

The round screen and rotary encoder free the game designer from established patterns, encouraging fresh and unconventional ideas.

Skills: Autodesk 3ds Max, Electronics Prototyping, Industrial Design

GyroGeddon is a mobile video game developed with Unity for Android devices. The game uses the phone's gyroscope to aim at enemies: the player doesn't control the character directly but guides it by physically rotating the device.

The goal is to help a defense robot survive waves of zombies approaching from random horizontal positions. The player aims using a crosshair fixed at the center of the screen; when aligned with a zombie, the robot automatically moves horizontally towards it. Tapping the screen fires a shot to eliminate the target.

The game lasts 60 seconds or ends earlier if a zombie reaches the robot. A summary screen then displays the total kills and high score.

The project was developed using C# scripts and Unity’s visual scripting, dividing core systems into modular components. A GameObject handles gyroscope input, updating camera orientation frame by frame using quaternions to maintain a stable aim relative to the initial device position.

Raycasting is used to simulate aiming: each frame, a ray is cast forward from the camera. If it hits a zombie (filtered via tags), the robot can fire when the player taps the screen. The hit count is tracked throughout the match.

A second GameObject dynamically spawns zombies at regular intervals with randomized horizontal positions. Each is equipped with a Box Collider to interact with the raycast and trigger collisions with the robot only.

A third GameObject manages the interaction logic, including the countdown timer and the transition to the game-over scene.

Skills: Unity · C# · Visual Scripting · Gyroscope Integration · Raycasting · Game Design · Interactive Systems

This academic project was developed in Unreal Engine 5 as part of a Narrative Game Design course. Besides development, I was responsible for crafting the storyline and worldbuilding, centered around a spaceship tasked with rescuing stranded soldiers and civilians while evading hostile factions and retaliatory attacks.

The prototype adopts an arcade style with a strong physics-driven core, inspired by classic Atari space titles. Inertia, vector-based movement and physics, and a dynamic minimap interface were all implemented entirely using Unreal Engine's Blueprint visual scripting system.

Skills: Blueprints, UI Design (Widgets), Unreal Engine 5

This project is part of a larger transmedia experience, whose first product was a comic book available on request (NSFW).

I independently managed the entire production process, from start to finish. I modeled all assets and created their UV mapping, then developed PBR material textures using Adobe Substance Designer’s node-based system.

On Unreal Engine, I assembled the assets and assigned their materials, designed gameplay features with Blueprints, and built interactions and puzzle mechanics. I also handled sound and light design, ensuring a complete and cohesive experience according to my vision.

Procedural Homeostasis is an interactive anti-anthropocentric installation that questions the role of human agency in digital creativity. Developed as part of an academic project, it explores the potential of the machine as an autonomous creative entity, where the human presence is redefined not as a catalyst, but as a disruptive interference in an otherwise self-sustaining computational process.

The installation features a dual sensory axis—visual and auditory—both driven by procedurally generated parameters. When a person enters the environment, their movements and presence affect the generative system, causing disturbances in both the visual output and sound algorithms. This interaction reveals the vulnerability of a system perceived as self-contained, challenging the notion of control in human-machine relationships.

I was involved as developer and worked with the following technologies:

• TouchDesigner: Outputting OSC signals through local network. Signal are based on based on facial detection using Google MediaPipe libraries.
• Pure Data: Visual scripting and conditional signal generation taking as input OSC signals from TouchDesigner through local network.
• Unreal Engine: Procedural 2D/3D effects generation by using OSC parameters from TouchDesigner over local network. Signals were processed via blueprints as a bridge between source data and 3d/2d assets.

Set in non-places such as airports or stations, the installation invites reflection on digital interconnection, surveillance, and algorithmic aesthetics. Inspired by cybernetic imagery (e.g., The Matrix), it visually alternates between order and chaos, repetition and disruption, offering a contemplative critique on our increasingly blurred boundary between physical and virtual realms.

You can find a live demo of this installation below.

Skills: Unreal Engine 5 · Niagara FX · TouchDesigner · Pure Data · Procedural Art · Interactive Installation · Real-Time Audio-Visual Systems · Human-Machine Interaction · Narrative Systems Design

These animations were produced within an academic context as part of coursework for 3D animation subjects. The first project required the delivery of a series of looping animations for a custom 3D character. The second focused on acting, starting from a pre-recorded audio track.

In the first project, I handled the entire pipeline—modeling, rigging, and animation—using 3ds Max with CAT (Character Animation Toolkit). In the second case, I received a fully rigged character in Maya and focused exclusively on animating it in sync with the audio.

Skills: 3ds Max (CAT, modeling, rigging, animation), Maya (animation).