Как использовать Behavior Graph в Unity при создании игрового AI

// Пример доступа к переменным Behavior Graph из скрипта
[SerializeField] private BehaviorAgent _agent;
 
void Start()
{
    // Получение доступа к переменной блэкборда
    _agent.SetBlackboardValue<float>("PatrolSpeed", 3.5f);
    
    // Запуск графа
    _agent.Start();
}

[Serializable, GeneratePropertyBag]
[NodeDescription(name: "Move2D", 
story: "[Agent] Navigates To [Target]", 
category: "Action", 
id: "739a0711c5da6e4ca560ae951d045b61")]
public partial class Move2DAction : Action
{
    [SerializeReference] public BlackboardVariable<GameObject> Agent;
    [SerializeReference] public BlackboardVariable<GameObject> Target;
    [SerializeReference] public BlackboardVariable<float> Speed = new(1.0f);
    [SerializeReference] public BlackboardVariable<float> DistanceThreshold = new(0.2f);
 
    private Rigidbody2D _agentRb;
 
    protected override Status OnStart()
    {
        if (Agent?.Value == null || Target?.Value == null)
            return Status.Failure;
        
        _agentRb = Agent.Value.GetComponent<Rigidbody2D>();
        if (_agentRb == null)
            return Status.Failure;
 
        return Status.Running;
    }
 
    protected override Status OnUpdate()
    {
        if (Agent?.Value == null || Target?.Value == null)
            return Status.Failure;
        
        Vector2 direction = (Target.Value.transform.position - Agent.Value.transform.position);
        float distance = direction.magnitude;
        
        if (distance <= DistanceThreshold.Value)
            return Status.Success;
        
        direction.Normalize();
        _agentRb.velocity = direction * Speed.Value;
        
        return Status.Running;
    }
}

// Пример отправки события из кода
[SerializeField] private EventChannel _enemySpottedChannel;
 
void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        _enemySpottedChannel.Invoke();
    }
}

// Пример получения экспозированных переменных внутри субграфа
protected override Status OnUpdate()
{
    // Переменная Speed экспозирована и может иметь разные значения
    // в разных местах использования субграфа
    float adjustedSpeed = Speed.Value * SpeedMultiplier.Value;
    
    // Остальная логика узла...
    _rb.velocity = _direction * adjustedSpeed;
    
    return Status.Running;
}

// Выбор субграфа в зависимости от сложности игры
[SerializeField] private BehaviorGraph _easyEnemyBehavior;
[SerializeField] private BehaviorGraph _mediumEnemyBehavior;
[SerializeField] private BehaviorGraph _hardEnemyBehavior;
 
void UpdateDifficulty(GameDifficulty difficulty)
{
    BehaviorGraph selectedGraph = difficulty switch
    {
        GameDifficulty.Easy => _easyEnemyBehavior,
        GameDifficulty.Medium => _mediumEnemyBehavior,
        GameDifficulty.Hard => _hardEnemyBehavior,
        _ => _mediumEnemyBehavior
    };
    
    // Находим все узлы RunSubgraph и меняем их граф
    var runSubgraphNodes = _mainBehaviorGraph.GetNodes<RunSubgraphNode>();
    foreach (var node in runSubgraphNodes.Where(n => n.GetBlackboardValue<string>("BehaviorType") == "Combat"))
    {
        node.SetSubgraph(selectedGraph);
    }
}

// Пример узла, который отправляет команду в ECS-систему
public class SendECSCommandNode : Action
{
    [SerializeReference] public BlackboardVariable<CommandType> CommandType;
    [SerializeReference] public BlackboardVariable<Entity> TargetEntity;
    
    protected override Status OnUpdate()
    {
        var command = new UnitCommand
        {
            Type = CommandType.Value,
            Target = TargetEntity.Value
        };
        
        // Добавление команды в очередь для обработки ECS-системой
        World.DefaultGameObjectInjectionWorld.EntityManager
            .GetComponentData<CommandBuffer>(CommandBufferEntity)
            .AddCommand(command);
        
        return Status.Success;
    }
}

