Roger Egito

It isn’t a game, a film or a tour. The player takes part in scenes from a child’s point of view, interacting with characters whose words and surroundings come from historical documentation.

Stepping up to lead. I didn’t join as project lead. We’re all busy people, and keeping the team organized and motivated, the project afloat and the clients satisfied was hard, so I stepped up and started organizing everything. I led four programmers working on Git feature branches, and turned the research team’s documentation into 12 scheduled technical milestones.

The first version, 2025. I set up the basic VR controls, added the characters and idle animations to the slave shop scene, and built the dialogue system. It had trigger zones, speech bubbles that follow the actors, animations during dialogue, and an importer that pulled the historians’ lines from Google Sheets. I also added the scene timer.

The experience was exhibited to the public at SBPC 2026, Brazil’s national science congress, hosted at UFF in July 2026. Kids, teenagers and adults tried it and enjoyed it.

I had told the team to keep everything as simple as possible, and it paid off. Sessions lasted about a minute, nobody felt any discomfort, and we didn’t need to teach teleporting at all.

Watching people play showed us one problem: with the headset on, people couldn’t find the trigger, and I had to guide their fingers to it. We’re changing how the experience shows its controls because of that.

From stealth to one tile of sight. To set the game apart from other dungeon crawlers and push it toward horror, my first idea was torchlight stealth. The client and I agreed it couldn’t be built in the time we had, so it never reached a prototype. I simplified it instead: the game is on a grid, enemies roam and only move when the player moves, and they see just one tile ahead. Waiting in place and letting them pass is always an option. The best fight is often the one you avoid.

I designed the level and the enemy routes around that short sight and those roaming enemies.

Simple enough for people who don’t play RPGs. I wanted someone who never plays RPGs to be able to pick this one up. So instead of loot and an inventory, the chests hold upgrades in the style of Metroid or Mega Man. They alternate between weapon and armor, from a femur up to a cleaver, so every chest makes you stronger and there’s nothing to manage.

Only the stats survived from the tabletop. From Mörk Borg’s rules we kept the four stats and little else. Combat is one roll to hit, a d20 plus a stat, then the weapon’s damage die minus the armor’s die. I adapted Presence to the game’s own economy: a higher Presence means the true ending asks for less Flesh and each piece heals more, but you can carry less of it.

A heal with a price. Combat hurts, so the game needed healing, but I wanted healing to carry pressure and risk. Flesh heals 2d4. Two dice make the middle results likely, which is a little friendlier, but a piece can still heal as little as 2. You also never know where the next one is.

Enemies drop Flesh, so every kill pays out right away. The fight can also cost more health than the Flesh gives back.

Flesh is also the price of the true ending. The moment you realize that, the game gets harder: now you ration your heals, and a lucky strike can kill you.

Words and art. I wrote the story and every line of in-game text, specced every screen, and directed the art with our artist.

Programming. I programmed the entire game in Unity, 44 C# scripts and about 3,200 lines. That covers grid step movement, enemy navigation that switches from roaming waypoints to combat, raycast enemy vision that walls block, and weapons, armor, enemies, upgrades and player stats as ScriptableObject data.

The game simulates a fictional coronavirus outbreak on a continent divided between six nations. Teams of students and stakeholders each act as a nation’s government and try to contain and eliminate the pandemic over a number of turns, while keeping their country socially, economically and politically stable.

They can aid their neighbors or harm them, and donate to a Global Health Organization.

Prototype and architecture. I built the first playable pieces: the game screen prototype, the turn timer, a new UI mockup, and the chat prototype that grew into the inter-team chat. I then structured the game around models, views and controllers for the clients, the server and each country, separating what the server owns from what each client displays.

The server runs the game flow and owns the turn clock, and it only ends a turn once every player has confirmed. Until a player confirms, everything on their screen is theirs to change. Confirming sends their choices to everyone.

Core rules. I implemented the turn and spending system with the correct order of operations, policies, emergency loans, vaccination, aid between countries, popularity, and donations to the Global Health Organization with a progressive global cost and a reset. My client and I replaced the original calculations with simpler, more direct ones that were easier to follow and test, starting with the disease stats in the pandemic model those rules feed into.

