Разработка продвинутого ИИ в Unity с использованием Behavior Graph

using Unity.Behaviors;
using UnityEngine;
using UnityEngine.AI;
 
[ActionCategory("Custom")]
public class PatrolAction : Action
{
    [SerializeField] private BlackboardPropertyName<Transform[]> _waypoints;
    [SerializeField] private BlackboardPropertyName<int> _currentWaypointIndex;
    
    private NavMeshAgent _agent;
    private int _targetWaypoint = 0;
    
    protected override void OnInitialize()
    {
        _agent = GetComponent<NavMeshAgent>();
        _targetWaypoint = GetBlackboardValue(_currentWaypointIndex, 0);
    }
    
    protected override Status OnUpdate()
    {
        var waypoints = GetBlackboardValue(_waypoints);
        if (waypoints == null || waypoints.Length == 0)
            return Status.Failure;
        
        if (!_agent.pathPending && _agent.remainingDistance < 0.5f)
        {
            _targetWaypoint = (_targetWaypoint + 1) % waypoints.Length;
            SetBlackboardValue(_currentWaypointIndex, _targetWaypoint);
            _agent.SetDestination(waypoints[_targetWaypoint].position);
        }
        
        return Status.Running;
    }
    
    protected override Status OnStop()
    {
        _agent.ResetPath();
        return Status.Success;
    }
}

[ActionCategory("Animation")]
public class PlayAnimationAction : Action
{
    [SerializeField] private string _animationName;
    
    private Animator _animator;
    
    protected override void OnInitialize()
    {
        _animator = GetComponent<Animator>();
    }
    
    protected override Status OnUpdate()
    {
        if (_animator == null)
            return Status.Failure;
        
        _animator.Play(_animationName);
        return Status.Success;
    }
}

[ActionCategory("Physics")]
public class OnCollisionEnterAction : Action
{
    [SerializeField] private BlackboardPropertyName<GameObject> _collidedObject;
    
    private bool _collisionDetected = false;
    private GameObject _collider = null;
    
    protected override void OnInitialize()
    {
        var rigidBody = GetComponent<Rigidbody>();
        if (rigidBody != null)
        {
            // Подписываемся на события коллизии
            StartCoroutine(DetectCollisions());
        }
    }
    
    private System.Collections.IEnumerator DetectCollisions()
    {
        while (true)
        {
            if (_collisionDetected)
            {
                SetBlackboardValue(_collidedObject, _collider);
                yield break;
            }
            yield return null;
        }
    }
    
    public void OnCollisionEnter(Collision collision)
    {
        _collisionDetected = true;
        _collider = collision.gameObject;
    }
    
    protected override Status OnUpdate()
    {
        if (_collisionDetected)
            return Status.Success;
        return Status.Running;
    }
}

[ActionCategory("Detection")]
public class DetectPlayer : Action
{
    [SerializeField] private BlackboardPropertyName<Transform> _player;
    [SerializeField] private BlackboardPropertyName<bool> _isPlayerVisible;
    [SerializeField] private BlackboardPropertyName<float> _detectionInterval = 0.5f;
    
    private float _lastCheckTime = 0;
    
    protected override Status OnUpdate()
    {
        if (Time.time - _lastCheckTime < GetBlackboardValue(_detectionInterval))
            return GetBlackboardValue(_isPlayerVisible) ? Status.Success : Status.Running;
        
        _lastCheckTime = Time.time;
        
        var player = GetBlackboardValue(_player);
        if (player == null)
            return Status.Failure;
        
        // Здесь логика проверки видимости
        bool isVisible = CanSeePlayer(player);
        SetBlackboardValue(_isPlayerVisible, isVisible);
        
        return isVisible ? Status.Success : Status.Running;
    }
    
    private bool CanSeePlayer(Transform player)
    {
        // Проверка видимости через рейкаст и угол обзора
        // ...
        return false;
    }
}

// Пример программного создания и назначения графа поведения
public class BehaviorGraphManager : MonoBehaviour
{
    [SerializeField] private BehaviorGraph _templateGraph;
    
    public void AssignBehaviorToObject(GameObject target)
    {
        // Создаем агента поведения, если его еще нет
        var agent = target.GetComponent<BehaviorAgent>() ?? 
                    target.AddComponent<BehaviorAgent>();
        
        // Клонируем шаблонный граф
        var instanceGraph = Instantiate(_templateGraph);
        
        // Назначаем клон агенту
        agent.behavior = instanceGraph;
        
        // Настраиваем переменные если нужно
        var blackboard = instanceGraph.blackboard;
        blackboard.SetValue("PatrolSpeed", 3.5f);
    }
}

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using Unity.Behaviors;
 