[Sticky Note]
Эта секция графа отвечает за поведение персонажа в бою.
1. Сначала проверяется здоровье — если оно низкое, персонаж попытается найти аптечку.
2. Если здоровье в норме, проверяется наличие противников в зоне видимости.
3. Для врагов в зоне досягаемости происходит атака, для дальних — перемещение к ним.

// Создание канала команд в редакторе
[CreateAssetMenu(fileName = "SquadCommandChannel", menuName = "Game/Channels/Squad Command")]
public class SquadCommandChannel : EventChannel
{
    // События могут нести полезную нагрузку
    public enum CommandType { Attack, Retreat, Hold, Formation }
    public CommandType CurrentCommand { get; private set; }
    
    public void SendCommand(CommandType command)
    {
        CurrentCommand = command;
        Invoke(); // Вызывает событие
    }
}

// В графе поведения члена отряда
[SerializeReference] public BlackboardVariable<Vector3> LastKnownPlayerPosition = new(Vector3.zero, isShared: true);
[SerializeReference] public BlackboardVariable<float> LastUpdateTime = new(0f, isShared: true);
 
// Когда один из агентов видит игрока, он обновляет общие данные
protected override Status OnUpdate()
{
    if (CanSeePlayer.Value)
    {
        LastKnownPlayerPosition.Value = PlayerTransform.Value.position;
        LastUpdateTime.Value = Time.time;
        return Status.Success;
    }
    return Status.Failure;
}

[CreateAssetMenu(fileName = "BehaviorLibrary", menuName = "Game/AI/Behavior Library")]
public class BehaviorLibrary : ScriptableObject
{
    [Serializable]
    public class BehaviorEntry
    {
        public string Name;
        public string Description;
        public BehaviorGraph Graph;
        public Texture2D Icon;
    }
    
    public List<BehaviorEntry> Behaviors = new();
}
 
// Редактор для быстрого доступа к библиотеке
public class BehaviorLibraryWindow : EditorWindow
{
    [MenuItem("Window/AI/Behavior Library")]
    public static void ShowWindow()
    {
        GetWindow<BehaviorLibraryWindow>("Behavior Library");
    }
    
    // Реализация интерфейса окна...
}

public class TacticalEvaluatorNode : SequenceNode
{
    [SerializeReference] public BlackboardVariable<List<GameObject>> Enemies;
    [SerializeReference] public BlackboardVariable<List<GameObject>> CoverPoints;
    [SerializeReference] public BlackboardVariable<float> Health;
    [SerializeReference] public BlackboardVariable<TacticalAction> SelectedAction;
 
    protected override Status OnUpdate()
    {
        float threatLevel = CalculateThreatLevel(Enemies.Value);
        bool hasNearCover = FindClosestCover(CoverPoints.Value) != null;
        
        // Принятие тактического решения на основе контекста
        if (Health.Value < 0.3f && hasNearCover)
            SelectedAction.Value = TacticalAction.TakeCover;
        else if (threatLevel > 0.7f)
            SelectedAction.Value = TacticalAction.Retreat;
        else if (threatLevel < 0.3f)
            SelectedAction.Value = TacticalAction.Attack;
        else
            SelectedAction.Value = TacticalAction.Flank;
            
        return Status.Success;
    }
    
    // Методы оценки тактической ситуации...
}

public class BehaviorGenerator : MonoBehaviour
{
    [SerializeField] private List<BehaviorGraph> _attackBehaviors;
    [SerializeField] private List<BehaviorGraph> _defenseBehaviors;
    [SerializeField] private List<BehaviorGraph> _specialAbilities;
    
    private BehaviorGraph GenerateEnemyBehavior(EnemyType type, DifficultyLevel difficulty)
    {
        BehaviorGraph newGraph = ScriptableObject.CreateInstance<BehaviorGraph>();
        
        // Добавление базовых узлов и переменных
        AddCoreNodes(newGraph);
        
        // Выбор подходящих для типа врага поведений
        BehaviorGraph attackGraph = SelectAppropriate(_attackBehaviors, type);
        BehaviorGraph defenseGraph = SelectAppropriate(_defenseBehaviors, type);
        
        // Добавление случайных специальных способностей в зависимости от сложности
        int abilitiesCount = Mathf.FloorToInt(difficulty) + Random.Range(0, 2);
        for (int i = 0; i < abilitiesCount; i++)
        {
            AddSpecialAbility(newGraph, _specialAbilities[Random.Range(0, _specialAbilities.Count)]);
        }
        
        // Соединение всех компонентов в финальный граф
        ConnectComponents(newGraph, attackGraph, defenseGraph);
        
        return newGraph;
    }
    
