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 "../system/EventQueue.h"
#include "../json_helper.h"
#include "../CollisionMap.h"
#include "../GameEngine.h"
#include <cmath>
#include <functional>
#include <set>
#include <fstream>
 
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", "");
 
            // Phase 38: Load editor positions for execution order sorting
            if (nodeJson.contains("position") && nodeJson["position"].is_object())
            {
                node.editorPosX = JsonHelper::GetFloat(nodeJson["position"], "x", 0.0f);
                node.editorPosY = JsonHelper::GetFloat(nodeJson["position"], "y", 0.0f);
            }
            else
            {
                node.editorPosX = 0.0f;
                node.editorPosY = 0.0f;
            }
 
            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;
            else if (typeStr == "Root") node.type = BTNodeType::Root;
            else if (typeStr == "OnEvent") node.type = BTNodeType::OnEvent;
            else if (typeStr == "SubGraph") node.type = BTNodeType::SubGraph;
            
            // 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);
                }
            }
 
            // Phase 39: Parse SubGraph node
            if (node.type == BTNodeType::SubGraph || typeStr == "SubGraph")
            {
                node.type = BTNodeType::SubGraph;
                node.subgraphPath = JsonHelper::GetString(nodeJson, "subgraphPath", "");
 
                // Parse input bindings (childVar -> parentVar)
                if (nodeJson.contains("subgraphInputs") && nodeJson["subgraphInputs"].is_object())
                {
                    const json& inputs = nodeJson["subgraphInputs"];
                    for (auto it = inputs.begin(); it != inputs.end(); ++it)
                    {
                        node.subgraphInputs[it.key()] = it.value().get<std::string>();
                    }
                }
 
                // Parse output bindings (childVar -> parentVar)
                if (nodeJson.contains("subgraphOutputs") && nodeJson["subgraphOutputs"].is_object())
                {
                    const json& outputs = nodeJson["subgraphOutputs"];
                    for (auto it = outputs.begin(); it != outputs.end(); ++it)
                    {
                        node.subgraphOutputs[it.key()] = it.value().get<std::string>();
                    }
                }
 
                std::cout << "[BehaviorTreeManager]   SubGraph loaded: " << node.subgraphPath 
                          << " with " << node.subgraphInputs.size() << " inputs, "
                          << node.subgraphOutputs.size() << " outputs" << std::endl;
            }
 
            // 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;
        }
 
        // Phase 38b: Step 6: Ensure Root node exists (auto-create if missing)
        std::cout << "[BehaviorTreeManager] Step 6: Ensuring Root node exists..." << std::endl;
        tree.EnsureRootNodeExists();
 
        // 7. Store the tree
        std::cout << "[BehaviorTreeManager] Step 7: 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;
                }
 
                        case BTActionType::SendMessage:
                        {
                            // Phase 38b: Emit event to EventQueue for OnEvent node processing
                            // param1 encoded as EventType enum value
 
                            EventType eventType = static_cast<EventType>(static_cast<int>(param1));
 
                            Message msg;
                            msg.msg_type = eventType;
                            msg.domain = EventDomain::Gameplay;
                            msg.targetUid = entity;
                            msg.param1 = 0;
                            msg.param2 = 0;
                            msg.state = 0;
 
                            EventQueue::Get().Push(msg);
 
                            return BTStatus::Success;
                        }
                    }
 
                    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;
}
 
// =============================================================================
// BehaviorTreeAsset - Phase 38b: Root Node Auto-Creation
// =============================================================================
 
void BehaviorTreeAsset::EnsureRootNodeExists()
{
    // Check if Root node already exists
    if (rootNodeId != 0)
    {
        const BTNode* rootNode = GetNode(rootNodeId);
        if (rootNode != nullptr)
        {
            return; // Root node exists and is valid
        }
 
        // Root ID is set but node doesn't exist - invalid, will recreate
        std::cerr << "[BehaviorTreeAsset::EnsureRootNodeExists] "
                  << "Root node ID " << rootNodeId << " not found in nodes list, creating new Root" << std::endl;
    }
 
    // Create default Root node if missing
    std::cout << "[BehaviorTreeAsset::EnsureRootNodeExists] Creating default Root node" << std::endl;
 
    BTNode rootNode;
    rootNode.id = GenerateNextNodeId();
    rootNode.type = BTNodeType::Selector;  // Default to Selector as root composite
    rootNode.name = "Root";
    rootNode.editorPosX = 0.0f;
    rootNode.editorPosY = 0.0f;
 
    nodes.push_back(rootNode);
    rootNodeId = rootNode.id;
 
    std::cout << "[BehaviorTreeAsset::EnsureRootNodeExists] "
              << "Created Root node with ID=" << rootNode.id << ", total nodes=" << nodes.size() << std::endl;
}
 
