BehaviorTree.cpp

Go to the documentation of this file.

/*
Olympe Engine V2 - 2025
Nicolas Chereau
nchereau@gmail.com
 
This file is part of Olympe Engine V2.
 
Behavior Tree implementation: JSON loading and built-in node execution.
 
*/
 
#include "BehaviorTree.h"
#include "BehaviorTreeDependencyScanner.h"
#include "../ECS_Components_AI.h"
#include "../ECS_Components.h"
#include "../World.h"
#include "../system/system_utils.h"
#include "../json_helper.h"
#include "../CollisionMap.h"
#include "../GameEngine.h"
#include <cmath>
#include <functional>
#include <set>
 
using json = nlohmann::json;
 
// --- BehaviorTreeManager Implementation ---
 
bool BehaviorTreeManager::LoadTreeFromFile(const std::string& filepath, uint32_t treeId)
{
    std::cout << "\n[BehaviorTreeManager] ========================================" << std::endl;
    std::cout << "[BehaviorTreeManager] Loading: " << filepath << std::endl;
    
    try
    {
        // 1. Load JSON file
        std::cout << "[BehaviorTreeManager] Step 1: Loading JSON file..." << std::endl;
        json j;
        if (!JsonHelper::LoadJsonFromFile(filepath, j))
        {
            std::cerr << "[BehaviorTreeManager] ERROR: Failed to load file: " << filepath << std::endl;
            std::cout << "[BehaviorTreeManager] ========================================+n" << std::endl;
            return false;
        }
        std::cout << "[BehaviorTreeManager] JSON loaded successfully" << std::endl;
        
        // 2. Detect version
        std::cout << "[BehaviorTreeManager] Step 2: Detecting format version..." << std::endl;
        bool isV2 = j.contains("schema_version") && j["schema_version"].get<int>() == 2;
        std::cout << "[BehaviorTreeManager] Version: " << (isV2 ? "v2" : "v1") << std::endl;
        
        // 3. Extract tree metadata and data section
        std::cout << "[BehaviorTreeManager] Step 3: Extracting tree metadata..." << std::endl;
        BehaviorTreeAsset tree;
        tree.id = treeId;
        
        const json* dataSection = &j;
        
        if (isV2)
        {
            tree.name = JsonHelper::GetString(j, "name", "Unnamed Tree");
            
            if (!j.contains("data"))
            {
                std::cerr << "[BehaviorTreeManager] ERROR: v2 format but no 'data' section" << std::endl;
                std::cout << "[BehaviorTreeManager] ========================================+n" << std::endl;
                return false;
            }
            
            dataSection = &j["data"];
            std::cout << "[BehaviorTreeManager] Extracted 'data' section from v2 format" << std::endl;
        }
        else
        {
            tree.name = JsonHelper::GetString(j, "name", "Unnamed Tree");
            std::cout << "[BehaviorTreeManager] Using root as data section (v1 format)" << std::endl;
        }
        
        tree.rootNodeId = JsonHelper::GetUInt(*dataSection, "rootNodeId", 0);
        std::cout << "[BehaviorTreeManager] Tree name: " << tree.name << std::endl;
        std::cout << "[BehaviorTreeManager] Root node ID: " << tree.rootNodeId << std::endl;
        
        // 4. Parse nodes
        std::cout << "[BehaviorTreeManager] Step 4: Parsing nodes..." << std::endl;
        if (!JsonHelper::IsArray(*dataSection, "nodes"))
        {
            std::cerr << "[BehaviorTreeManager] ERROR: No 'nodes' array in data section" << std::endl;
            std::cerr << "[BehaviorTreeManager] This may be an empty or invalid tree" << std::endl;
            
            // For debug: display JSON structure
            std::cout << "[BehaviorTreeManager] JSON structure:" << std::endl;
            std::cout << j.dump(2) << std::endl;
            
            std::cout << "[BehaviorTreeManager] ========================================+n" << std::endl;
            return false;
        }
        
        // Count nodes first
        int nodeCount = 0;
        JsonHelper::ForEachInArray(*dataSection, "nodes", [&nodeCount](const json& nodeJson, size_t i) { nodeCount++; });
        std::cout << "[BehaviorTreeManager] Found " << nodeCount << " nodes to parse" << std::endl;
        
        JsonHelper::ForEachInArray(*dataSection, "nodes", [&tree, isV2](const json& nodeJson, size_t i)
        {
            BTNode node;
            node.id = JsonHelper::GetInt(nodeJson, "id", 0);
            node.name = JsonHelper::GetString(nodeJson, "name", "");
            
            std::string typeStr = JsonHelper::GetString(nodeJson, "type", "Action");
            if (typeStr == "Selector") node.type = BTNodeType::Selector;
            else if (typeStr == "Sequence") node.type = BTNodeType::Sequence;
            else if (typeStr == "Condition") node.type = BTNodeType::Condition;
            else if (typeStr == "Action") node.type = BTNodeType::Action;
            else if (typeStr == "Inverter") node.type = BTNodeType::Inverter;
            else if (typeStr == "Repeater") node.type = BTNodeType::Repeater;
            
            // Parse child IDs for composite nodes
            if (JsonHelper::IsArray(nodeJson, "children"))
            {
                JsonHelper::ForEachInArray(nodeJson, "children", [&node](const json& childId, size_t j)
                {
                    node.childIds.push_back(childId.get<uint32_t>());
                });
            }
            
            // Parse condition type
            if (node.type == BTNodeType::Condition && nodeJson.contains("conditionType"))
            {
                std::string condStr = JsonHelper::GetString(nodeJson, "conditionType", "");
                node.conditionTypeString = condStr; // Store string for flexible conditions
                
                if (condStr == "TargetVisible" || condStr == "HasTarget") 
                    node.conditionType = BTConditionType::TargetVisible;
                else if (condStr == "TargetInRange" || condStr == "IsTargetInAttackRange") 
                    node.conditionType = BTConditionType::TargetInRange;
                else if (condStr == "HealthBelow") 
                    node.conditionType = BTConditionType::HealthBelow;
                else if (condStr == "HasMoveGoal") 
                    node.conditionType = BTConditionType::HasMoveGoal;
                else if (condStr == "CanAttack") 
                    node.conditionType = BTConditionType::CanAttack;
                else if (condStr == "HeardNoise") 
                    node.conditionType = BTConditionType::HeardNoise;
                // NEW: Wander behavior conditions
                else if (condStr == "IsWaitTimerExpired")
                    node.conditionType = BTConditionType::IsWaitTimerExpired;
                else if (condStr == "HasNavigableDestination")
                    node.conditionType = BTConditionType::HasNavigableDestination;
                else if (condStr == "HasValidPath")
                    node.conditionType = BTConditionType::HasValidPath;
                else if (condStr == "HasReachedDestination")
                    node.conditionType = BTConditionType::HasReachedDestination;
                // NEW: CheckBlackboardValue is handled via string type, not enum
                
                // Handle v2 format parameters (nested in "parameters" object)
                if (isV2 && nodeJson.contains("parameters") && nodeJson["parameters"].is_object())
                {
                    const json& params = nodeJson["parameters"];
                    node.conditionParam = JsonHelper::GetFloat(params, "param", 0.0f);
                    
                    // Parse flexible parameters for conditions like CheckBlackboardValue
                    for (auto it = params.begin(); it != params.end(); ++it)
                    {
                        if (it.value().is_string())
                            node.stringParams[it.key()] = it.value().get<std::string>();
                        else if (it.value().is_number_integer())
                            node.intParams[it.key()] = it.value().get<int>();
                        else if (it.value().is_number_float())
                            node.floatParams[it.key()] = it.value().get<float>();
                    }
                }
                else
                {
                    // v1 format (flat)
                    node.conditionParam = JsonHelper::GetFloat(nodeJson, "param", 0.0f);
                }
            }
            
            // Parse action type
            if (node.type == BTNodeType::Action && nodeJson.contains("actionType"))
            {
                std::string actStr = JsonHelper::GetString(nodeJson, "actionType", "");
                if (actStr == "SetMoveGoalToLastKnownTargetPos") 
                    node.actionType = BTActionType::SetMoveGoalToLastKnownTargetPos;
                else if (actStr == "SetMoveGoalToTarget") 
                    node.actionType = BTActionType::SetMoveGoalToTarget;
                else if (actStr == "SetMoveGoalToPatrolPoint") 
                    node.actionType = BTActionType::SetMoveGoalToPatrolPoint;
                else if (actStr == "MoveToGoal" || actStr == "MoveTo") 
                    node.actionType = BTActionType::MoveToGoal;
                else if (actStr == "AttackIfClose" || actStr == "AttackMelee") 
                    node.actionType = BTActionType::AttackIfClose;
                else if (actStr == "PatrolPickNextPoint") 
                    node.actionType = BTActionType::PatrolPickNextPoint;
                else if (actStr == "ClearTarget") 
                    node.actionType = BTActionType::ClearTarget;
                else if (actStr == "Idle") 
                    node.actionType = BTActionType::Idle;
                // NEW: Wander behavior actions
                else if (actStr == "WaitRandomTime")
                    node.actionType = BTActionType::WaitRandomTime;
                else if (actStr == "ChooseRandomNavigablePoint")
                    node.actionType = BTActionType::ChooseRandomNavigablePoint;
                else if (actStr == "RequestPathfinding")
                    node.actionType = BTActionType::RequestPathfinding;
                else if (actStr == "FollowPath")
                    node.actionType = BTActionType::FollowPath;
                
                // Handle v2 format parameters (nested in "parameters" object)
                if (isV2 && nodeJson.contains("parameters") && nodeJson["parameters"].is_object())
                {
                    const json& params = nodeJson["parameters"];
                    node.actionParam1 = JsonHelper::GetFloat(params, "param1", 0.0f);
                    node.actionParam2 = JsonHelper::GetFloat(params, "param2", 0.0f);
                }
                else
                {
                    // v1 format (flat)
                    node.actionParam1 = JsonHelper::GetFloat(nodeJson, "param1", 0.0f);
                    node.actionParam2 = JsonHelper::GetFloat(nodeJson, "param2", 0.0f);
                }
            }
            
            // Parse decorator child
            if (node.type == BTNodeType::Inverter || node.type == BTNodeType::Repeater)
            {
                node.decoratorChildId = JsonHelper::GetInt(nodeJson, "decoratorChildId", 0);
            }
            
            if (node.type == BTNodeType::Repeater)
            {
                node.repeatCount = JsonHelper::GetInt(nodeJson, "repeatCount", 0);
            }
            
            tree.nodes.push_back(node);
            
            std::cout << "[BehaviorTreeManager]   Node " << node.id << ": " << node.name 
                      << " (" << typeStr << ") children: " << node.childIds.size() << std::endl;
        });
        
        std::cout << "[BehaviorTreeManager] Parsed " << tree.nodes.size() << " nodes successfully" << std::endl;
        
        // 5. Validate tree structure
        std::cout << "[BehaviorTreeManager] Step 5: Validating tree structure..." << std::endl;
        std::string validationError;
        bool valid = ValidateTree(tree, validationError);
        if (!valid)
        {
            std::cerr << "[BehaviorTreeManager] WARNING: Tree validation failed: " << validationError << std::endl;
            // Don't fail loading - allow hot-reload to fix issues
        }
        else
        {
            std::cout << "[BehaviorTreeManager] Tree validation: OK" << std::endl;
        }
        
        // 6. Store the tree
        std::cout << "[BehaviorTreeManager] Step 6: Registering tree..." << std::endl;
        m_trees.push_back(tree);
        
        // Register the path -> ID mapping
        m_pathToIdMap[filepath] = treeId;
        
        std::cout << "[BehaviorTreeManager] SUCCESS: Loaded '" << tree.name << "' (ID=" << treeId << ") with " 
                  << tree.nodes.size() << " nodes" << std::endl;
        std::cout << "[BehaviorTreeManager] Registered path mapping: " << filepath << " -> ID " << treeId << "\n";
        std::cout << "[BehaviorTreeManager] ========================================+n" << std::endl;
        
        return true;
    }
    catch (const std::exception& e)
    {
        std::cerr << "\n[BehaviorTreeManager] !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
        std::cerr << "[BehaviorTreeManager] EXCEPTION: " << e.what() << std::endl;
        std::cerr << "[BehaviorTreeManager] !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" << std::endl;
        std::cout << "[BehaviorTreeManager] ========================================+n" << std::endl;
        return false;
    }
}
 