    // Вспомогательные методы...
}

public class ShortTermMemoryNode : Action
{
    [SerializeReference] public BlackboardVariable<GameObject> Player;
    [SerializeReference] public BlackboardVariable<Vector3> LastKnownPosition;
    [SerializeReference] public BlackboardVariable<float> MemoryDecayRate = new(0.1f);
    [SerializeReference] public BlackboardVariable<float> Confidence = new(1.0f);
    
    private float _lastUpdateTime;
    
    protected override Status OnStart()
    {
        _lastUpdateTime = Time.time;
        return Status.Running;
    }
    
    protected override Status OnUpdate()
    {
        // Проверка видимости игрока
        if (CanSeePlayer())
        {
            // Обновление данных при прямом контакте
            LastKnownPosition.Value = Player.Value.transform.position;
            Confidence.Value = 1.0f;
            _lastUpdateTime = Time.time;
        }
        else
        {
            // Постепенное снижение уверенности в старых данных
            float timeSinceUpdate = Time.time - _lastUpdateTime;
            Confidence.Value = Mathf.Max(0, Confidence.Value - MemoryDecayRate.Value * timeSinceUpdate);
        }
        
        return Status.Running;
    }
    
    private bool CanSeePlayer()
    {
        // Реализация проверки видимости...
        return false;
    }
}

public class AIUpdateManager : MonoBehaviour
{
    private List<BehaviorAgent> _allAgents = new();
    private int _currentIndex = 0;
    private int _agentsPerFrame = 5;
    
    public void RegisterAgent(BehaviorAgent agent)
    {
        _allAgents.Add(agent);
    }
    
    private void Update()
    {
        // Обновляем только часть агентов каждый кадр
        for (int i = 0; i < _agentsPerFrame; i++)
        {
            if (_currentIndex >= _allAgents.Count)
                _currentIndex = 0;
                
            _allAgents[_currentIndex].ManualUpdate();
            _currentIndex++;
        }
    }
}

public class SpatialPartitionNode : Action
{
    [SerializeReference] public BlackboardVariable<GameObject> Self;
    [SerializeReference] public BlackboardVariable<float> DetectionRadius;
    [SerializeReference] public BlackboardVariable<List<GameObject>> VisibleEntities;
    
    protected override Status OnUpdate()
    {
        VisibleEntities.Value.Clear();
        
        // Запрос к структуре пространственного разделения вместо поиска по всем агентам
        var nearbyEntities = GameWorld.SpatialGrid.QueryRadius(
            Self.Value.transform.position, 
            DetectionRadius.Value
        );
        
        foreach (var entity in nearbyEntities)
        {
            if (IsVisible(Self.Value, entity))
                VisibleEntities.Value.Add(entity);
        }
        
        return Status.Success;
    }
}

public class FuzzyEvaluatorNode : Action
{
    [SerializeReference] public BlackboardVariable<float> Health;
    [SerializeReference] public BlackboardVariable<float> Distance;
    [SerializeReference] public BlackboardVariable<TacticalAction> SelectedAction;
    
    protected override Status OnUpdate()
    {
        // Степени принадлежности к нечётким множествам
        float lowHealth = FuzzyMembership(Health.Value, 0f, 0.4f);
        float mediumHealth = FuzzyMembership(Health.Value, 0.3f, 0.7f);
        float highHealth = FuzzyMembership(Health.Value, 0.6f, 1f);
        
        float closeDistance = FuzzyMembership(Distance.Value, 0f, 5f);
        float mediumDistance = FuzzyMembership(Distance.Value, 4f, 15f);
        float farDistance = FuzzyMembership(Distance.Value, 12f, 30f);
        
        // Нечёткие правила
        float retreatScore = Math.Max(lowHealth * closeDistance, lowHealth * mediumDistance);
        float attackScore = highHealth * closeDistance;
        float flankerScore = mediumHealth * mediumDistance;
        float sniperScore = Math.Max(mediumHealth * farDistance, highHealth * farDistance);
        
        // Дефаззификация — выбор действия с максимальным значением
        float maxScore = Math.Max(Math.Max(retreatScore, attackScore), 
                                 Math.Max(flankerScore, sniperScore));
        
        if (maxScore == retreatScore)
            SelectedAction.Value = TacticalAction.Retreat;
        else if (maxScore == attackScore)
            SelectedAction.Value = TacticalAction.Attack;
        else if (maxScore == flankerScore)
            SelectedAction.Value = TacticalAction.Flank;
        else
            SelectedAction.Value = TacticalAction.Snipe;
        
        return Status.Success;
    }
    
