The Colony 2044

Systems thinking with Scriptable Objects

One of our main goals was an extensible, data-driven architecture that supported my design choices and minimized redundant code. With our engineering team, we leaned heavily on Unity's Scriptable Object architecture to define everything from crafting stations to colonist tasks.

Each station, whether a weapons table, farm plot, or mineshaft, was a Scriptable Object describing its function, the resources it consumed or produced, and any unique behaviors it triggered. Colonists were assigned to stations dynamically through an AI task system, which I implemented with our engineers. It read station availability and resource conditions to pick the best jobs in real time.

Tasks were modular: each type (crafting, hauling, resting, defending) was a flexible behavior tree node with its logic abstracted away, so new station types could be created without rewriting base systems. That made iteration fast and let production and variety scale as the game grew.

Building a modular UI framework

I designed and implemented most of the game's menus: colony management panels, colonist selection, station interfaces, and resource inventories. To handle the game's scale, I built a modular menu system that generates panels from configuration data.

Instead of hardcoding every menu, a panel generator reads configuration assets (Scriptable Objects again) that define each menu's components, from buttons, progress bars, and sliders to nested data tables and task queues. A new menu layout is just structure and behavior defined in a single asset.

The benefits were twofold:

1. Rapid iteration during playtesting and UX feedback sessions, since menus could be adjusted without recompiling.
2. Systemic cohesion, because every menu shared components and data bindings, making them reliable, consistent, and easy to debug.

It also enabled context-aware behavior. For example, the colonist panel can show task status, mood, health, and relationships in different ways depending on game state or player focus.

public abstract class WorkMenu<TEntity> : UIBaseWorkMenu<TEntity> where TEntity : Entity, IHasWorkers
{
    [SerializeField, Optional] protected WorkMenuItemArea optionItemList;
    [SerializeField, Optional] protected WorkMenuItemArea queueItemList;
    [SerializeField, Optional] protected WorkMenuItemArea workersItemList;
    [SerializeField] protected WorkItemDetails details;
    [SerializeField] protected UIButtonPrompts prompts;

    protected EntityRef<TEntity> station;

    protected override void OnDisplay(TEntity station)
    {
        this.station = station;

        Rebuild();
        details.Hide();
    }

    protected override void OnHidden()
    {
        optionItemList.List.Clear();
        queueItemList.List.Clear();
        workersItemList.List.Clear();
    }

    protected abstract (Func<string> optionsTitle, Func<string> queueTitle, Func<string> workersTitle) AreaTitles
    {
        get;
    }

    protected abstract IEnumerable<QueueableStationItemUI.QueueableIconActions> OptionItemDatas(TEntity station);

    protected abstract IEnumerable<QueueableStationItemUI.QueueableIconActions> QueueItemDatas(TEntity station);

    protected abstract IEnumerable<QueueableStationItemUI.QueueableIconActions> WorkerItemDatas(TEntity station);
}

public class StationWorkMenu : WorkMenuQueue<StationEntity>
{
    protected override (Func<string> optionsTitle, Func<string> queueTitle, Func<string> workersTitle) AreaTitles =>
    (
        () => "Recipes",
        () => $"Queue ({queue?.BillCount ?? -99}/5)",
        null
    );

    protected override IEnumerable<QueueableStationItemUI.QueueableIconActions> OptionItemDatas(StationEntity station)
    {
        foreach (var recipe in station.Data.allowedRecipes)
        {
            QueueableStationItemUI.QueueableIconActions actions = new()
            {
                updateCount = () => 0,
                onButtonClicked = () => AddRecipe(recipe, 1),
                onShiftClick = () => AddRecipe(recipe, 10),
                onQueueItemHoverChanged = hovered => OnHover(recipe, hovered),
                getSprite = () => recipe.Task.data.Icon,
                type = QueueableStationItemUI.ItemType.Add,
            };

            yield return actions;
        }
    }

    protected override IEnumerable<QueueableStationItemUI.QueueableIconActions> QueueItemDatas(StationEntity station)
    {
        foreach (var bill in (station as IHasWorkQueue).Queue)
        {
            QueueableStationItemUI.QueueableIconActions actions = new()
            {
                updateCount = () => bill.limit.SingleValue * bill.Data.OutputItem.count,
                onButtonClicked = () => RemoveRecipe(bill, 1),
                onShiftClick = () => RemoveRecipe(bill, 10),
                workCompleteAmount = () => bill.ActiveTask?.NormalizedProgress ?? 0,
                getSprite = () => bill.Data.Task.data.Icon,
                onQueueItemHoverChanged = hovered => OnHover(bill.Data, hovered),
                type = QueueableStationItemUI.ItemType.Remove,
            };

            yield return actions;
        }
    }

    protected override IEnumerable<QueueableStationItemUI.QueueableIconActions> WorkerItemDatas(StationEntity station)
    {
        yield break;
    }
}

Leadership & vision

As Project Lead, I kept us focused on a game that was both strategic and emotionally resonant. The zombie bunnies weren't just enemies: they were once part of some colony, and discovering the cure hidden in one of your survivors added narrative tension and mystery. That leaned into one of our core pillars, Thematic Immersive Survival.

My role included:

• Planning development milestones and scoping systems with the team
• Coordinating art, design, and programming so features landed smoothly
• Writing internal documentation and task specs to keep things clear and reduce bottlenecks
• Running design reviews to check features for player agency, clarity, and emotional tone

Design philosophy

Every system I built for The Colony 2044 followed a few pillars:

• ModularityBuild more, faster, with less overhead.
• AccessibilityLess dependence on engineers for content creation.
• ExpressivenessEmergent stories, like a medic bunny abandoning their post to grieve a lost friend, or a survivor hoarding food out of fear.

These choices made a game that wasn't just functional, but alive and full of unexpected interactions and player-driven stories.

Achievements

Out of dozens of indie titles at DreamHack Dallas, The Colony 2044 was voted Audience Choice by attendees for its blend of strategy, charm, and post-apocalyptic bunny drama. After years of hard work, it was a blast watching players enjoy it.