Building a Robust Skill Tree in Unity with Scriptable Objects

Posted by Gemma Ellison

July 14, 2025

The progression system can make or break a game. A well-designed skill tree, offering meaningful choices and tangible character growth, is crucial for player engagement. But many developers find themselves wrestling with complex data structures and clunky UI implementations, resulting in a frustrating development experience. This is often a consequence of approaching the system without a clear, data-driven strategy. Let’s build a simplified, yet robust, skill tree in Unity using Scriptable Objects to define skills and a streamlined UI for visualization and interaction. This approach emphasizes clarity, maintainability, and scalability, saving you countless hours of debugging and refactoring down the line.

Defining Skills with Scriptable Objects

Scriptable Objects are perfect for defining skill data. They act as data containers that live outside the scene, preventing data loss and allowing for easy editing and reuse.

Create a Scriptable Object:

using UnityEngine;

[CreateAssetMenu(fileName = "NewSkill", menuName = "Skill Tree/Skill")]
public class Skill : ScriptableObject
{
    public string skillName;
    [TextArea]
    public string description;
    public Sprite icon;
    public int cost;
    public Skill[] prerequisites;
    public StatModifier[] statModifiers;
}

[System.Serializable]
public struct StatModifier
{
    public string statName;
    public float value;
    public ModifierType type;
}

public enum ModifierType { Additive, Multiplicative }

Define the Skill Properties: skillName (string), description (string), icon (Sprite), cost (int), prerequisites (Skill[]), and statModifiers (StatModifier[]). The statModifiers array lets you apply stat bonuses upon unlocking a skill. I strongly advise against hardcoding stat changes directly in your scripts. Instead, create a system to dynamically apply these modifiers.
Why Scriptable Objects? This approach promotes data-driven design. Instead of hardcoding skill data in your game logic, you define skills as assets. This makes it easier to balance, modify, and expand the skill tree without touching your code. Imagine trying to change the cost of a skill buried deep in your game logic versus simply editing a Scriptable Object.

Building the Skill Tree UI

A clear and intuitive UI is vital for presenting the skill tree to the player.

Create Skill Nodes: Each skill should be represented by a UI element (e.g., an Image or Button). Attach a script to each node that references the corresponding Skill Scriptable Object.
Connect the Nodes: Use Unity’s UI system (e.g., LineRenderer or custom lines) to visually represent the dependencies between skills. This is where a lot of developers make mistakes. Don’t just use static lines; implement a system to dynamically update the lines based on the positions of the skill nodes. This is crucial for accommodating different screen sizes and resolutions.
Implement Skill Information Display: When a player selects a skill node, display its skillName, description, and cost in a dedicated UI panel. Displaying the prerequisites is just as crucial.
Example Scenario: Consider a simple skill tree with three skills: “Basic Attack,” “Power Attack,” and “Critical Strike.” “Power Attack” requires “Basic Attack,” and “Critical Strike” requires “Power Attack.” The UI would show these skills as nodes connected by lines, clearly indicating the progression path.

Implementing Skill Unlocking and Stat Modifications

The core logic of the skill tree lies in unlocking skills and applying stat modifications.

Skill Unlocking Logic: Implement a function to check if a skill can be unlocked. This involves verifying if the player has enough points and if all prerequisites are met.

public bool CanUnlock(Skill skill)
{
    if (skillPoints < skill.cost) return false;
    foreach (Skill prerequisite in skill.prerequisites)
    {
        if (!unlockedSkills.Contains(prerequisite)) return false;
    }
    return true;
}

Applying Stat Modifiers: When a skill is unlocked, iterate through its statModifiers array and apply the corresponding bonuses to the player’s stats.

public void UnlockSkill(Skill skill)
{
    if (!CanUnlock(skill)) return;

    skillPoints -= skill.cost;
    unlockedSkills.Add(skill);

    foreach (StatModifier modifier in skill.statModifiers)
    {
        ApplyStatModifier(modifier);
    }
}

void ApplyStatModifier(StatModifier modifier)
{
    // Logic to apply the stat modifier based on modifier.statName, modifier.value, and modifier.type
    // Example:
    if (modifier.statName == "AttackDamage")
    {
        if (modifier.type == ModifierType.Additive)
        {
            attackDamage += modifier.value;
        }
        else if (modifier.type == ModifierType.Multiplicative)
        {
            attackDamage *= modifier.value;
        }
    }
}

Common Pitfalls: A frequent mistake is directly modifying the stat values. This makes it difficult to revert changes or implement temporary buffs. Instead, use a modifier stack. Each unlocked skill adds a modifier to the stack, and when a skill is reset, the modifier is removed. This provides a flexible and reversible system.

Real-World Application: A Simple RPG

Imagine you’re developing a simple RPG. You can use this skill tree system to allow players to customize their character’s abilities. A warrior might have skills that increase their attack damage and defense, while a mage might have skills that enhance their spellcasting abilities and mana regeneration. By using Scriptable Objects and a dynamic UI, you can easily add new skills, balance the progression, and create diverse character builds.

By embracing a data-driven approach using Scriptable Objects, you’ll find that creating compelling skill trees becomes a far less daunting task. The key is to focus on modularity and flexibility, allowing for easy expansion and modification as your game evolves. This initial investment in a solid foundation will save you countless headaches down the road and allow you to focus on what truly matters: creating an engaging and rewarding experience for your players. Remember, a well-designed skill tree is more than just a feature; it’s a core element of player progression and a powerful tool for driving long-term engagement.