    private float FuzzyMembership(float value, float min, float max)
    {
        if (value <= min) return 0f;
        if (value >= max) return 1f;
        return (value - min) / (max - min);
    }
}

public class GraphEvolutionSystem : MonoBehaviour
{
    [SerializeField] private BehaviorGraph _baseGraph;
    [SerializeField] private List<BehaviorGraph> _strategyTemplates;
    [SerializeField] private List<BehaviorAgent> _agents;
    
    private Dictionary<BehaviorAgent, PerformanceMetrics> _agentPerformance = new();
    
    public void EvolveAgentStrategies()
    {
        // Сортировка агентов по эффективности
        var rankedAgents = _agentPerformance.OrderByDescending(pair => pair.Value.OverallScore).ToList();
        
        // Замена стратегий у наименее эффективных агентов
        for (int i = rankedAgents.Count / 2; i < rankedAgents.Count; i++)
        {
            var agent = rankedAgents[i].Key;
            
            // Мутация графа одного из лучших агентов
            var bestAgentGraph = rankedAgents[Random.Range(0, rankedAgents.Count / 4)].Key.Graph;
            var newGraph = MutateGraph(bestAgentGraph);
            
            // Применение нового графа
            agent.SetGraph(newGraph);
        }
    }
    
    private BehaviorGraph MutateGraph(BehaviorGraph sourceGraph)
    {
        // Реализация мутации графа...
        // Может включать изменение параметров, замену узлов или перестройку связей
        
        return null; // Вернуть мутированный граф
    }
}

public class AdaptiveOpponentGenerator : MonoBehaviour
{
    [SerializeField] private PlayerDataAnalyzer _playerAnalyzer;
    [SerializeField] private BehaviorTemplateLibrary _templates;
    
    public BehaviorGraph GenerateCounterBehavior()
    {
        PlayerStyle playerStyle = _playerAnalyzer.GetDominantStyle();
        
        // Выбор шаблонов, эффективных против данного стиля
        List<BehaviorTemplate> counterTemplates = _templates.GetCounters(playerStyle);
        
        // Комбинирование шаблонов с небольшими вариациями
        BehaviorGraph resultGraph = CombineTemplates(counterTemplates, 
                                                   playerStyle.Aggression, 
                                                   playerStyle.Patience);
        
        return resultGraph;
    }
    
    private BehaviorGraph CombineTemplates(List<BehaviorTemplate> templates, 
                                          float aggression, 
                                          float patience)
    {
        // Логика комбинирования шаблонов с учётом параметров
        return null;
    }
}

public class NeuralNetworkNode : Action
{
    [SerializeReference] public BlackboardVariable<float[]> InputFeatures;
    [SerializeReference] public BlackboardVariable<float[]> OutputValues;
    
    private NeuralNetwork _network;
    
    protected override Status OnStart()
    {
        // Загрузка предварительно обученной модели
        _network = NeuralNetworkLoader.Load("combat_tactics_model");
        return Status.Running;
    }
    
    protected override Status OnUpdate()
    {
        // Передача входных данных в нейросеть и получение результатов
        OutputValues.Value = _network.Predict(InputFeatures.Value);
        return Status.Success;
    }
}

// Узел, определяющий распорядок дня NPC
public class DailyRoutineNode : Action
{
    [SerializeReference] public BlackboardVariable<GameObject> Self;
    [SerializeReference] public BlackboardVariable<DayTime> CurrentTime;
    [SerializeReference] public BlackboardVariable<RoutineActivity> SelectedActivity;
    [SerializeReference] public BlackboardVariable<GameObject> ActivityLocation;
 
