Personal · Mar–May 2025
Void Protocol
A survivors-like built to explore whether difficulty changes how much fun players have.

TL;DR
- Built a survivors-like solo in eight weeks: 3 difficulties, 10 enemy types, and 10 upgrades across 5 rarity tiers.
- Wrote an in-game telemetry system that records every run, for data-driven balancing.
- Became the foundation of my B.Sc. thesis on classifying player behavior.
Overview
Void Protocol started from one question:
Does a game's difficulty change how much fun players have with it?
To explore it, I built a survivors-like with three difficulty levels: Calm Seas, Balanced Encounter and Merciless Gauntlet. Each step up raises the enemy count, the damage enemies deal and the overall intensity, on purpose.
Built for a study
The game was designed so a run could be measured, not just played:
- Telemetry: a
GlobalDataCollectorManageranonymously records gameplay data during each run and writes it to a text file. - Survey design: a questionnaire about how each run felt, meant to be cross-referenced with that run's data.
The survey was never run as a standalone study. The question, and the telemetry behind it, carried over into my B.Sc. thesis. There they grew into a hybrid model that classifies player motivation (Bartle's typology) from self-report, content choices, performance telemetry and engagement, to guide real-time game adaptation. The thesis uses a redesigned Void Protocol as its proof of concept, and it was graded 9.5 out of 10. The thesis is linked below, in Portuguese.
What I built
- Survivors-like core loop: fast top-down action in the style of the genre's classics.
- Upgrades: level up from EXP and choose upgrades for your weapons and abilities: 10 upgrades across 5 rarity tiers.
- 3 difficulties, 10 enemy types: each difficulty includes the enemies of the ones before it, picked from a weighted random pool on every spawn.
- Special spawn patterns: after a set time, the
SpawnManagertries to unleash a special wave. If it fails, it goes on cooldown and gets a higher chance next time. - Bosses with special abilities that trigger periodically.
- Enemy behavior that changes with difficulty and with what the player does.
- Audio integrated through FMOD, with original music and sound effects made in LMMS and Audacity.
Challenges
Spawning that scales with difficulty
The spawn system had to scale across three difficulty levels and still feel fair at each one. Tuning the weighted enemy selection and the cooldown logic took a lot of iteration and playtesting before each difficulty felt distinct.
Keeping the code maintainable as it grew
I used the project to research and apply game programming patterns:
- Visitor for flexible interactions between different game entities.
- Chain of Responsibility for event-driven behaviors and decision flows.
- Object Pool to reuse projectiles, enemies and VFX.
- Factory for clean, scalable object creation.
From the thesis prototype
The redesigned Void Protocol that my thesis uses as its proof of concept is built around a stat mediator. Buffs, debuffs and permanent upgrades are all modifiers that subscribe to it, and reading a stat sends one query through every active modifier. Upgrades choose their math through the Strategy pattern, so a new kind of upgrade is a new strategy class, with no change to the stat code.
// CharacterStats.cs: every stat read runs through the mediator
public float GetStat(AttributeType type)
{
// Reuse the query object to prevent GC allocation
_reusableQuery.StatType = type;
_reusableQuery.Value = GetBaseValue(type);
_mediator.PerformQuery(this, _reusableQuery);
return _reusableQuery.Value;
}
// StatsMediator.cs: modifiers subscribe to queries...
public void AddModifier(StatModifier modifier)
{
_modifiers.Add(modifier);
Queries += modifier.Handle;
modifier.OnDispose += HandleModifierDisposal;
}
// ...and unsubscribe when they expire, removed after the update loop
private void HandleModifierDisposal(StatModifier modifier)
{
modifier.OnDispose -= HandleModifierDisposal;
Queries -= modifier.Handle;
_modifiersToRemove.Add(modifier);
}
// FunctionalStatModifier.cs: an upgrade is an operation on one stat
public override void Handle(object sender, Query query)
{
if (query.StatType == _type)
{
query.Value = _operation(query.Value);
}
}
An excerpt from three files of the prototype, trimmed for length. The repository is private.
What I learned
How to instrument a game for player data, and how much it pays to design with data. Managing spawn rates, EXP curves, enemy counts and cooldowns in spreadsheets kept balancing decisions grounded and organized.
Media
Trailer
Gameplay
Like this?
Let's talk
Open to conversations about developer and production roles, and collaborations. I'm in Recife, Brazil (UTC−3).