const BehaviorTreeAsset* BehaviorTreeManager::GetTree(uint32_t treeId) const
{
    for (const auto& tree : m_trees)
    {
        if (tree.id == treeId)
            return &tree;
    }
    return nullptr;
}
 
void BehaviorTreeManager::Clear()
{
    m_trees.clear();
    m_pathToIdMap.clear();
}
 
bool BehaviorTreeManager::ReloadTree(uint32_t treeId)
{
    // Find the tree
    for (auto& tree : m_trees)
    {
        if (tree.id == treeId)
        {
            // Get the original filepath (we need to store it)
            // For now, reconstruct it from tree name
            std::string filepath = "Blueprints/AI/" + tree.name + ".json";
            
            // Remove old tree
            m_trees.erase(std::remove_if(m_trees.begin(), m_trees.end(),
                [treeId](const BehaviorTreeAsset& t) { return t.id == treeId; }), 
                m_trees.end());
            
            // Load new version
            bool success = LoadTreeFromFile(filepath, treeId);
            if (success)
            {
                SYSTEM_LOG << "BehaviorTreeManager: Hot-reloaded tree ID=" << treeId << "\n";
            }
            return success;
        }
    }
    
    SYSTEM_LOG << "BehaviorTreeManager: Cannot reload tree ID=" << treeId << " (not found)\n";
    return false;
}
 