[CustomEditor(typeof(BehaviorAgent))]
public class BehaviorAgentEditor : Editor
{
    private bool _showBlackboard = true;
    
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        
        BehaviorAgent agent = (BehaviorAgent)target;
        if (agent.behavior == null)
            return;
            
        EditorGUILayout.Space();
        _showBlackboard = EditorGUILayout.Foldout(_showBlackboard, "Blackboard Variables");
        
        if (_showBlackboard)
        {
            EditorGUI.indentLevel++;
            
            var blackboard = agent.behavior.blackboard;
            var propertyNames = blackboard.GetPropertyNames();
            
            foreach (var propName in propertyNames)
            {
                // Показываем только exposed переменные
                if (!blackboard.IsPropertyExposed(propName))
                    continue;
                    
                var propType = blackboard.GetPropertyType(propName);
                
                // Для разных типов используем соответствующие элементы GUI
                if (propType == typeof(float))
                {
                    float value = blackboard.GetValue<float>(propName);
                    float newValue = EditorGUILayout.FloatField(propName, value);
                    if (value != newValue)
                        blackboard.SetValue(propName, newValue);
                }
                else if (propType == typeof(bool))
                {
                    bool value = blackboard.GetValue<bool>(propName);
                    bool newValue = EditorGUILayout.Toggle(propName, value);
                    if (value != newValue)
                        blackboard.SetValue(propName, newValue);
                }
                // Добавьте обработку других типов по необходимости
            }
            
            EditorGUI.indentLevel--;
        }
        
        // Кнопка для открытия графа в редакторе
        if (GUILayout.Button("Edit Behavior Graph"))
        {
            Selection.activeObject = agent.behavior;
        }
    }
}
#endif

[ActionCategory("Debug")]
public class LogStateAction : Action
{
    [SerializeField] private string _message = "Node execution";
    [SerializeField] private LogType _logType = LogType.Log;
    [SerializeField] private bool _logOnlyOnce = true;
    
    private bool _hasLogged = false;
    
    protected override Status OnUpdate()
    {
        if (_logOnlyOnce && _hasLogged)
            return Status.Success;
            
        switch (_logType)
        {
            case LogType.Log:
                Debug.Log($"[{name}] {_message}");
                break;
            case LogType.Warning:
                Debug.LogWarning($"[{name}] {_message}");
                break;
            case LogType.Error:
                Debug.LogError($"[{name}] {_message}");
                break;
        }
        
        _hasLogged = true;
        return Status.Success;
    }
    
    protected override void OnReset()
    {
        _hasLogged = false;
    }
}

[ActionCategory("Debug")]
public class VisualizeStateAction : Action
{
    [SerializeField] private BlackboardPropertyName<Color> _debugColor = Color.red;
    [SerializeField] private BlackboardPropertyName<float> _radius = 1.0f;
    
    private GameObject _visualMarker;
    
    protected override void OnInitialize()
    {
        _visualMarker = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        _visualMarker.transform.parent = transform;
        _visualMarker.transform.localPosition = Vector3.zero;
        
        var renderer = _visualMarker.GetComponent<Renderer>();
        renderer.material.color = GetBlackboardValue(_debugColor);
        
        // Отключаем коллайдер, нам нужна только визуализация
        var collider = _visualMarker.GetComponent<Collider>();
        if (collider)
            Destroy(collider);
    }
    
    protected override Status OnUpdate()
    {
        float radius = GetBlackboardValue(_radius);
        _visualMarker.transform.localScale = new Vector3(radius, radius, radius);
        return Status.Running;
    }
    
    protected override void OnStop()
    {
        if (_visualMarker)
            Destroy(_visualMarker);
    }
}

public class CombatStyleSelector : Action
{
    [SerializeField] private BlackboardPropertyName<float> _healthPercentage;
    [SerializeField] private BlackboardPropertyName<float> _staminaPercentage;
    [SerializeField] private BlackboardPropertyName<float> _distanceToPlayer;
    [SerializeField] private BlackboardPropertyName<string> _selectedStyle;
    
    protected override Status OnUpdate()
    {
        float health = GetBlackboardValue(_healthPercentage);
        float stamina = GetBlackboardValue(_staminaPercentage);
        float distance = GetBlackboardValue(_distanceToPlayer);
        
        string newStyle;
        
        // Логика выбора стиля боя на основе текущего состояния
        if (health < 30f)
        {
            newStyle = "Defensive";
        }
        else if (distance > 5f)
        {
            newStyle = "Ranged";
        }
        else if (stamina > 70f)
        {
            newStyle = "Aggressive";
        }
        else
        {
            newStyle = "Balanced";
        }
        
        // Устанавливаем выбранный стиль в blackboard
        SetBlackboardValue(_selectedStyle, newStyle);
        
        return Status.Success;
    }
}