Multiplayer that holds up in a real classroom. I fixed the server’s player count per country, and a bug that stopped a third player from joining: the Relay allocation was still sized by a prototype constant of two players instead of the room’s real player count. I also gave clients the right write permissions, and added safe disconnection and client reconnection that restores each player’s local policies. Clients now disconnect cleanly when the host leaves, the packet queue limit is higher, and the create and join buttons lock while a session loads.

Reconnection for players on unstable Wi-Fi is one of the features the client highlights.

Game setup. I built the initial game settings screen and wired every field to the game’s variables. Before a session starts, the host can tune each nation’s infection rate, population, ICU capacity and popularity, along with the vaccination rate, when vaccines arrive, and how long each turn lasts.

News and the rest of the interface. I built the news popup that reports on the outbreak as the game goes on, along with the main menu, the policy screens and a policy details popup, the pause, reset and emergency buttons, and the onboarding screens.

Results for the debrief. I built the end-of-game results: graphs of infections, deaths, ICU usage, vaccination and popularity, with filters to show one nation or all of them. The client uses them for post-round debriefing.

I also built the report screen, which breaks down every policy each nation took, what it donated to the Global Health Organization, and what it gave to other nations, so the group can talk through who cooperated and who didn’t.

Tools that are the sum of their parts. The core idea is that a tool’s stats come from what it’s made of. I built an item instance layer so each crafted tool can carry its own parts, durability and effects, and a seven-cell grid where the pattern of parts decides which tool comes out. Parts fold into stats in a fixed order, so the order they were placed in never changes the result.

A world from a seed. The world is generated from a seed, so the same seed always builds the same world. It has a round boundary, terrain autotiled a quarter tile at a time, and houses placed as neighborhoods: a core house far from any other core, with more houses grown beside it by the design’s rules. A world 90 tiles in radius generates in about a second and a half in the editor.

Enemies you learn to read. The design describes enemies as distinct stages the player learns to exploit, so each enemy is a state machine you can read: wander, chase, attack, strafe, guard, flee, scavenge. Before every swing an enemy stands still and shows in red exactly where the hit will land, and a “!” goes up when it spots you. Enemies find their way with A* pathfinding, and they live in camps that call them home at night.

Testing as I go. The codebase has 196 automated tests. Before handing the prototype over, I tested every task against its acceptance criteria and wrote up what passed, what didn’t, and the problems I found outside the tasks.

All Stars Merge is a free-to-play merge game published on Google Play by Hermit Crab Game Studio. I worked on it for my client, Ludomancer Studio, which was developing the game for Hermit Crab.

I joined in June 2025, on a codebase that had been in development since 2023, alongside a team of more than 20 people.

Stadiums. I built the stadium layer from its first scene: field evolution, upgradeable field parts with costs, the upgrade choice screen and its animation, stage swapping, the basketball and volleyball stadiums, and the transition animation between them. I also fixed the upgrade save so progress held between sessions.

Quests. I implemented missions with task costs and rewards, a questline flow driven by ScriptableObjects, and the level 3 questlines, which I authored in PlayFab title data. I added quest completion notifications in both the merge and stadium scenes, consumed the right board items when a quest completed, marked quest items on the board, and added the quest drawer.

I also rebuilt the daily tasks screen and its rewards.

Story. I implemented the story cutscenes and the prologue, then restyled them and added character portraits with expressions, a skip button, and a new HQ introduction.

Sticker album. I brought the album back online and extended it: more albums, stickers and packages, sticker page progression with page rewards, a three-pack opening animation, and collection notifications.

Hotel 77 is a first-person narrative horror game from Ludomancer Studio, set in a haunted hotel caught in a time loop. Players walk its shifting corridors, spot what is wrong, and have to make the right choice to move time forward.

The team had about ten people, and the game is localized into ten languages with full English audio.

Level design. In the first pass I built and polished several of the hotel’s rooms, including the Outlast room, the skull room and the dark room, added locked doors, and placed the carpets and the letter. My level design branch was merged in January 2025.