bool BehaviorTreeManager::ValidateTree(const BehaviorTreeAsset& tree, std::string& errorMessage) const
{
    errorMessage.clear();
    
    // Check if tree has nodes
    if (tree.nodes.empty())
    {
        errorMessage = "Tree has no nodes";
        return false;
    }
    
    // Check if root node exists
    const BTNode* root = tree.GetNode(tree.rootNodeId);
    if (!root)
    {
        errorMessage = "Root node ID " + std::to_string(tree.rootNodeId) + " not found";
        return false;
    }
    
    // Validate each node
    for (const auto& node : tree.nodes)
    {
        // Check composite nodes have children
        if (node.type == BTNodeType::Selector || node.type == BTNodeType::Sequence)
        {
            if (node.childIds.empty())
            {
                errorMessage = "Composite node '" + node.name + "' (ID=" + std::to_string(node.id) + ") has no children";
                return false;
            }
            
            // Validate all children exist
            for (uint32_t childId : node.childIds)
            {
                if (!tree.GetNode(childId))
                {
                    errorMessage = "Node '" + node.name + "' references missing child ID " + std::to_string(childId);
                    return false;
                }
            }
        }
        
        // Check decorator nodes have a child
        if (node.type == BTNodeType::Inverter || node.type == BTNodeType::Repeater)
        {
            if (!tree.GetNode(node.decoratorChildId))
            {
                errorMessage = "Decorator node '" + node.name + "' references missing child ID " + std::to_string(node.decoratorChildId);
                return false;
            }
        }
        
        // Check for duplicate node IDs
        int count = 0;
        for (const auto& other : tree.nodes)
        {
            if (other.id == node.id)
                count++;
        }
        if (count > 1)
        {
            errorMessage = "Duplicate node ID " + std::to_string(node.id);
            return false;
        }
    }
    
    return true;
}
 
// --- Behavior Tree Execution ---
 