public class ScheduleManager : Action
{
    [SerializeField] private BlackboardPropertyName<float> _gameTimeHours;
    [SerializeField] private BlackboardPropertyName<string> _currentActivity;
    
    [Serializable]
    public class ScheduleEntry
    {
        public string ActivityName;
        public float StartTimeHours;
        public float EndTimeHours;
    }
    
    [SerializeField] private ScheduleEntry[] _schedule;
    
    protected override Status OnUpdate()
    {
        float currentTime = GetBlackboardValue(_gameTimeHours);
        
        // Находим подходящую активность по текущему времени
        string newActivity = "Idle";  // Действие по умолчанию
        
        foreach (var entry in _schedule)
        {
            if (currentTime >= entry.StartTimeHours && currentTime < entry.EndTimeHours)
            {
                newActivity = entry.ActivityName;
                break;
            }
        }
        
        // Обновляем активность только если она изменилась
        string currentActivity = GetBlackboardValue(_currentActivity);
        if (currentActivity != newActivity)
        {
            SetBlackboardValue(_currentActivity, newActivity);
        }
        
        return Status.Success;
    }
}

public class ResourceAllocationStrategy : Action
{
    [SerializeField] private BlackboardPropertyName<float> _militaryThreatLevel;
    [SerializeField] private BlackboardPropertyName<float> _economyStrength;
    [SerializeField] private BlackboardPropertyName<float> _militaryRatio;
    [SerializeField] private BlackboardPropertyName<float> _economyRatio;
    [SerializeField] private BlackboardPropertyName<float> _researchRatio;
    
    protected override Status OnUpdate()
    {
        float threat = GetBlackboardValue(_militaryThreatLevel);
        float economy = GetBlackboardValue(_economyStrength);
        
        // Распределение ресурсов в зависимости от текущей ситуации
        if (threat > 0.7f)  // Высокая угроза
        {
            // Приоритет военного производства
            SetBlackboardValue(_militaryRatio, 0.7f);
            SetBlackboardValue(_economyRatio, 0.2f);
            SetBlackboardValue(_researchRatio, 0.1f);
        }
        else if (economy < 0.4f)  // Слабая экономика
        {
            // Приоритет экономического развития
            SetBlackboardValue(_militaryRatio, 0.3f);
            SetBlackboardValue(_economyRatio, 0.6f);
            SetBlackboardValue(_researchRatio, 0.1f);
        }
        else  // Стабильная ситуация
        {
            // Сбалансированное развитие с уклоном в исследования
            SetBlackboardValue(_militaryRatio, 0.3f);
            SetBlackboardValue(_economyRatio, 0.3f);
            SetBlackboardValue(_researchRatio, 0.4f);
        }
        
        return Status.Success;
    }
}

public class EmotionManager : Action
{
  [SerializeField] private BlackboardPropertyName<float> _happiness;
  [SerializeField] private BlackboardPropertyName<float> _fear;
  [SerializeField] private BlackboardPropertyName<float> _anger;
  [SerializeField] private BlackboardPropertyName<string> _dominantEmotion;
  
  private float _decayRate = 0.01f;  // Скорость затухания эмоций со временем
  
  protected override Status OnUpdate()
  {
      // Получаем текущие эмоциональные значения
      float happiness = GetBlackboardValue(_happiness);
      float fear = GetBlackboardValue(_fear);
      float anger = GetBlackboardValue(_anger);
      
      // Применяем затухание эмоций с течением времени
      happiness = Mathf.Max(0, happiness - _decayRate);
      fear = Mathf.Max(0, fear - _decayRate);
      anger = Mathf.Max(0, anger - _decayRate);
      
      // Обновляем значения
      SetBlackboardValue(_happiness, happiness);
      SetBlackboardValue(_fear, fear);
      SetBlackboardValue(_anger, anger);
      
      // Определяем доминирующую эмоцию
      string dominant = "neutral";
      float maxEmotion = 0.3f;  // Порог для проявления эмоции
      
      if (happiness > maxEmotion && happiness > fear && happiness > anger)
      {
          dominant = "happy";
          maxEmotion = happiness;
      }
      else if (fear > maxEmotion && fear > happiness && fear > anger)
      {
          dominant = "afraid";
          maxEmotion = fear;
      }
      else if (anger > maxEmotion && anger > happiness && anger > fear)
      {
          dominant = "angry";
          maxEmotion = anger;
      }
      
      SetBlackboardValue(_dominantEmotion, dominant);
      
      return Status.Running;  // Этот узел всегда активен
  }
}

