Structuring a Decision Tree in C# Without If Statements

Structuring a Decision Tree in C# Without If Statements

This article demonstrates how to structure a decision tree using pure C# code without relying on deeply nested if statements.

By using DecisionNode objects to represent each branching condition and outcome, we can make our logic cleaner, more readable, and easier to maintain.

Quest Tree Flow

[Level ≥ 15?]
├─ Yes → [Has "Ancient Key" + "Royal Seal"?]
│       ├─ Yes → [Completed "Tutorial" + "SideMission1"?]
│       │       ├─ Yes → 🎁 Grant special quest: Trial of the King
│       │       └─ No  → 📌 Complete side quests first
│       └─ No  → 🔑 Required items missing
└─ No  → [Has "VIP Token"?]
        ├─ Yes → 🎟️ Temporary quest unlocked for VIPs
        └─ No  → [Has "Hidden Scroll"?]
                 ├─ Yes → 🌀 Bonus quest unlocked
                 └─ No  → ⛔ Level too low to proceed

Code Components

  • DecisionNode : Holds a condition and branching result actions
  • Player : Stores the level, inventory, and completed quests
  • QuestSystem : Builds and evaluates the decision tree
  • Main : Sample use with mock player data

Full Source Code

// QuestDecisionNode.cs
using System;
using System.Collections.Generic;

class DecisionNode
{
    public Func<bool> Condition = null;
    public Action Result = null;
    public DecisionNode YesNode = null;
    public DecisionNode NoNode = null;
}

class Player
{
    public int Level;
    public List<string> Inventory = new List<string>();
    public List<string> CompletedQuests = new List<string>();

    public bool HasItem(string item) => Inventory.Contains(item);

    public bool HasItems(params string[] items)
    {
        foreach (var item in items)
            if (!Inventory.Contains(item)) return false;
        return true;
    }

    public bool HasCompleted(string quest) 
                => CompletedQuests.Contains(quest);
}

class QuestSystem
{
    private Player player;

    public QuestSystem(Player player)
    {
        this.player = player;
    }

    public DecisionNode BuildQuestDecisionTree()
    {
        return new DecisionNode
        {
            Condition = () => player.Level >= 15,
            YesNode = new DecisionNode
            {
                Condition = 
                () => player.HasItems("Ancient Key","Royal Seal"),
                
                YesNode = new DecisionNode
                {
                    Condition = 
                    () => player.HasCompleted("Tutorial") 
                          && player.HasCompleted("SideMission1"),
                
                    YesNode = new DecisionNode
                    {
                        Condition = null,
                        Result = () => Console.WriteLine
                        ("🎁 Grant special quest: Trial of the King")
                    },
                    
                    NoNode = new DecisionNode
                    {
                        Condition = null,
                        Result = () => Console.WriteLine
                        ("📌 Complete side quests first")
                    }
                },
                
                NoNode = new DecisionNode
                {
                    Condition = null,
                    Result = () => Console.WriteLine
                    ("🔑 Required items missing")
                }
            },
            
            NoNode = new DecisionNode
            {
                Condition = () => player.HasItem("VIP Token"),
                
                YesNode = new DecisionNode
                {
                    Condition = null,
                    Result = () => Console.WriteLine
                    ("🎟️ Temporary quest unlocked for VIPs")
                },
                
                NoNode = new DecisionNode
                {
                    Condition = () => player.HasItem("Hidden Scroll"),
                    
                    YesNode = new DecisionNode
                    {
                        Condition = null,
                        Result = () => Console.WriteLine
                        ("🌀 Bonus quest unlocked")
                    },
                    
                    NoNode = new DecisionNode
                    {
                        Condition = null,
                        Result = () => Console.WriteLine
                        ("⛔ Level too low to proceed")
                    }
                }
            }
        };
    }

    public void EvaluateTree(DecisionNode node)
    {
        if (node == null) return;

        if (node.Condition != null)
        {
            if (node.Condition())
                EvaluateTree(node.YesNode);
            else
                EvaluateTree(node.NoNode);
        }
        else
        {
            node.Result?.Invoke();
        }
    }
}

class Program
{
    static void Main()
    {
        var player = new Player
        {
            Level = 12,
            Inventory = new List<string>
            { "Ancient Key", "Hidden Scroll" },
            
            CompletedQuests = new List<string> { "Tutorial" }
        };

        var questSystem = new QuestSystem(player);
        var root = questSystem.BuildQuestDecisionTree();
        questSystem.EvaluateTree(root);
    }
}

Benefits of This Hardcoded Tree

  • Clear decision flow without if-statements
  • Readable, declarative structure using lambdas
  • Condition = null used explicitly to mark terminal nodes
  • Clean tree structure, easy to test and maintain

Final Thoughts

You don’t need JSON or ScriptableObjects to build decision logic.

This hardcoded tree structure is powerful enough to handle moderate game logic scenarios without becoming unreadable.

Later, you could replace this with external data (e.g., JSON) to enable designers to build the logic themselves. But for now? This approach is elegant, clean, and totally usable. 😄

Popular posts from this blog

Understanding Arrays as Reference Types in C#

Image
Arrays as Reference Types In programming, it's important to understand the behavior of arrays. In most programming languages including C#, arrays are treated as reference types. This article will explore what that means and how to use that knowledge effectively. Value Types vs Reference Types In C#, data types are categorized into two main types: Value types : Store actual values directly. Examples : int , float , bool , struct Reference types : Store memory addresses instead of the actual values. Examples: class , string , array , delegate Arrays, like classes, are reference types. When you assign one array variable to another, you're copying the reference, not the actual data. Example: Arrays as Reference Types using System; class Program { static void Main() { int[] array1 = { 1, 2, 3 }; int[] array2 = array1; // Copy reference array2[0] = 100; Console.WriteLine(array1[0]); // Out...
Read more

Setting Up a Basic Follow Camera with Cinemachine 3.x

Image
Setting Up a Basic Follow Camera with Cinemachine 3.x Cinemachine has been significantly upgraded in version 3.x, introducing new concepts, improved terminology, and a refined workflow. In this post, we’ll go through how to set up a simple follow camera using the latest version. For more advanced examples, be sure to check out the sample scenes provided in the Cinemachine package—they’re very helpful for understanding the system. Install the Cinemachine Package Start by downloading and importing the Cinemachine package from the Unity Package Manager. Check the Main Camera After installation, you'll notice that the Main Camera now has a Cinemachine Brain component attached. Make sure the Live Camera field shows the name of your Cinemachine Camera. Create a Cinemachine Camera In the Hierarchy window, right-click and go to Cinemachine > Cinemachine Camera to create a new virtual camera. Set the Tracking Targe...
Read more

How to Initialize Struct – C# Struct Initialization Guide

Image
How to Initialize Struct – C# Struct Initialization Guide In C#, there are multiple ways to declare and initialize structs. While using just one method is often enough, it's common to encounter different initialization styles in real-world code. This guide summarizes the most common approaches, including how to handle struct arrays and lists. Struct Declaration struct Item { public string name; public int price; public string desc; } 1. Declare First, Assign Later This is the most straightforward method. Declare the struct first, then assign values to its fields one by one. Item item; item.name = "Fireball"; item.price = 100; item.desc = "Deals fire damage to the enemy."; Note: Structs are value types, so you can declare them without new . However, you must initialize all fields before use, or you'll get a compile-time error. 2. Use new and Assign Fields Item item = new Item(); item.name = "Fir...
Read more