BTStatus ExecuteBTNode(const BTNode& node, EntityID entity, AIBlackboard_data& blackboard, const BehaviorTreeAsset& tree)
{
    switch (node.type)
    {
        case BTNodeType::Selector:
        {
            // OR node: succeeds if any child succeeds
            for (uint32_t childId : node.childIds)
            {
                const BTNode* child = tree.GetNode(childId);
                if (!child) continue;
                
                BTStatus status = ExecuteBTNode(*child, entity, blackboard, tree);
                if (status == BTStatus::Success)
                    return BTStatus::Success;
                if (status == BTStatus::Running)
                    return BTStatus::Running;
            }
            return BTStatus::Failure;
        }
        
        case BTNodeType::Sequence:
        {
            // AND node: succeeds if all children succeed
            for (uint32_t childId : node.childIds)
            {
                const BTNode* child = tree.GetNode(childId);
                if (!child) continue;
                
                BTStatus status = ExecuteBTNode(*child, entity, blackboard, tree);
                if (status == BTStatus::Failure)
                    return BTStatus::Failure;
                if (status == BTStatus::Running)
                    return BTStatus::Running;
            }
            return BTStatus::Success;
        }
        
        case BTNodeType::Condition:
        {
            // Check if this is a string-based condition (like CheckBlackboardValue)
            if (!node.conditionTypeString.empty() && node.conditionTypeString == "CheckBlackboardValue")
            {
                // Execute CheckBlackboardValue condition
                std::string key = node.GetParameterString("key");
                std::string op = node.GetParameterString("operator");
                int expectedValue = node.GetParameterInt("value");
                
                int actualValue = 0;
                
                // Get value from blackboard
                if (key == "AIMode")
                {
                    actualValue = blackboard.AIMode;
                }
                else
                {
                    // Future: support other blackboard integer fields
                    return BTStatus::Failure;  // Key not found
                }
                
                // Perform comparison
                if (op == "Equals" || op == "equals" || op == "==")
                    return (actualValue == expectedValue) ? BTStatus::Success : BTStatus::Failure;
                else if (op == "NotEquals" || op == "notequals" || op == "!=")
                    return (actualValue != expectedValue) ? BTStatus::Success : BTStatus::Failure;
                else if (op == "GreaterThan" || op == "greaterthan" || op == ">")
                    return (actualValue > expectedValue) ? BTStatus::Success : BTStatus::Failure;
                else if (op == "LessThan" || op == "lessthan" || op == "<")
                    return (actualValue < expectedValue) ? BTStatus::Success : BTStatus::Failure;
                else if (op == "GreaterOrEqual" || op == "greaterorequal" || op == ">=")
                    return (actualValue >= expectedValue) ? BTStatus::Success : BTStatus::Failure;
                else if (op == "LessOrEqual" || op == "lessorequal" || op == "<=")
                    return (actualValue <= expectedValue) ? BTStatus::Success : BTStatus::Failure;
                
                return BTStatus::Failure;
            }
            else
            {
                // Execute enum-based condition (legacy)
                return ExecuteBTCondition(node.conditionType, node.conditionParam, entity, blackboard);
            }
        }
        
        case BTNodeType::Action:
        {
            return ExecuteBTAction(node.actionType, node.actionParam1, node.actionParam2, entity, blackboard);
        }
        
        case BTNodeType::Inverter:
        {
            const BTNode* child = tree.GetNode(node.decoratorChildId);
            if (!child) return BTStatus::Failure;
            
            BTStatus status = ExecuteBTNode(*child, entity, blackboard, tree);
            if (status == BTStatus::Success)
                return BTStatus::Failure;
            if (status == BTStatus::Failure)
                return BTStatus::Success;
            return status;
        }
        
        case BTNodeType::Repeater:
        {
            // Simplified repeater: just execute once per tick
            const BTNode* child = tree.GetNode(node.decoratorChildId);
            if (!child) return BTStatus::Failure;
            
            return ExecuteBTNode(*child, entity, blackboard, tree);
        }
    }
    
    return BTStatus::Failure;
}
 
BTStatus ExecuteBTCondition(BTConditionType condType, float param, EntityID entity, const AIBlackboard_data& blackboard)
{
    switch (condType)
    {
        case BTConditionType::TargetVisible:
            return blackboard.targetVisible ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::TargetInRange:
            if (!blackboard.hasTarget) return BTStatus::Failure;
            return (blackboard.distanceToTarget <= param) ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::HealthBelow:
            if (World::Get().HasComponent<Health_data>(entity))
            {
                const Health_data& health = World::Get().GetComponent<Health_data>(entity);
                float healthPercent = static_cast<float>(health.currentHealth) / static_cast<float>(health.maxHealth);
                return (healthPercent < param) ? BTStatus::Success : BTStatus::Failure;
            }
            return BTStatus::Failure;
        
        case BTConditionType::HasMoveGoal:
            return blackboard.hasMoveGoal ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::CanAttack:
            return blackboard.canAttack ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::HeardNoise:
            return blackboard.heardNoise ? BTStatus::Success : BTStatus::Failure;
        
        // NEW: Wander behavior conditions
        case BTConditionType::IsWaitTimerExpired:
            return (blackboard.wanderWaitTimer >= blackboard.wanderTargetWaitTime) ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::HasNavigableDestination:
            return blackboard.hasWanderDestination ? BTStatus::Success : BTStatus::Failure;
        
        case BTConditionType::HasValidPath:
            // Check if NavigationAgent has a valid path
            if (World::Get().HasComponent<NavigationAgent_data>(entity))
            {
                const NavigationAgent_data& navAgent = World::Get().GetComponent<NavigationAgent_data>(entity);
                return (!navAgent.currentPath.empty()) ? BTStatus::Success : BTStatus::Failure;
            }
            return BTStatus::Failure;
        
        case BTConditionType::HasReachedDestination:
            if (!blackboard.hasWanderDestination) return BTStatus::Failure;
            
            if (World::Get().HasComponent<Position_data>(entity))
            {
                const Position_data& pos = World::Get().GetComponent<Position_data>(entity);
                Vector vDest = pos.position;
                vDest -= blackboard.wanderDestination;
                float dist = vDest.Magnitude();
                
                // Use arrival threshold from MoveIntent if available, otherwise use default
                float threshold = 5.0f;
                if (World::Get().HasComponent<MoveIntent_data>(entity))
                {
                    const MoveIntent_data& intent = World::Get().GetComponent<MoveIntent_data>(entity);
                    threshold = intent.arrivalThreshold;
                }
                
                return (dist < threshold) ? BTStatus::Success : BTStatus::Failure;
            }
            return BTStatus::Failure;
    }
    
    return BTStatus::Failure;
}
 