public class RoomGenerator : Action
{
  [SerializeField] private BlackboardPropertyName<string> _roomType;
  [SerializeField] private BlackboardPropertyName<float> _difficulty;
  [SerializeField] private BlackboardPropertyName<Vector2Int> _roomSize;
  [SerializeField] private BlackboardPropertyName<GameObject> _generatedRoom;
  
  protected override Status OnUpdate()
  {
      string type = GetBlackboardValue(_roomType);
      float difficulty = GetBlackboardValue(_difficulty);
      Vector2Int size = GetBlackboardValue(_roomSize);
      
      GameObject room = new GameObject($"Room_{type}");
      
      // Генерируем базовую геометрию комнаты
      CreateRoomGeometry(room, size);
      
      // Наполняем комнату в зависимости от типа
      switch (type)
      {
          case "combat":
              PopulateCombatRoom(room, difficulty);
              break;
          case "treasure":
              PopulateTreasureRoom(room, difficulty);
              break;
          case "puzzle":
              PopulatePuzzleRoom(room, difficulty);
              break;
          default:
              PopulateBasicRoom(room);
              break;
      }
      
      SetBlackboardValue(_generatedRoom, room);
      return Status.Success;
  }
  
  private void CreateRoomGeometry(GameObject room, Vector2Int size)
  {
      // Логика создания стен, пола и потолка
      // ...
  }
  
  private void PopulateCombatRoom(GameObject room, float difficulty)
  {
      // Размещение врагов, препятствий и т.д.
      int enemyCount = Mathf.RoundToInt(difficulty * 2) + 1;
      
      for (int i = 0; i < enemyCount; i++)
      {
          // Создаем врага с соответствующей силой
          GameObject enemy = CreateEnemy(difficulty);
          enemy.transform.parent = room.transform;
          // Позиционируем врага
          // ...
      }
  }
  
  private void PopulateTreasureRoom(GameObject room, float difficulty)
  {
      // Размещение сокровищ, ловушек и т.д.
      // ...
  }
  
  private void PopulatePuzzleRoom(GameObject room, float difficulty)
  {
      // Размещение элементов головоломки
      // ...
  }
  
  private void PopulateBasicRoom(GameObject room)
  {
      // Базовое наполнение обычной комнаты
      // ...
  }
  
  private GameObject CreateEnemy(float difficulty)
  {
      // Создание врага соответствующей сложности
      // ...
      return new GameObject("Enemy");
  }
}

public class AdaptiveDifficultyManager : Action
{
  [SerializeField] private BlackboardPropertyName<float> _playerWinRate;
  [SerializeField] private BlackboardPropertyName<float> _aiAggressiveness;
  [SerializeField] private BlackboardPropertyName<float> _aiAccuracy;
  [SerializeField] private BlackboardPropertyName<float> _aiReactionTime;
  
  [SerializeField] private float _targetWinRate = 0.6f;  // Целевой коэффициент побед игрока
  [SerializeField] private float _adjustmentRate = 0.05f;  // Скорость адаптации
  
  protected override Status OnUpdate()
  {
      float currentWinRate = GetBlackboardValue(_playerWinRate);
      
      // Если игрок выигрывает слишком часто, увеличиваем сложность
      if (currentWinRate > _targetWinRate)
      {
          AdjustDifficulty(true);
      }
      // Если игрок проигрывает слишком часто, снижаем сложность
      else if (currentWinRate < _targetWinRate - 0.1f)
      {
          AdjustDifficulty(false);
      }
      
      return Status.Success;
  }
  
  private void AdjustDifficulty(bool increase)
  {
      float adjustmentDirection = increase ? 1f : -1f;
      
      // Корректируем параметры ИИ
      float aggressiveness = GetBlackboardValue(_aiAggressiveness);
      float accuracy = GetBlackboardValue(_aiAccuracy);
      float reactionTime = GetBlackboardValue(_aiReactionTime);
      
      aggressiveness = Mathf.Clamp01(aggressiveness + adjustmentDirection * _adjustmentRate);
      accuracy = Mathf.Clamp01(accuracy + adjustmentDirection * _adjustmentRate);
      reactionTime = Mathf.Clamp(reactionTime - adjustmentDirection * _adjustmentRate * 0.1f, 0.1f, 1f);
      
      SetBlackboardValue(_aiAggressiveness, aggressiveness);
      SetBlackboardValue(_aiAccuracy, accuracy);
      SetBlackboardValue(_aiReactionTime, reactionTime);
  }
}