In the second pass I designed and built all of the hotel’s bedrooms, starting from the basic bedroom. The bedroom is the same behind all 8 doors, so players don’t have to memorize much. Only one door in the hallway is unlocked, so they don’t have to check all 8 either. The unlocked door is random, except when the anomaly is in a bedroom: then that bedroom always spawns behind the same door.

Anomalies. I created 17 anomaly variants and 4 themed room variants across both passes. In the hallways, mine include blood handprints around the fire alarm, luggage turned into coffins, a dead ghost sitting at the start of the hallway, GET OUT written across the wall, statues that turn to watch you, a skull inside a diver helmet, and Nevermore, where the same helmet hides a bloody raven. In the bedrooms, they include a bloody bathtub, an evil TV, a hole in the wardrobe, a lamp that is simply wrong, and a crying zombie.

To me, a good anomaly rewards paying attention. It doesn’t try to jumpscare you hard. You get a little scared when you realize what’s wrong with the room. Some of mine are obvious and scary on purpose, and some are really hard to spot. I always added a black substance near the anomaly, to make it a tiny bit easier to see and to give all of them a shared motif. When an anomaly is a jumpscare, it should feel unique. In my Outlast room, the power goes out partway through and your night vision switches on by itself.

My favorite is the shadow man, in my dark room. The lights are off and a huge shadow stands at the far end, looking at you. It gives an immediate “oh no” feeling without being a jumpscare. Walk toward it, and the lights come back on and it’s gone.

Not every anomaly made it. Each one went through review, and two of mine were cut. A shadow hiding behind the luggage, given away only by its breathing, was too hard to spot. A door left ajar with a baby crying behind it overlapped with another developer’s crying baby.

Anomaly behaviors. I wrote eight scripts to bring the anomalies to life: objects and heads that turn to face the player, triggers that fire when the player gets close, props that vanish on approach or after a timer, a random door unlocker, a rotation reset trigger, and a manager for the lamp anomaly.

Development. The code I inherited was tightly coupled, threw frequent exceptions, and made little use of polymorphism. Some data came from ScriptableObjects and the rest didn’t. I refactored the entire codebase, then developed the rest of the game in Unity myself.

I reworked the classes so allies and enemies work the same way, built a better turn system, and rebuilt the whole attack and movement preview. I tried to reuse the existing attack and movement patterns, but ended up rewriting those too. Data is now a mix of ScriptableObjects and JSON, and the JSON doubles as the save data.

Levels that build on each other. I designed the levels and the obstacles that shape them, each one building on the last. The first level is a single enemy and teaches the basics. The second splits the map in two, adds more enemies, and shows how walls two tiles thick get in the way of both moving and attacking. The third arranges the walls so that movement itself gets hard. Each level asks you to use what the one before it taught.

Balance. I set the stats for every ally and enemy. They live in JSON, and I tuned them by playtesting the game a lot, making sure each character has its own specialty. Since I designed both the levels and the stats, playtesting let me balance them together. When a character was too strong or a level too hard, I could adjust either side.

Small numbers. Stats used to run to values like 25 and 105, which felt bloated to me. I reworked them into small, simple numbers, so the player can do the math in their head and work out a fight at a glance, the way Hearthstone and Magic: The Gathering do.

Player controller. I built the player controller with 19 states, including walking, running, crouch walking and crouch running, hanging, rolling, a backflip, and slide jumps.

The hardest part was chaining them: a standing jump that turns into a backflip, lands in a slide, and lets you slide jump out of it, possibly into a wall. It took a lot of messing around, and sliding in general was the most troublesome. The idle animations that play after 10 seconds of standing still took me a whole day on their own, since some stop on their last frame and only go back to the default idle once you move.

Looking back, the states lived in a long chain of if and else checks, which is a big part of why chaining them was so hard. Today I’d build the controller as a proper state machine from the start.

I also wrote the collision system and integrated the Tiled maps.

Soldier AI. Soldiers see through a vision area and two line-of-sight checks, one to the player’s head and one to their feet, that tiles can block, and they give chase once they spot the player. Two checks because the player can cling to ceilings, where sometimes only their feet are in view.