BTStatus ExecuteBTAction(BTActionType actionType, float param1, float param2, EntityID entity, AIBlackboard_data& blackboard)
{
    switch (actionType)
    {
        case BTActionType::SetMoveGoalToLastKnownTargetPos:
            blackboard.moveGoal = blackboard.lastKnownTargetPosition;
            blackboard.hasMoveGoal = true;
            return BTStatus::Success;
        
        case BTActionType::SetMoveGoalToTarget:
            if (blackboard.hasTarget && blackboard.targetEntity != INVALID_ENTITY_ID)
            {
                if (World::Get().HasComponent<Position_data>(blackboard.targetEntity))
                {
                    const Position_data& targetPos = World::Get().GetComponent<Position_data>(blackboard.targetEntity);
                    blackboard.moveGoal = targetPos.position;
                    blackboard.hasMoveGoal = true;
                    return BTStatus::Success;
                }
            }
            return BTStatus::Failure;
        
        case BTActionType::SetMoveGoalToPatrolPoint:
            if (blackboard.patrolPointCount > 0)
            {
                int index = static_cast<int>(param1);
                if (index < 0 || index >= blackboard.patrolPointCount)
                    index = blackboard.currentPatrolPoint;
                
                blackboard.moveGoal = blackboard.patrolPoints[index];
                blackboard.hasMoveGoal = true;
                return BTStatus::Success;
            }
            return BTStatus::Failure;
        
        case BTActionType::MoveToGoal:
            if (!blackboard.hasMoveGoal) return BTStatus::Failure;
            
            // Set MoveIntent if component exists
            if (World::Get().HasComponent<MoveIntent_data>(entity))
            {
                MoveIntent_data& intent = World::Get().GetComponent<MoveIntent_data>(entity);
                intent.targetPosition = blackboard.moveGoal;
                intent.desiredSpeed = (param1 > 0.0f) ? param1 : 1.0f;
                intent.hasIntent = true;
                
                // Check if we've arrived
                if (World::Get().HasComponent<Position_data>(entity))
                {
                    Position_data& pos = World::Get().GetComponent<Position_data>(entity);
                    float dist = (pos.position - blackboard.moveGoal).Magnitude();
                    if (dist < intent.arrivalThreshold)
                    {
                        blackboard.hasMoveGoal = false;
                        intent.hasIntent = false;
                        return BTStatus::Success;
                    }
                }
                
                return BTStatus::Running;
            }
            return BTStatus::Failure;
        
        case BTActionType::AttackIfClose:
        {
            float range = (param1 > 0.0f) ? param1 : 50.0f;
            if (blackboard.hasTarget && blackboard.distanceToTarget <= range && blackboard.canAttack)
            {
                // Set AttackIntent if component exists
                if (World::Get().HasComponent<AttackIntent_data>(entity))
                {
                    AttackIntent_data& intent = World::Get().GetComponent<AttackIntent_data>(entity);
                    intent.targetEntity = blackboard.targetEntity;
                    intent.targetPosition = blackboard.lastKnownTargetPosition;
                    intent.range = range;
                    intent.damage = (param2 > 0.0f) ? param2 : 10.0f;
                    intent.hasIntent = true;
                    
                    blackboard.canAttack = false;
                    return BTStatus::Success;
                }
            }
            return BTStatus::Failure;
        }
        
        case BTActionType::PatrolPickNextPoint:
            if (blackboard.patrolPointCount > 0)
            {
                blackboard.currentPatrolPoint = (blackboard.currentPatrolPoint + 1) % blackboard.patrolPointCount;
                blackboard.moveGoal = blackboard.patrolPoints[blackboard.currentPatrolPoint];
                blackboard.hasMoveGoal = true;
                return BTStatus::Success;
            }
            return BTStatus::Failure;
        
        case BTActionType::ClearTarget:
            blackboard.hasTarget = false;
            blackboard.targetEntity = INVALID_ENTITY_ID;
            blackboard.targetVisible = false;
            return BTStatus::Success;
        
        case BTActionType::Idle:
            // Do nothing
            return BTStatus::Success;
        
        // NEW: Wander behavior actions
        case BTActionType::WaitRandomTime:
        {
            // If timer not initialized, create a random time
            if (blackboard.wanderTargetWaitTime == 0.0f)
            {
                float minWait = (param1 > 0.0f) ? param1 : 2.0f;
                float maxWait = (param2 > 0.0f) ? param2 : 6.0f;
                
                // Random generation between min and max
                float randomFactor = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
                blackboard.wanderTargetWaitTime = minWait + randomFactor * (maxWait - minWait);
                blackboard.wanderWaitTimer = 0.0f;
            }
            
            // Increment timer with engine deltaTime
            blackboard.wanderWaitTimer += GameEngine::fDt;
            
            // Check if timer expired
            if (blackboard.wanderWaitTimer >= blackboard.wanderTargetWaitTime)
            {
                // Reset for next cycle
                blackboard.wanderTargetWaitTime = 0.0f;
                blackboard.wanderWaitTimer = 0.0f;
                return BTStatus::Success;
            }
            
            return BTStatus::Running;
        }
        
        case BTActionType::ChooseRandomNavigablePoint:
        {
            // Get current position
            if (!World::Get().HasComponent<Position_data>(entity))
                return BTStatus::Failure;
            
            const Position_data& pos = World::Get().GetComponent<Position_data>(entity);
            
            // Parameters
            float searchRadius = (param1 > 0.0f) ? param1 : blackboard.wanderSearchRadius;
            int maxAttempts = (param2 > 0.0f) ? static_cast<int>(param2) : blackboard.wanderMaxSearchAttempts;
            
            // Search for a random navigable point
            float destX, destY;
            bool found = NavigationMap::Get().GetRandomNavigablePoint(
                pos.position.x, pos.position.y, searchRadius, maxAttempts, destX, destY
            );
            
            if (found)
            {
                blackboard.wanderDestination = Vector(destX, destY);
                blackboard.hasWanderDestination = true;
                blackboard.moveGoal = blackboard.wanderDestination;
                blackboard.hasMoveGoal = true;
                return BTStatus::Success;
            }
            
            return BTStatus::Failure;
        }
        
        case BTActionType::RequestPathfinding:
        {
            if (!blackboard.hasMoveGoal) return BTStatus::Failure;
            
            // Go through MoveIntent_data with pathfinding enabled
            if (World::Get().HasComponent<MoveIntent_data>(entity))
            {
                MoveIntent_data& intent = World::Get().GetComponent<MoveIntent_data>(entity);
                intent.targetPosition = blackboard.moveGoal;
                intent.desiredSpeed = 1.0f;
                intent.hasIntent = true;
                intent.usePathfinding = true;  // Enable pathfinding
                intent.avoidObstacles = true;
                
                return BTStatus::Success;
            }
            
            return BTStatus::Failure;
        }
        
        case BTActionType::FollowPath:
        {
            if (!blackboard.hasWanderDestination) return BTStatus::Failure;
            
            // Check if we have an active MoveIntent
            if (World::Get().HasComponent<MoveIntent_data>(entity))
            {
                MoveIntent_data& intent = World::Get().GetComponent<MoveIntent_data>(entity);
                
                // Maintain the active intent
                if (!intent.hasIntent)
                {
                    intent.targetPosition = blackboard.wanderDestination;
                    intent.desiredSpeed = 1.0f;
                    intent.hasIntent = true;
                    intent.usePathfinding = true;
                }
                
                // Check if we have arrived
                if (World::Get().HasComponent<Position_data>(entity))
                {
                    const Position_data& pos = World::Get().GetComponent<Position_data>(entity);
                    Vector vDest = pos.position;
                    vDest -= blackboard.wanderDestination;
                    float dist = vDest.Magnitude();
                    
                    if (dist < intent.arrivalThreshold)
                    {
                        // Arrived at destination
                        blackboard.hasWanderDestination = false;
                        blackboard.hasMoveGoal = false;
                        intent.hasIntent = false;
                        return BTStatus::Success;
                    }
                }
                
                return BTStatus::Running;
            }
            
            return BTStatus::Failure;
        }
    }
    
    return BTStatus::Failure;
}
 