public class TacticEffectivenessTracker : Action
{
  [Serializable]
  public class TacticData
  {
      public string TacticName;
      public float SuccessRate;
      public int UsageCount;
  }
  
  [SerializeField] private BlackboardPropertyName<string> _currentTactic;
  [SerializeField] private BlackboardPropertyName<bool> _tacticSuccess;
  [SerializeField] private BlackboardPropertyName<string> _recommendedTactic;
  
  // Список тактик и их эффективность
  private List<TacticData> _tactics = new List<TacticData>
  {
      new TacticData { TacticName = "Aggressive", SuccessRate = 0.5f, UsageCount = 1 },
      new TacticData { TacticName = "Defensive", SuccessRate = 0.5f, UsageCount = 1 },
      new TacticData { TacticName = "Flanking", SuccessRate = 0.5f, UsageCount = 1 },
      new TacticData { TacticName = "Ranged", SuccessRate = 0.5f, UsageCount = 1 }
  };
  
  protected override void OnInitialize()
  {
      // Выбираем начальную тактику случайным образом
      int randomIndex = UnityEngine.Random.Range(0, _tactics.Count);
      SetBlackboardValue(_recommendedTactic, _tactics[randomIndex].TacticName);
  }
  
  protected override Status OnUpdate()
  {
      // Проверяем, изменилась ли текущая тактика
      string currentTactic = GetBlackboardValue(_currentTactic);
      string prevTactic = null;
      
      // Если текущая тактика была оценена (успех/неудача)
      if (GetBlackboardValueChanged(_tacticSuccess, out bool success))
      {
          // Обновляем статистику для текущей тактики
          foreach (var tactic in _tactics)
          {
              if (tactic.TacticName == currentTactic)
              {
                  // Обновляем успешность тактики
                  tactic.SuccessRate = (tactic.SuccessRate * tactic.UsageCount + (success ? 1 : 0)) / (tactic.UsageCount + 1);
                  tactic.UsageCount++;
                  break;
              }
          }
          
          // Выбираем новую рекомендуемую тактику на основе их эффективности
          // С вероятностью 80% выбираем лучшую тактику, 20% - случайную (для исследования)
          if (UnityEngine.Random.value < 0.8f)
          {
              // Сортируем тактики по успешности и выбираем лучшую
              var sortedTactics = _tactics.OrderByDescending(t => t.SuccessRate).ToList();
              SetBlackboardValue(_recommendedTactic, sortedTactics[0].TacticName);
          }
          else
          {
              // Случайная тактика для исследования
              int randomIndex = UnityEngine.Random.Range(0, _tactics.Count);
              SetBlackboardValue(_recommendedTactic, _tactics[randomIndex].TacticName);
          }
      }
      
      return Status.Running;  // Этот узел всегда активен
  }
}

// Плохой подход — всё в одном графе
public class GiantMonolithicAI : Action
{
    // Десятки переменных и сотни строк кода
}
 
// Хороший подход — декомпозиция на компоненты
public class PatrolSubgraphController : Action
{
    // Только логика патрулирования
}
 
public class CombatSubgraphController : Action
{
    // Только боевая логика
}

// Потенциально проблемный код
protected override Status OnUpdate()
{
    if (SomeCondition())
        return Status.Running;  // Граф может застрять, если SomeCondition всегда true
    
    return Status.Success;
}
 
// Безопасный вариант с таймаутом
protected override Status OnUpdate()
{
    if (SomeCondition() && Time.time - _startTime < _maxRunningTime)
        return Status.Running;
    
    return SomeCondition() ? Status.Failure : Status.Success;
}

public class CachedPathfinding : Action
{
    [SerializeField] private BlackboardPropertyName<Vector3> _targetPosition;
    [SerializeField] private BlackboardPropertyName<List<Vector3>> _cachedPath;
    [SerializeField] private float _recalculationDistance = 3f;
    
    private Vector3 _lastCalculatedPosition;
    
    protected override Status OnUpdate()
    {
        Vector3 currentTarget = GetBlackboardValue(_targetPosition);
        
        // Пересчитываем путь только если цель существенно переместилась
        if (Vector3.Distance(currentTarget, _lastCalculatedPosition) > _recalculationDistance)
        {
            List<Vector3> newPath = CalculatePath(transform.position, currentTarget);
            SetBlackboardValue(_cachedPath, newPath);
            _lastCalculatedPosition = currentTarget;
        }
        
        return Status.Success;
    }
    
    private List<Vector3> CalculatePath(Vector3 start, Vector3 end)
    {
        // Дорогостоящие расчёты пути
        // ...
        return new List<Vector3>();
    }
}