Hearing. I added parkour and speed, and wanted something to balance them and make the stealth more interesting. So the faster you go, the more noise you make, which turns speed into a risk and reward choice. I designed and built the hearing system. Whistling sends out an expanding sound sphere that draws soldiers toward where it came from, and a soldier who is already chasing sends out spheres of its own that alert the others.

Look and sound. I added atmospheric lighting and an animated noise overlay generated with Pillow. I wrote the audio module, with music fades, sound effect channels and stingers, and added the music and sound effects.

Levels. I designed and built stages, reworked the first one, and added the title screen and the ending.

Painless deaths. When you die, you respawn almost instantly. Dying and trying again should feel like part of the game, not a failure state, the way it does in fast platformers like Super Meat Boy and Celeste.

Red Death Party is a short psychological horror visual novel that Ludomancer Studio made for Spooktober 2025, with a team of five. To fit the jam, the team chose simple backgrounds and character designs and a story that doesn’t branch. I couldn’t take part in the whole jam, so I handled the work that came last.

After a year locked in his house, Edgar accepts an invitation to wait out a pandemic in a millionaire’s underground mansion.

Translation. I translated the entire script from Portuguese to English: the introduction, three chapters and the final chapter, about 460 lines and 6,700 words of narration and dialogue in Naninovel.

My favorite part was Vamp. In the original she roleplays as a vampire. In English, with approval, I made her roleplay as a Shakespearean vampire, and talk normally whenever she steps out of character. She didn’t talk like that in Portuguese, but it made for stronger characterization.

I delivered the translation on September 29, 2025, one day before the project’s last commit.

Quality assurance. It’s a simple game, so I tested it by hand. I went through every feature, left it running, closed it at different moments, saved, loaded and deleted saves, and changed the settings and the resolution.

DESTRUA is a game I made alone in 2015 for a game jam, and my first attempt at a conventional game.

A lonely, self-aware robot trapped in a decaying factory remembers a single command, destroy, and a malfunctioning four-dimensional loop device resets reality every minute. Each reset undoes most of what the robot has done, but the items it carries survive, and so does everything the player has learned.

Logic. I built the game’s logic from RPG Maker’s switches, variables and conditional branches, including key and keycard doors, and position tracking for a wheelchair and colored objects.

Puzzles. I designed all of the factory’s levels and the puzzles in them, including a three-lever combination puzzle.

Plugins. I configured plugins for dynamic lighting, picking up and throwing objects, an in-game hint system, audio, events that play before the title screen, and a menu without combat options.

Writing. I wrote the story and all of the text, 588 messages and 34 choices, with custom colors, pauses and font sizes for the robot’s system messages.

At the end of my English course I could give a presentation on any subject, and I chose video games as art. Instead of slides, I made a game in English that makes the argument itself: a narrative walking simulator where the player learns about games to save Towney from an evil vampire, ending in a puzzle challenge.

It was my way of letting the medium speak for itself. The game makes the argument by being what it argues for. It shows every aspect of games, uses music from many different games, and tries to be beautiful. It tells a story, with interesting characters, funny and sad moments, and backstories, and it proves games can teach by teaching.

It also had to work for the person playing it in class: my teacher, who wasn’t a gamer. That’s why it’s a walking simulator. Anyone could walk through it, and no challenge could stop the presentation halfway.

Story structure. A storyline variable tracks the player’s progress through the main story, with separate threads for side characters such as Julia and the Captain.

The villain, Selene, is a vampire because she drains the happiness from the villages. She’s an immortal being who has corrupted the meaning of games. Her powers turn out to be a curse as well: at the end of the game, Roger becomes the vampire.

Staging. I staged scenes with move routes, map transfers and pictures, and set the mood with weather, dynamic lighting and timed events.

Levels and puzzles. I designed all 32 levels and built the puzzles, including position tracking for red, blue and yellow objects, backed by an in-game hint system.

Writing. I wrote all of the dialogue, 1,145 messages and 48 choices.