    protected override Status OnUpdate()
    {
        // Определение активности на основе времени суток
        switch (CurrentTime.Value)
        {
            case DayTime.Morning:
                SelectedActivity.Value = RoutineActivity.Field;
                ActivityLocation.Value = GameLocations.Field;
                break;
            case DayTime.Noon:
                SelectedActivity.Value = RoutineActivity.Market;
                ActivityLocation.Value = GameLocations.Market;
                break;
            case DayTime.Evening:
                SelectedActivity.Value = RoutineActivity.Home;
                ActivityLocation.Value = GameLocations.House;
                break;
            case DayTime.Night:
                SelectedActivity.Value = RoutineActivity.Sleep;
                ActivityLocation.Value = GameLocations.Bed;
                break;
        }
        
        return Status.Success;
    }
}

// Часть графа для выбора атакующего поведения
public class SelectAttackPatternNode : Action
{
    [SerializeReference] public BlackboardVariable<EnemyType> Type;
    [SerializeReference] public BlackboardVariable<GameObject> Player;
    [SerializeReference] public BlackboardVariable<AttackPattern> SelectedPattern;
    [SerializeReference] public BlackboardVariable<float> DistanceToPlayer;
 
    protected override Status OnUpdate()
    {
        DistanceToPlayer.Value = Vector3.Distance(
            Self.Value.transform.position, 
            Player.Value.transform.position
        );
        
        switch (Type.Value)
        {
            case EnemyType.Brute:
                SelectedPattern.Value = AttackPattern.DirectAssault;
                break;
                
            case EnemyType.Archer:
                if (DistanceToPlayer.Value < 5.0f)
                    SelectedPattern.Value = AttackPattern.CreateDistance;
                else if (DistanceToPlayer.Value > 15.0f)
                    SelectedPattern.Value = AttackPattern.ApproachSlightly;
                else
                    SelectedPattern.Value = AttackPattern.RangedAttack;
                break;
                
            case EnemyType.Mage:
                if (Health.Value < 0.3f)
                    SelectedPattern.Value = AttackPattern.Teleport;
                else if (ManaPool.Value > 0.5f)
                    SelectedPattern.Value = AttackPattern.CastPowerful;
                else
                    SelectedPattern.Value = AttackPattern.CastWeak;
                break;
        }
        
        return Status.Success;
    }
}

// Канал событий для команды
[CreateAssetMenu(fileName = "SquadEvents", menuName = "Game/AI/Squad Events")]
public class SquadEventChannel : EventChannel
{
    public enum CommandType { Attack, Flank, Support, Retreat }
    public CommandType Command { get; private set; }
    public Vector3 TargetPosition { get; private set; }
    
    public void IssueCommand(CommandType cmd, Vector3 position)
    {
        Command = cmd;
        TargetPosition = position;
        Invoke();
    }
}

// В графе лидера отряда
protected override Status OnUpdate()
{
    // Анализ тактической ситуации
    if (TeamHealth.Value < 0.3f)
    {
        SquadEvents.Value.IssueCommand(CommandType.Retreat, RetreatPoint.Value);
    }
    else if (CanFlankPlayer.Value)
    {
        SquadEvents.Value.IssueCommand(CommandType.Flank, FlankPosition.Value);
    }
    else
    {
        SquadEvents.Value.IssueCommand(CommandType.Attack, Player.Value.transform.position);
    }
    
    return Status.Success;
}

// В графе члена отряда: узел, который подписывается на команды
public class SquadMemberNode : Action
{
    [SerializeReference] public BlackboardVariable<SquadEventChannel> SquadEvents;
    [SerializeReference] public BlackboardVariable<CommandType> CurrentCommand;
    [SerializeReference] public BlackboardVariable<Vector3> TargetPosition;
    
    private EventHandler _commandHandler;
    
    protected override Status OnStart()
    {
        // Подписка на события
        _commandHandler = (sender, args) => {
            CurrentCommand.Value = SquadEvents.Value.Command;
            TargetPosition.Value = SquadEvents.Value.TargetPosition;
        };
        
        SquadEvents.Value.OnEventRaised += _commandHandler;
        return Status.Running;
    }
    