// --- Path-to-ID Registry Methods ---
 
uint32_t BehaviorTreeManager::GetTreeIdFromPath(const std::string& treePath) const
{
    auto it = m_pathToIdMap.find(treePath);
    if (it != m_pathToIdMap.end())
        return it->second;
    
    // Fallback: generate ID from path if not in registry
    // This allows forward compatibility with paths that aren't loaded yet
    return BehaviorTreeDependencyScanner::GenerateTreeIdFromPath(treePath);
}
 
bool BehaviorTreeManager::IsTreeLoadedByPath(const std::string& treePath) const
{
    return m_pathToIdMap.find(treePath) != m_pathToIdMap.end();
}
 
const BehaviorTreeAsset* BehaviorTreeManager::GetTreeByPath(const std::string& treePath) const
{
    uint32_t treeId = GetTreeIdFromPath(treePath);
    return GetTree(treeId);
}
 
const BehaviorTreeAsset* BehaviorTreeManager::GetTreeByAnyId(uint32_t treeId) const
{
    // Strategy 1: Direct ID lookup
    for (const auto& tree : m_trees)
    {
        if (tree.id == treeId)
            return &tree;
    }
    
    // No additional strategies currently implemented
    // Future enhancement: Could add tree structure matching for corrupted prefabs
    
    return nullptr;
}
 
std::string BehaviorTreeManager::GetTreePathFromId(uint32_t treeId) const
{
    // Check path-to-ID registry
    for (const auto& entry : m_pathToIdMap)
    {
        if (entry.second == treeId)
            return entry.first;
    }
    
    // Check if a tree with this ID exists (might be loaded with different path)
    for (const auto& tree : m_trees)
    {
        if (tree.id == treeId)
            return "TreeName:" + tree.name; // Prefix to distinguish from actual file path
    }
    
    return "";
}
 
void BehaviorTreeManager::DebugPrintLoadedTrees() const
{
    std::cout << "[BehaviorTreeManager] Loaded trees (" << m_trees.size() << "):" << std::endl;
    for (const auto& tree : m_trees)
    {
        std::cout << "  - ID=" << tree.id << " Name='" << tree.name << "' Nodes=" << tree.nodes.size() << std::endl;
    }
    
    std::cout << "[BehaviorTreeManager] Path-to-ID registry (" << m_pathToIdMap.size() << "):" << std::endl;
    for (const auto& entry : m_pathToIdMap)
    {
        std::cout << "  - '" << entry.first << "' -> ID=" << entry.second << std::endl;
    }
}
 