// =============================================================================
// BehaviorTreeAsset - Validation Methods (continued)
// =============================================================================
 
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;
    newNode.editorPosX = position.x;
    newNode.editorPosY = position.y;
 
    // 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 << "'"
              << " pos=(" << position.x << "," << position.y << ")" << 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;
}
 
// ============================================================================
// Phase 39c Step 6: SubGraph Validation Methods
// ============================================================================
 
bool BehaviorTreeManager::ValidateSubGraphPath(const std::string& path) const
{
    // 1. Check if path is empty
    if (path.empty())
    {
        SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: Path is empty\n";
        return false;
    }
 
    // 2. Check if file exists and is readable
    std::ifstream fileTest(path.c_str());
    if (!fileTest.good())
    {
        SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: File not found or not readable: " << path << "\n";
        return false;
    }
    fileTest.close();
 
    // 3. Check if it's a .bt.json file
    std::string filename = path;
    size_t lastSlash = filename.find_last_of("/\\");
    if (lastSlash != std::string::npos)
    {
        filename = filename.substr(lastSlash + 1);
    }
 
    if (filename.length() < 8 || filename.substr(filename.length() - 7) != ".bt.json")
    {
        SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: Not a .bt.json file: " << path << "\n";
        return false;
    }
 
    // 4. Try to parse JSON to verify it's valid
    try
    {
        json j;
        if (!JsonHelper::LoadJsonFromFile(path, j))
        {
            SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: Failed to load JSON: " << path << "\n";
            return false;
        }
    }
    catch (const std::exception& e)
    {
        SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: JSON parse error: " << e.what() << "\n";
        return false;
    }
 
    SYSTEM_LOG << "[BehaviorTreeManager] ValidateSubGraphPath: Valid - " << path << "\n";
    return true;
}
 
bool BehaviorTreeManager::DetectCircularDependencies(uint32_t graphId, uint32_t nodeId, const BehaviorTreeAsset* parentTree, std::set<std::string>& visited)
{
    if (!parentTree)
    {
        return false;
    }
 
    const BTNode* node = parentTree->GetNode(nodeId);
    if (!node || node->type != BTNodeType::SubGraph)
    {
        return false;
    }
 
    // 1. Check if we've already visited this path (cycle detected)
    if (visited.find(node->subgraphPath) != visited.end())
    {
        SYSTEM_LOG << "[BehaviorTreeManager] Circular dependency detected: " << node->subgraphPath << "\n";
        return true;
    }
 
    // 2. Check if path is valid first
    if (!ValidateSubGraphPath(node->subgraphPath))
    {
        SYSTEM_LOG << "[BehaviorTreeManager] SubGraph path invalid for circular check: " << node->subgraphPath << "\n";
        return false;  // Invalid path is not a circular dependency, just a broken reference
    }
 
    // 3. Add this path to visited set
    visited.insert(node->subgraphPath);
 
    // 4. Try to load the SubGraph
    uint32_t subgraphId = std::hash<std::string>{}(node->subgraphPath) & 0x7FFFFFFF;
 
    // Load if not already loaded
    if (!IsTreeLoadedByPath(node->subgraphPath))
    {
        if (!const_cast<BehaviorTreeManager*>(this)->LoadTreeFromFile(node->subgraphPath, subgraphId))
        {
            SYSTEM_LOG << "[BehaviorTreeManager] Failed to load SubGraph for circular check: " << node->subgraphPath << "\n";
            return false;
        }
    }
 
    const BehaviorTreeAsset* subgraph = GetTreeByAnyId(subgraphId);
    if (!subgraph)
    {
        return false;
    }
 
    // 5. Recursively check all SubGraph nodes in the loaded tree
    for (const BTNode& subNode : subgraph->nodes)
    {
        if (subNode.type == BTNodeType::SubGraph)
        {
            if (DetectCircularDependencies(subgraphId, subNode.id, subgraph, visited))
            {
                return true;  // Cycle found deeper in the graph
            }
        }
    }
 
    // 6. Backtrack: remove from visited set for other branches
    visited.erase(node->subgraphPath);
 
    return false;  // No cycle in this path
}
 
