Hi, I'm Franco Leone

Memora's core mechanic, in Unity (C#): you look at a photograph, hold for three seconds, and you are inside the memory. Through the hold an HDRP custom pass runs a four-stage grade — peripheral vision opens up, the world drains of colour until the photograph is the only living thing left, and at the end everything floods to white — while a custom shader tears a crack of light open in the paper. The light coming out of that crack is not a screen effect: it is a real volumetric point light that lights the room and pulses at 1.5 Hz, in sync with the core of the crack. Past the point of no return, the memory's scene loads additively with its own arrival grade.

A note and document reading system in Unity (C#): the paper never moves, and it never teleports into the player's hand. The camera fades to black, reappears in front of the document where it actually sits, and comes back the same way, with a side panel holding the transcription and the inspection light on for dark rooms. The core decision was to never interpolate the camera — every move is a fade over an instant teleport, because in first person a camera lerp the player does not control reads as sloppy and makes people queasy. It replaces three earlier systems with one.

A working computer inside the game, in Unity (C#): you sit down, it boots with its own sound, the screen swaps material and lights the room, and it asks for a password you work out by exploring the house. Inside there are mail and photo sections and a security-camera circuit that renders real cameras from the scene, each with its own feed. The whole desktop — windows, icons, taskbar — is built on Canvas. Every piece of state (password solved, section open, what you have read) persists through ISaveable, and it drives a printer that first needs you to find paper.

Object inspection with sub-elements in Unity (C#): what you are holding can carry parts you interact with without putting it down. A painting comes off the wall; you pick it up, rotate it, and inside the broken frame there is a photograph you take and keep. While something inside is still unresolved, the container blocks the exit — you cannot drop the object until you have dealt with what it holds. Sub-elements live on their own raycast layer.

An inventory in Unity (C#) you open at any point to go back over what you have found and inspect it again unhurried: each object is shown in 3D, you rotate it with the mouse over the blurred background and read it alongside its description. The categories are defined by the game — three here, because they are the ones the story needs: usable objects, notes and photographs. All of it persists through the save system, and the photographs can be entered from here too, straight into their memory.

A key and item-selection system in Unity (C#): interact with a locked door and the camera moves in on the lock where it stands, opening a 3x3 grid of the inventory in miniature. You pick with WASD and use with space; a wrong item returns a red flash without throwing you out of the menu, and the right key is consumed, travels to the mouth of the lock and turns. The menu is generic — anything in the world that implements IMenuInteractable uses it, doors, printer, lamp — and each one returns its own verdict on whether the item fit.

A framework for scripted set-pieces in Unity (C#): a persistent base class that fires when the player looks towards a point and then orchestrates independent actuators — a warm-light fader, a dying lamp, a desaturation volume, a micro-movement oscillator, the dissociation effect — each one unaware of the others. The moment in the clip is six phases: the corridor's four warm lights die in parallel, the hanging lamp agonises in warm and comes back cold, revealing a figure at the far end, and the audio riser is tuned so its peak lands on the exact frame where the hospital ceiling appears over the house. The composition rule was that the hospital is the noun, the grade is the adjective and the dissociation is the verb, and that everything converges on a single downbeat. The last phase hides the reset under a blink: when you open your eyes the house is normal again and the figure is gone.

Doors with no open button, in Unity (C#): the leaf is a Rigidbody on a HingeJoint and you push it with your body as you walk, so it swings differently depending on where you touch it and how hard. The rule the system runs on is that continuous interaction is physics and the discrete verb is animation — pushing is physics, but the slam when you run in and the close on a key press are animations, so they look the same every time. It covers locked-door feedback, collision layers that follow the state of the leaf, and optional auto-close through JointSpring. On closing, the door sweeps its own path: if you are standing in the doorway it stays open instead of passing through you.

A JSON save system in Unity (C#): every object in the world decides what persists by implementing an interface, and a component with a stable GUID collects the state of everything sitting on it. It writes to a temporary file first and uses File.Replace, which is atomic and produces the backup in the same operation — if the main file is missing or fails to parse, it recovers itself from the backup. Restoring is multi-pass with a hard cap, because restoring one object can create another: the printer turns a photo on, the lamp instantiates a bulb, and those new arrivals need their state too. It includes a gate that suspends saving while a scripted sequence is running, so no checkpoint can land halfway through a moment and leave the game in an inconsistent state.

The core mechanic of an investigation game in Unity (C#): photograph clues, pin them to a cork board, and link them with red thread to reconstruct the case. The threads are a physically-simulated Verlet rope running on the UI's own real-time clock, so they keep swinging while the board freezes game time (timeScale = 0). Built entirely with UI Toolkit.

Over-the-shoulder survival-horror shooting in Unreal Engine 5.8 (C++), on GAS: aim, fire, reload, and the infected drops into ragdoll. The shot does not trace when the ability activates — it waits for the montage notify that marks the frame the bullet leaves the barrel, so the shot and the arm agree instead of the enemy falling before the gun has finished coming up. It traces from the camera while the muzzle flash comes from the weapon, and the two disagreeing is the illusion: the reticle sits at the centre of the screen, and a shot genuinely leaving the barrel would miss whatever the reticle covers. Aim assist scores by angle from centre rather than by proximity, and corrects before the spread is applied — never after, or the weapon's cone stops meaning anything.

Localized damage and dismemberment in Unreal Engine 5.8 (C++), on GAS: the shot traces against the enemy's physics asset, so the bone it actually struck is what picks the damage multiplier and the reaction — and past a per-zone threshold the head, an arm or a leg comes off, bones hidden, a cap plugged into the surviving socket and the blood jet parented to it so it follows the body as it falls. The impact plays no animation at all. It is an impulse at the struck bone driven through PhysicsControl on top of whatever the enemy was already doing, and the drive gets weaker at the moment of contact — a fifth of its strength, climbing back over the next second — because a strong drive is a rigid body, and a rigid body has nowhere to put a bullet. Two shots twenty centimetres apart produce two different reactions.

A Tetris-style grid inventory built in Unreal Engine with C++: items occupy multiple cells with drag-and-drop placement, rotation, and stacking, backed by fast slot lookup and collision checks.

A first-person object inspection system in Unreal Engine with C++: pick up and rotate props in 3D to examine them, with smooth camera focus and highlight-on-hover.