    protected override void OnStop()
    {
        // Отписка при завершении
        SquadEvents.Value.OnEventRaised -= _commandHandler;
    }
    
    protected override Status OnUpdate()
    {
        // Постоянно работающий узел, который слушает команды
        return Status.Running;
    }
}

public class EmotionalStateNode : Action
{
    [SerializeReference] public BlackboardVariable<float> Fear = new(0f);
    [SerializeReference] public BlackboardVariable<float> Anger = new(0f);
    [SerializeReference] public BlackboardVariable<float> Joy = new(0f);
    [SerializeReference] public BlackboardVariable<float> EmotionalDecayRate = new(0.01f);
    [SerializeReference] public BlackboardVariable<EmotionalState> DominantEmotion;
    
    protected override Status OnUpdate()
    {
        // Естественное затухание эмоций со временем
        Fear.Value = Mathf.Max(0, Fear.Value - EmotionalDecayRate.Value * Time.deltaTime);
        Anger.Value = Mathf.Max(0, Anger.Value - EmotionalDecayRate.Value * Time.deltaTime);
        Joy.Value = Mathf.Max(0, Joy.Value - EmotionalDecayRate.Value * Time.deltaTime);
        
        // Определение доминирующей эмоции
        if (Fear.Value > Anger.Value && Fear.Value > Joy.Value && Fear.Value > 0.3f)
            DominantEmotion.Value = EmotionalState.Fear;
        else if (Anger.Value > Fear.Value && Anger.Value > Joy.Value && Anger.Value > 0.3f)
            DominantEmotion.Value = EmotionalState.Anger;
        else if (Joy.Value > 0.3f)
            DominantEmotion.Value = EmotionalState.Joy;
        else
            DominantEmotion.Value = EmotionalState.Neutral;
            
        return Status.Running;
    }
}

// Модификация скорости перемещения на основе эмоций
protected override Status OnUpdate()
{
    float baseSpeed = MovementSpeed.Value;
    
    switch (EmotionalState.Value)
    {
        case EmotionalState.Fear:
            CurrentSpeed.Value = baseSpeed * 1.5f; // Бег от страха
            break;
        case EmotionalState.Anger:
            CurrentSpeed.Value = baseSpeed * 1.2f; // Агрессивное движение
            break;
        case EmotionalState.Joy:
            CurrentSpeed.Value = baseSpeed * 0.8f; // Расслабленное движение
            break;
        default:
            CurrentSpeed.Value = baseSpeed;
            break;
    }
    
    return Status.Success;
}

public class AILODManager : MonoBehaviour
{
    [SerializeField] private Transform _player;
    [SerializeField] private float _highDetailDistance = 10f;
    [SerializeField] private float _mediumDetailDistance = 30f;
    
    private List<BehaviorAgent> _allAgents = new();
    
    public void RegisterAgent(BehaviorAgent agent)
    {
        _allAgents.Add(agent);
    }
    
    private void Update()
    {
        foreach (var agent in _allAgents)
        {
            float distance = Vector3.Distance(_player.position, agent.transform.position);
            
            if (distance <= _highDetailDistance)
            {
                agent.SetLODLevel(AI_LOD.High); // Полный граф поведения
            }
            else if (distance <= _mediumDetailDistance)
            {
                agent.SetLODLevel(AI_LOD.Medium); // Упрощенный граф
            }
            else
            {
                agent.SetLODLevel(AI_LOD.Low); // Минимальные обновления
            }
        }
    }
}

public class FlockManager : MonoBehaviour
{
    [SerializeField] private List<BehaviorAgent> _flockMembers = new();
    [SerializeField] private Vector3 _flockCenter;
    [SerializeField] private Vector3 _flockDirection;
    [SerializeField] private float _cohesionStrength = 1.0f;
    [SerializeField] private float _alignmentStrength = 0.8f;
    [SerializeField] private float _separationStrength = 1.2f;
    
    void Update()
    {
        CalculateFlockProperties();
        BroadcastToMembers();
    }
    
