Build Behavior Trees Like You Think

Node AcquireItem(Func<string> getItemID, Action lifecycle = null) => Selector("Acquire Item", () =>
{
    var itemID = Variable(getItemID);
    var item = Variable(() => Item.FindWithID(itemID.Value));
    var recipe = Variable(() => ItemDatabase.GetFromID(itemID.Value));
}

Node UseTool(Action lifecycle = null) => Leaf("Use Tool", () =>
{
    OnEnter(async ct => await PlayEquipToolAnimation(ct));
    OnSuccess(async ct => await Celebrate(ct));
    OnExit(async ct => await PutAwayToolAnimation(ct));

    OnBaseTick(() =>
    {
        PerformToolTask();
        return ToolTaskCompleted ? Status.Success : Status.Running;
    });

    lifecycle?.Invoke()
});

Node AI() => Reactive * Sequence("AI", () =>
{
    Sequence("Perform Task", () => 
    {
        OnSuccess(() => Debug.Log("Perform Task Sequence Succeeded"));

        Condition("Has Task", HasTask);
        UseTool(() => 
        {
            OnEnter(() => Debug.Log("Starting Tool Task");
            OnSuccess(() => Debug.Log("Tool Task Completed Successfully"));
        });
    });

    // ...
});

Reactive * Sequence("Guard Dog", () =>
{
    var distance = Variable(() => 0f);
    OnTick(() => distance.Value = DistanceToPlayer());

    D.ConditionLatch("Too Close", () => distance.Value < 3f);
    D.Until("Far Enough", () => distance.Value > 5f);
    Chase(() => Player, () =>
    {
        OnEnter(() => Debug.Log("Guard Dog began chasing player!"));
        OnExit(() => Debug.Log("Guard Dog stopped chasing player."));
    });

    Sequence(() =>
    {
        WaitUntil("Return To Post", () => MoveTo(Post.transform.position));
        JustRunning("Idle");
    });
});

Node AcquireItem(Func<string> getItemID) => Selector(() =>
{
    var itemID = Variable(getItemID);

    // Already have it?
    Condition(() => Inventory.Contains(itemID.Value));

    // Can collect it from world?
    D.Condition(() => ItemExists(itemID.Value));
    YieldSimpleCached(() => CollectItem(itemID));

    // Need to craft it? (RECURSION!)
    D.Condition(() => IsCraftable(itemID.Value));
    YieldSimpleCached(() => CraftItem(itemID));
});

Node CraftItem(Func<string> getItemID) => Sequence(() =>
{
    var recipe = Variable(() => GetRecipe(getItemID()));

    // Acquire each ingredient recursively!
    D.ForEach(() => recipe.Value.Ingredients, out var item);
    YieldSimpleCached(() => AcquireItem(item));

    Wait(() => recipe.Value.CraftTime);
});

Node Cook(Func<string[]> getIngredients, out Func<Food> getResultFood)
{
    VariableType<Food> resultFood = null;
    getResultFood = () => resultFood.Value;

    return Leaf("Cook", () =>
    {
        var timeBegan = Variable(0f);

        OnEnter(() =>
        {
            resultFood.Value = Food.FromIngredients(getIngredients());
            timeBegan.Value = Time.time;
            BeginCookingAnimation();
        });

        OnExit(() => StopCookingAnimation());

        OnBaseTick(() =>
        {
            return Time.time - timeBegan.Value >= resultFood.Value.cookTime
                ? Status.Success
                : Status.Running;
        });
    });
}

Node Eat(Func<Food> getFood) => Leaf("Eat Meal", () =>
{
    OnSuccess(() =>
    {
        var food = getFood();
        Health += food.healthRestored;
        Hunger = 0;
    });

    OnBaseTick(() => PerformEatingAnimation() ? Status.Success : Status.Running);
});

Sequence(() =>
{
    Condition("Is Hungry", () => Satiation < 50);
    Cook(RandomIngredientsFromInventory, out var getFood);

    // Cooked food flows directly to Eat - seamless chaining!
    Eat(getFood);
});

// Raw mouse position updates every tick
var mousePos = UseEveryTick(MouseWorldPosition);

// Build a transformation pipeline
var smoothPos = UsePipe(mousePos,
    v => UseThrottle(0.025f, v),        // Limit updates
    v => UseRollingBuffer(15, false, v), // Keep last 15
    v => UseSelect(v, buffer =>          // Average them
    {
        var avg = Vector3.zero;
        foreach (var pos in buffer) avg += pos;
        return avg / buffer.Count;
    })
);

// smoothPos.Value is always the smoothed mouse position!
// No manual updates. No polling. Just works.

Node AI = YieldSimple("Enemy AI", () =>
{
    var state = Variable(() => 0);  // 0=Idle, 1=Combat, 2=Flee
    Node idleNode = null, combatNode = null, fleeNode = null;

    OnTick(() => // Global Interrupt
    { 
        if (Health < 20) 
            state.Value = 2; 
    });  

    return () => state.Value switch
    {
        0 => idleNode ??= IdlePatrol(() =>
        {
            OnTick(() =>
            {
                if (HasTargetInSight())
                    state.Value = 1;
            });
        }),

        1 => combatNode ??= CombatBehavior(() =>
        {
            OnSuccess(() => state.Value = 0);  // Target down
            OnFailure(() => state.Value = 2);  // Can't win → Flee
        }),

        2 => fleeNode ??= FleeBehavior(() => OnSuccess(() => state.Value = 0)),

        _ => null
    };
});