// =============================================================================
// BehaviorTreeAsset - Validation Methods
// =============================================================================
 
std::vector<BTValidationMessage> BehaviorTreeAsset::ValidateTreeFull() const
{
    std::vector<BTValidationMessage> messages;
    
    // Rule 1: Exactly one root node
    int rootCount = 0;
    const BTNode* rootNode = nullptr;
    for (const auto& node : nodes)
    {
        if (node.id == rootNodeId)
        {
            rootNode = &node;
            rootCount++;
        }
    }
    
    if (rootCount == 0)
    {
        BTValidationMessage msg;
        msg.severity = BTValidationMessage::Severity::Error;
        msg.nodeId = 0;
        msg.message = "No root node found (rootNodeId=" + std::to_string(rootNodeId) + ")";
        messages.push_back(msg);
        return messages; // Cannot continue without root
    }
    else if (rootCount > 1)
    {
        BTValidationMessage msg;
        msg.severity = BTValidationMessage::Severity::Error;
        msg.nodeId = 0;
        msg.message = "Multiple nodes with root ID found";
        messages.push_back(msg);
    }
    
    // Build parent count map
    std::map<uint32_t, int> parentCounts;
    for (const auto& node : nodes)
    {
        parentCounts[node.id] = 0;
    }
    
    // Count parents for each node
    for (const auto& node : nodes)
    {
        // Check childIds for composites
        if (node.type == BTNodeType::Selector || node.type == BTNodeType::Sequence)
        {
            for (uint32_t childId : node.childIds)
            {
                if (parentCounts.find(childId) != parentCounts.end())
                {
                    parentCounts[childId]++;
                }
                else
                {
                    BTValidationMessage msg;
                    msg.severity = BTValidationMessage::Severity::Error;
                    msg.nodeId = node.id;
                    msg.message = "Node references non-existent child ID " + std::to_string(childId);
                    messages.push_back(msg);
                }
            }
        }
        
        // Check decoratorChildId for decorators
        if (node.type == BTNodeType::Inverter || node.type == BTNodeType::Repeater)
        {
            if (node.decoratorChildId != 0)
            {
                if (parentCounts.find(node.decoratorChildId) != parentCounts.end())
                {
                    parentCounts[node.decoratorChildId]++;
                }
                else
                {
                    BTValidationMessage msg;
                    msg.severity = BTValidationMessage::Severity::Error;
                    msg.nodeId = node.id;
                    msg.message = "Decorator references non-existent child ID " + std::to_string(node.decoratorChildId);
                    messages.push_back(msg);
                }
            }
        }
    }
    
    // Rule 2: No node should have multiple parents
    for (const auto& entry : parentCounts)
    {
        if (entry.second > 1)
        {
            BTValidationMessage msg;
            msg.severity = BTValidationMessage::Severity::Error;
            msg.nodeId = entry.first;
            msg.message = "Node has multiple parents (count=" + std::to_string(entry.second) + ")";
            messages.push_back(msg);
        }
    }
    
    // Rule 3: Root should have no parent
    if (rootNode && parentCounts[rootNode->id] > 0)
    {
        BTValidationMessage msg;
        msg.severity = BTValidationMessage::Severity::Error;
        msg.nodeId = rootNode->id;
        msg.message = "Root node has parent(s)";
        messages.push_back(msg);
    }
    
    // Rule 4: No orphan nodes (except root)
    for (const auto& entry : parentCounts)
    {
        if (entry.second == 0 && entry.first != rootNodeId)
        {
            BTValidationMessage msg;
            msg.severity = BTValidationMessage::Severity::Warning;
            msg.nodeId = entry.first;
            msg.message = "Orphan node (no parent, not root)";
            messages.push_back(msg);
        }
    }
    
    // Rule 5: Validate node type-specific constraints
    for (const auto& node : nodes)
    {
        if (node.type == BTNodeType::Inverter || node.type == BTNodeType::Repeater)
        {
            // Decorators must have exactly 1 child
            if (node.decoratorChildId == 0)
            {
                BTValidationMessage msg;
                msg.severity = BTValidationMessage::Severity::Error;
                msg.nodeId = node.id;
                msg.message = "Decorator has no child (decoratorChildId=0)";
                messages.push_back(msg);
            }
        }
        else if (node.type == BTNodeType::Selector || node.type == BTNodeType::Sequence)
        {
            // Composites should have at least 1 child (warning if 0)
            if (node.childIds.empty())
            {
                BTValidationMessage msg;
                msg.severity = BTValidationMessage::Severity::Warning;
                msg.nodeId = node.id;
                msg.message = "Composite has no children";
                messages.push_back(msg);
            }
        }
    }
    
    // Rule 6: Detect cycles
    for (const auto& node : nodes)
    {
        if (DetectCycle(node.id))
        {
            BTValidationMessage msg;
            msg.severity = BTValidationMessage::Severity::Error;
            msg.nodeId = node.id;
            msg.message = "Cycle detected starting from this node";
            messages.push_back(msg);
        }
    }
    
    return messages;
}
 