    private void CalculateFlockProperties()
    {
        // Расчёт общих свойств стаи
        Vector3 centerSum = Vector3.zero;
        Vector3 directionSum = Vector3.zero;
        
        foreach (var member in _flockMembers)
        {
            centerSum += member.transform.position;
            
            // Проверяем, что Rigidbody существует
            var rb = member.GetComponent<Rigidbody>();
            if (rb != null)
                directionSum += rb.velocity.normalized;
        }
        
        _flockCenter = centerSum / _flockMembers.Count;
        _flockDirection = directionSum.normalized;
    }
    
    private void BroadcastToMembers()
    {
        foreach (var member in _flockMembers)
        {
            member.SetBlackboardValue("FlockCenter", _flockCenter);
            member.SetBlackboardValue("FlockDirection", _flockDirection);
            member.SetBlackboardValue("CohesionStrength", _cohesionStrength);
            member.SetBlackboardValue("AlignmentStrength", _alignmentStrength);
            member.SetBlackboardValue("SeparationStrength", _separationStrength);
        }
    }
}

public class FlockMemberBehaviorNode : Action
{
    [SerializeReference] public BlackboardVariable<Vector3> FlockCenter;
    [SerializeReference] public BlackboardVariable<Vector3> FlockDirection;
    [SerializeReference] public BlackboardVariable<float> CohesionStrength;
    [SerializeReference] public BlackboardVariable<float> AlignmentStrength;
    [SerializeReference] public BlackboardVariable<float> SeparationStrength;
    
    protected override Status OnUpdate()
    {
        // Получение компонентов
        var rb = Self.Value.GetComponent<Rigidbody>();
        if (rb == null)
            return Status.Failure;
            
        // Расчёт векторов влияния
        Vector3 cohesion = (FlockCenter.Value - Self.Value.transform.position).normalized;
        Vector3 alignment = FlockDirection.Value;
        Vector3 separation = CalculateSeparation();
        
        // Комбинирование сил
        Vector3 combinedForce = cohesion * CohesionStrength.Value + 
                              alignment * AlignmentStrength.Value + 
                              separation * SeparationStrength.Value;
        
        // Применение результирующей силы с ограничением скорости
        rb.velocity = Vector3.ClampMagnitude(rb.velocity + combinedForce, MaxSpeed.Value);
        
        return Status.Running;
    }
    
    private Vector3 CalculateSeparation()
    {
        // Расчёт вектора разделения, отталкивающего от соседей
        // ...
        return Vector3.zero; // Упрощённый вариант
    }
}

public class ML_TacticalDecisionNode : Action
{
    [SerializeReference] public BlackboardVariable<float[]> ContextFeatures;
    [SerializeReference] public BlackboardVariable<int> SelectedTactic;
    
    private TacticPredictor _predictor;
    
    protected override Status OnStart()
    {
        // Загрузка модели при первом запуске
        _predictor = new TacticPredictor("Assets/ML/TacticModel.onnx");
        return Status.Running;
    }
    
    protected override Status OnUpdate()
    {
        // Подготовка входных данных для модели
        var input = PreprocessInput(ContextFeatures.Value);
        
        // Получение предсказания
        var output = _predictor.Predict(input);
        
        // Выбор тактики с наивысшей вероятностью
        SelectedTactic.Value = GetMaxProbabilityIndex(output);
        
        return Status.Success;
    }
    
    private float[] PreprocessInput(float[] rawFeatures)
    {
        // Нормализация, масштабирование и другая предобработка
        return rawFeatures;
    }
    
    private int GetMaxProbabilityIndex(float[] probabilities)
    {
        int maxIndex = 0;
        float maxValue = probabilities[0];
        
        for (int i = 1; i < probabilities.Length; i++)
        {
            if (probabilities[i] > maxValue)
            {
                maxValue = probabilities[i];
                maxIndex = i;
            }
        }
        
        return maxIndex;
    }
}

public class RL_AgentTrainer : MonoBehaviour
{
    [SerializeField] private BehaviorAgent _agent;
    [SerializeField] private float _learningRate = 0.01f;
    [SerializeField] private float _discountFactor = 0.95f;
    
    private Dictionary<string, float> _qTable = new();
    private string _lastState;
    private string _lastAction;
    
