Iterative Unlocks: Branching Your Game's Narrative Tree

Posted by Gemma Ellison

July 27, 2025

Let’s talk about branching narratives. Not the kind that balloon into a bloated mess of unfinished content, but the kind that organically grow from the gameplay itself. I’m talking about iterative unlocks.

The Allure (and Danger) of Choice

Branching narratives are sexy. Players love feeling like their choices matter, and as developers, we love the idea of crafting intricate stories that respond to player agency.

But here’s the cold, hard truth: most indie studios can’t afford to write, implement, and test a sprawling, multi-path narrative. It’s scope creep incarnate.

The solution? Iterative unlocks. Small, impactful changes to the narrative, world, or gameplay that unlock based on player actions. These don’t demand rewriting the entire story, but they do create a sense of meaningful progression and choice.

Planning for Limited Resources

Forget giant flowcharts with dozens of branches. That’s AAA territory.

Instead, start with the core narrative. What’s the central conflict? What are the major milestones? Identify 2-3 key points where a minor divergence can occur.

For instance, in a detective game, instead of branching the entire case, consider a single, smaller side case that becomes available only if the player possesses a specific skill (lockpicking) or piece of evidence. This side case provides additional context or resources, but doesn’t fundamentally alter the main plot if skipped.

This “micro-branching” approach is manageable.

Designing Engaging Unlock Conditions

An unlock isn’t engaging if it’s arbitrary. The condition for unlocking new content needs to feel organic to the game’s mechanics and narrative.

Consider these options:

Skill-Based Unlocks: Mastering a specific skill opens up new dialogue options, areas, or interactions. For example, learning a particular language in a fantasy RPG could unlock interactions with a hidden faction.
Item-Based Unlocks: Acquiring a rare item grants access to a previously inaccessible area or triggers a unique event. Maybe that old key unlocks a hidden basement with a vital clue.
Choice-Based Unlocks: A decision early in the game alters the player’s reputation, affecting how NPCs react and what quests become available. This isn’t about a “good” or “bad” ending, but about nuanced shifts in the world.
Stat-Based Unlocks: Reaching a certain threshold in a stat, like persuasion or intimidation, opens up different routes in conversations. This encourages players to invest in specific builds.

Avoid “grindy” unlock conditions. Collecting 100 feathers just to unlock a single line of dialogue is not engaging. The unlock should feel like a natural consequence of playing the game.

Concrete Examples: Unity and Godot

Let’s get practical. Here are some basic code snippets demonstrating how to implement unlock systems in Unity and Godot.

Unity

Here’s how to unlock a new scene based on a specific item being in the player’s inventory.

using UnityEngine;
using UnityEngine.SceneManagement;
using System.Collections.Generic;

public class ItemUnlock : MonoBehaviour
{
    public string unlockItemName = "RustyKey";
    public string sceneToUnlock = "HiddenArea";

    private Inventory inventory;

    void Start()
    {
        inventory = GetComponent<Inventory>(); // Assuming the Inventory script is on the same GameObject
        if (inventory == null)
        {
            Debug.LogError("Inventory script not found!");
        }
    }

    public void CheckForUnlock()
    {
        if (inventory.HasItem(unlockItemName))
        {
            SceneManager.LoadScene(sceneToUnlock);
        }
        else
        {
            Debug.Log("You need the " + unlockItemName + " to unlock this area.");
        }
    }
}

//And here is the Inventory Script
public class Inventory : MonoBehaviour
{
    public List<string> items = new List<string>();

    public void AddItem(string itemName)
    {
        items.Add(itemName);
    }

    public bool HasItem(string itemName)
    {
        return items.Contains(itemName);
    }
}

Attach ItemUnlock to the gameobject you want to check for the item on.

This shows how to unlock a scene, but this could be applied to dialogue options, new enemies, or map locations.

Godot

Here’s how to unlock a dialogue option based on a player’s skill level in Godot:

extends Node

var persuasion_skill = 0
var has_unlocked_dialogue = false

func _ready():
    # Load the player's skill level from save data or initialize it
    persuasion_skill = 5 # Example: Player starts with a skill level of 5

func check_dialogue_unlock():
    if persuasion_skill >= 10 and not has_unlocked_dialogue:
        # Unlock the special dialogue option
        has_unlocked_dialogue = true
        print("Dialogue option unlocked!")
        # Signal the Dialogue Manager to enable the new option
        emit_signal("dialogue_option_unlocked")

signal dialogue_option_unlocked

This demonstrates the basic logic. You would need to connect the dialogue_option_unlocked signal to your dialogue manager to actually enable the new option in the UI.

These snippets are basic, but they illustrate the core principle: use flags and checks to gate content based on player actions.

Common Mistakes and How to Avoid Them

Over-scoping: Trying to create too many branches, leading to unfinished content. Solution: Focus on micro-branching and prioritize a few well-executed divergences.
Arbitrary Unlock Conditions: Unlocks that don’t feel connected to the game’s mechanics or narrative. Solution: Tie unlocks to meaningful actions, skills, or choices.
Ignoring Playtesting: Not testing the unlock system thoroughly, leading to bugs or imbalances. Solution: Get feedback early and often, and be prepared to adjust unlock conditions based on player behavior.
Lack of Player Feedback: Not providing clear feedback to the player about how to unlock new content. Solution: Use tooltips, dialogue hints, or in-game tutorials to guide players.

Iteration is Key

The beauty of iterative unlocks is right there in the name: iteration. Start small, test thoroughly, and expand gradually. Don’t try to build a branching narrative behemoth from the start.

Focus on creating small, meaningful changes that reward player agency and deepen engagement. Your players (and your budget) will thank you.

**Iterative Unlocks: Branching Your Game's Narrative Tree**