bool BehaviorTreeAsset::DetectCycle(uint32_t startNodeId) const
{
    std::set<uint32_t> visited;
    std::set<uint32_t> recursionStack;
    
    // DFS helper function
    std::function<bool(uint32_t)> dfs = [&](uint32_t nodeId) -> bool
    {
        if (recursionStack.find(nodeId) != recursionStack.end())
        {
            return true; // Cycle detected
        }
        
        if (visited.find(nodeId) != visited.end())
        {
            return false; // Already checked this node
        }
        
        visited.insert(nodeId);
        recursionStack.insert(nodeId);
        
        const BTNode* node = GetNode(nodeId);
        if (!node)
        {
            recursionStack.erase(nodeId);
            return false;
        }
        
        // Check children in childIds (composites)
        for (uint32_t childId : node->childIds)
        {
            if (dfs(childId))
            {
                return true;
            }
        }
        
        // Check decoratorChildId (decorators)
        if ((node->type == BTNodeType::Inverter || node->type == BTNodeType::Repeater) &&
            node->decoratorChildId != 0)
        {
            if (dfs(node->decoratorChildId))
            {
                return true;
            }
        }
        
        recursionStack.erase(nodeId);
        return false;
    };
    
    return dfs(startNodeId);
}
 
// =============================================================================
// BehaviorTreeAsset - Editor CRUD Operations
// =============================================================================
 
uint32_t BehaviorTreeAsset::GenerateNextNodeId() const
{
    uint32_t maxId = 0;
    for (const auto& node : nodes)
    {
        if (node.id > maxId)
        {
            maxId = node.id;
        }
    }
    return maxId + 1;
}
 
uint32_t BehaviorTreeAsset::AddNode(BTNodeType type, const std::string& name, const Vector& position)
{
    BTNode newNode;
    newNode.type = type;
    newNode.id = GenerateNextNodeId();
    newNode.name = name;
    
    // Set default parameters based on type
    if (type == BTNodeType::Action)
    {
        newNode.actionType = BTActionType::Idle;
        newNode.actionParam1 = 0.0f;
        newNode.actionParam2 = 0.0f;
    }
    else if (type == BTNodeType::Condition)
    {
        newNode.conditionType = BTConditionType::TargetVisible;
        newNode.conditionParam = 0.0f;
    }
    else if (type == BTNodeType::Repeater)
    {
        newNode.repeatCount = 1;
        newNode.decoratorChildId = 0;
    }
    else if (type == BTNodeType::Inverter)
    {
        newNode.decoratorChildId = 0;
    }
    
    nodes.push_back(newNode);
    
    std::cout << "[BehaviorTreeAsset] Added node ID=" << newNode.id
              << " type=" << static_cast<int>(type) << " name='" << name << "'" << std::endl;
    
    return newNode.id;
}
 
bool BehaviorTreeAsset::RemoveNode(uint32_t nodeId)
{
    // Find and remove the node
    auto it = nodes.begin();
    while (it != nodes.end())
    {
        if (it->id == nodeId)
        {
            nodes.erase(it);
            break;
        }
        ++it;
    }
    
    // Clean up connections to/from this node
    for (auto& node : nodes)
    {
        // Remove from childIds
        auto childIt = node.childIds.begin();
        while (childIt != node.childIds.end())
        {
            if (*childIt == nodeId)
            {
                childIt = node.childIds.erase(childIt);
            }
            else
            {
                ++childIt;
            }
        }
        
        // Remove from decoratorChildId
        if (node.decoratorChildId == nodeId)
        {
            node.decoratorChildId = 0;
        }
    }
    
    std::cout << "[BehaviorTreeAsset] Removed node ID=" << nodeId << std::endl;
    return true;
}
 
bool BehaviorTreeAsset::ConnectNodes(uint32_t parentId, uint32_t childId)
{
    BTNode* parent = GetNode(parentId);
    const BTNode* child = GetNode(childId);
    
    if (!parent || !child)
    {
        std::cerr << "[BehaviorTreeAsset] ConnectNodes failed: invalid node IDs" << std::endl;
        return false;
    }
    
    // Add connection based on parent type
    if (parent->type == BTNodeType::Selector || parent->type == BTNodeType::Sequence)
    {
        // Check if already connected
        for (uint32_t id : parent->childIds)
        {
            if (id == childId)
            {
                std::cerr << "[BehaviorTreeAsset] Connection already exists" << std::endl;
                return false;
            }
        }
        
        parent->childIds.push_back(childId);
        std::cout << "[BehaviorTreeAsset] Connected composite node " << parentId << " -> " << childId << std::endl;
        return true;
    }
    else if (parent->type == BTNodeType::Inverter || parent->type == BTNodeType::Repeater)
    {
        if (parent->decoratorChildId != 0)
        {
            std::cerr << "[BehaviorTreeAsset] Decorator already has a child" << std::endl;
            return false;
        }
        
        parent->decoratorChildId = childId;
        std::cout << "[BehaviorTreeAsset] Connected decorator node " << parentId << " -> " << childId << std::endl;
        return true;
    }
    else
    {
        std::cerr << "[BehaviorTreeAsset] Cannot connect from leaf node" << std::endl;
        return false;
    }
}
 
bool BehaviorTreeAsset::DisconnectNodes(uint32_t parentId, uint32_t childId)
{
    BTNode* parent = GetNode(parentId);
    
    if (!parent)
    {
        return false;
    }
    
    // Remove from childIds
    auto it = parent->childIds.begin();
    while (it != parent->childIds.end())
    {
        if (*it == childId)
        {
            parent->childIds.erase(it);
            std::cout << "[BehaviorTreeAsset] Disconnected " << parentId << " -X-> " << childId << std::endl;
            return true;
        }
        ++it;
    }
    
    // Remove from decoratorChildId
    if (parent->decoratorChildId == childId)
    {
        parent->decoratorChildId = 0;
        std::cout << "[BehaviorTreeAsset] Disconnected decorator " << parentId << " -X-> " << childId << std::endl;
        return true;
    }
    
    return false;
}