    public void RecordState(string state, string action, float reward)
    {
        string stateAction = $"{state}:{action}";
        
        // Обновление Q-значения для состояния и действия
        if (!_qTable.ContainsKey(stateAction))
            _qTable[stateAction] = 0;
            
        if (_lastState != null)
        {
            string lastStateAction = $"{_lastState}:{_lastAction}";
            
            // Q-learning формула
            float maxQ = GetMaxQForState(state);
            _qTable[lastStateAction] += _learningRate * (reward + _discountFactor * maxQ - _qTable[lastStateAction]);
        }
        
        _lastState = state;
        _lastAction = action;
        
        // Сохранение модели периодически
        if (Time.frameCount % 1000 == 0)
            SaveModel();
    }
    
    public string GetBestAction(string state, List<string> possibleActions)
    {
        // Исследование vs использование (exploration vs exploitation)
        if (Random.value < GetExplorationRate())
            return possibleActions[Random.Range(0, possibleActions.Count)];
        
        // Выбор действия с максимальным Q-значением
        float maxQ = float.MinValue;
        string bestAction = possibleActions[0];
        
        foreach (var action in possibleActions)
        {
            string stateAction = $"{state}:{action}";
            float q = _qTable.ContainsKey(stateAction) ? _qTable[stateAction] : 0;
            
            if (q > maxQ)
            {
                maxQ = q;
                bestAction = action;
            }
        }
        
        return bestAction;
    }
    
    private float GetMaxQForState(string state)
    {
        // Поиск максимального Q-значения для состояния
        float maxQ = float.MinValue;
        
        foreach (var entry in _qTable)
        {
            if (entry.Key.StartsWith(state + ":") && entry.Value > maxQ)
                maxQ = entry.Value;
        }
        
        return maxQ == float.MinValue ? 0 : maxQ;
    }
    
    private float GetExplorationRate()
    {
        // Снижение вероятности случайных действий со временем
        return Mathf.Max(0.1f, 1.0f - GameManager.Instance.GameTime / 3600f);
    }
    
    private void SaveModel()
    {
        // Сохранение Q-таблицы
    }
}

public class RL_ActionSelectorNode : Action
{
    [SerializeReference] public BlackboardVariable<RL_AgentTrainer> Trainer;
    [SerializeReference] public BlackboardVariable<string> CurrentState;
    [SerializeReference] public BlackboardVariable<List<string>> PossibleActions;
    [SerializeReference] public BlackboardVariable<string> SelectedAction;
    
    protected override Status OnUpdate()
    {
        if (Trainer.Value == null)
            return Status.Failure;
            
        SelectedAction.Value = Trainer.Value.GetBestAction(
            CurrentState.Value, 
            PossibleActions.Value
        );
        
        return Status.Success;
    }
}

public class HybridAI_CombatNode : Action
{
    [SerializeReference] public BlackboardVariable<GameObject> Enemy;
    [SerializeReference] public BlackboardVariable<CombatContext> Context;
    [SerializeReference] public BlackboardVariable<CombatStyle> Style;
    
    private PosePredictor _posePredictor;
    private AttackEvaluator _attackEvaluator;
    
    protected override Status OnStart()
    {
        // Загрузка специализированных моделей
        _posePredictor = new PosePredictor("Assets/ML/PoseModel.onnx");
        _attackEvaluator = new AttackEvaluator("Assets/ML/AttackModel.onnx");
        return Status.Running;
    }
    
    protected override Status OnUpdate()
    {
        if (Enemy.Value == null)
            return Status.Failure;
            
        // Традиционная логика для высокоуровневых решений
        if (Context.Value.Health < 0.2f)
        {
            Style.Value = CombatStyle.Defensive;
        }
        else if (Context.Value.Stamina > 0.8f)
        {
            Style.Value = CombatStyle.Aggressive;
        }
        
        // ML для предсказания следующего действия противника
        var enemyPose = GetEnemyPoseFeatures();
        var nextPosePrediction = _posePredictor.Predict(enemyPose);
        
        // ML для оценки эффективности разных атак
        var attackContext = GetAttackContext(nextPosePrediction);
        var attackScores = _attackEvaluator.Evaluate(attackContext);
        
        // Выбор лучшей атаки на основе оценок ML и текущего стиля
        SelectBestAttack(attackScores, Style.Value);
        
        return Status.Running;
    }
    
    // Вспомогательные методы
}