std::vector<std::string> BehaviorTreeManager::GetValidationErrors(uint32_t graphId)
{
    std::vector<std::string> errors;
 
    const BehaviorTreeAsset* tree = GetTree(graphId);
    if (!tree)
    {
        errors.push_back("Graph not found with ID: " + std::to_string(graphId));
        return errors;
    }
 
    // 1. Check each SubGraph node
    std::set<std::string> visited;
 
    for (const BTNode& node : tree->nodes)
    {
        if (node.type == BTNodeType::SubGraph)
        {
            // Check 1: Empty path
            if (node.subgraphPath.empty())
            {
                errors.push_back("SubGraph node '" + node.name + "' (ID:" + std::to_string(node.id) + ") has no path specified");
                continue;
            }
 
            // Check 2: Path validity
            if (!ValidateSubGraphPath(node.subgraphPath))
            {
                errors.push_back("SubGraph node '" + node.name + "' (ID:" + std::to_string(node.id) + ") path invalid: " + node.subgraphPath);
                continue;
            }
 
            // Check 3: Circular dependency
            std::set<std::string> circularVisited;
            if (DetectCircularDependencies(graphId, node.id, tree, circularVisited))
            {
                errors.push_back("SubGraph node '" + node.name + "' (ID:" + std::to_string(node.id) + ") creates circular reference: " + node.subgraphPath);
            }
        }
    }
 
    return errors;
}
 
// ============================================================================
// Phase 38b: OnEvent Root Node Activation via EventQueue
// ============================================================================
 
void TickEventRoots(EventQueue& eventQueue, const BehaviorTreeAsset& tree, EntityID entity, AIBlackboard_data& blackboard)
{
    // Guard: If tree has no event roots, skip
    if (tree.m_eventRootIds.empty())
        return;
 
    // Get all events from EventQueue (these are frame N-1 events, now readable in frame N)
    const std::vector<Message>& events = eventQueue.GetEvents();
 
    // Iterate through all events
    for (const Message& msg : events)
    {
        // Phase 38b: Match event type to OnEvent nodes
        // Find OnEvent root nodes that are listening for this event type
        for (uint32_t eventRootId : tree.m_eventRootIds)
        {
            // Get the OnEvent root node
            const BTNode* onEventRoot = tree.GetNode(eventRootId);
            if (!onEventRoot)
                continue;
 
            // Check if this OnEvent node is listening for this event type
            // eventType field contains the EventType enum value as string (e.g., "Olympe_EventType_AI_Explosion")
            if (onEventRoot->eventType.empty())
                continue;
 
            // Convert message type to string for comparison
            // For now, simple enum-to-string mapping
            std::string msgTypeStr;
            switch (msg.msg_type)
            {
                case EventType::Olympe_EventType_AI_Explosion:
                    msgTypeStr = "Olympe_EventType_AI_Explosion";
                    break;
                case EventType::Olympe_EventType_AI_Noise:
                    msgTypeStr = "Olympe_EventType_AI_Noise";
                    break;
                case EventType::Olympe_EventType_AI_DamageDealt:
                    msgTypeStr = "Olympe_EventType_AI_DamageDealt";
                    break;
                case EventType::Olympe_EventType_Object_Create:
                    msgTypeStr = "Olympe_EventType_Object_Create";
                    break;
                case EventType::Olympe_EventType_Object_Destroy:
                    msgTypeStr = "Olympe_EventType_Object_Destroy";
                    break;
                default:
                    msgTypeStr = "";
                    break;
            }
 
            // Phase 38b: Optional event message filtering (future enhancement)
            // If eventMessage is set, only activate if message content matches
            // For now, simple event type matching
 
            // Check if this OnEvent node matches the event type
            if (onEventRoot->eventType == msgTypeStr)
            {
                // Execute this OnEvent root node
                std::cout << "[TickEventRoots] Entity " << entity << ": Executing OnEvent root " << eventRootId
                          << " for event '" << msgTypeStr << "'" << std::endl;
 
                // Execute the OnEvent root (will traverse its child tree)
                ExecuteBTNode(*onEventRoot, entity, blackboard, tree);
            }
        }
    }
}