TH1/Unity/Assets/Scripts/TH1_Logic/AI/BehaviourTree/MainEditor.cs

/*
* @Author: 白哉
* @Description: 
* @Date: 2025年06月18日 星期三 15:06:25
* @Modify: 
*/

using System.Collections.Generic;
using Logic.AI;
using TH1_Logic.Core;
using UnityEngine;

namespace Logic
{
    public class MainEditor
    {
        public bool IsEditor = false;
        public bool IsGo = false;
        public AICalculatorData Data;
        public uint BTNodeId = 0;
        private Dictionary<uint, Strategy> _playerStrategy;
        private Dictionary<uint, HashSet<uint>> _playerAttackTarget;
        private Dictionary<uint, Strategy> _cityStrategy;
        private Dictionary<uint, Strategy> _unitStrategy;
        private Dictionary<uint, Strategy> _legionStrategy;
        private Dictionary<uint, LegionStrategyType> _legionStrategyTypes;
        private Dictionary<uint, FreeUnitStrategyType> _freeUnitStrategyTypes;
        private Dictionary<uint, uint> _unitTarget;
        private Dictionary<uint, List<AIActionBase>> _actionRecord;
        
        
        public static MainEditor Instance = new MainEditor();
        
        public MainEditor()
        {
            _playerStrategy = new Dictionary<uint, Strategy>();
            _playerAttackTarget = new Dictionary<uint, HashSet<uint>>();
            _cityStrategy = new Dictionary<uint, Strategy>();
            _unitStrategy = new Dictionary<uint, Strategy>();
            _legionStrategy = new Dictionary<uint, Strategy>();
            _legionStrategyTypes = new Dictionary<uint, LegionStrategyType>();
            _unitTarget = new Dictionary<uint, uint>();
            _actionRecord = new Dictionary<uint, List<AIActionBase>>();
            _freeUnitStrategyTypes = new Dictionary<uint, FreeUnitStrategyType>();
        }

        public void OnAIStarted()
        {
            _actionRecord.Clear();
        }
        
        public void OnActionExcuted()
        {
            if (Data.MaxAiAction?.Param?.CityData == null) return;
            if (!_actionRecord.ContainsKey(Data.MaxAiAction.Param.CityData.Id))
                _actionRecord[Data.MaxAiAction.Param.CityData.Id] = new List<AIActionBase>();
            _actionRecord[Data.MaxAiAction.Param.CityData.Id].Add(Data.MaxAiAction);
        }

        public List<AIActionBase> GetCityActions(uint cid)
        {
            return _actionRecord.GetValueOrDefault(cid);
        }

        public void GetPlayerStrategy(uint pid, out Strategy strategy, out HashSet<uint> target)
        {
            strategy = Strategy.None;
            _playerStrategy.TryGetValue(pid, out strategy);
            _playerAttackTarget.TryGetValue(pid, out target);
        }

        public void GetUnitStrategy(uint uid, uint legion, uint playerId, out Strategy strategy, out uint cityId, out LegionStrategyType type)
        {
            cityId = 0;
            strategy = Strategy.None;
            type = LegionStrategyType.None;
            _unitTarget.TryGetValue(uid, out cityId);
            if (legion == 0) _unitStrategy.TryGetValue(uid, out strategy);
            else
            {
                _legionStrategy.TryGetValue(legion * 10000 + playerId, out strategy);
                _legionStrategyTypes.TryGetValue(legion * 10000 + playerId, out type);
            }
        }

        public void GetCityStrategy(uint cid, out Strategy strategy)
        {
            strategy = Strategy.None;
            _cityStrategy.TryGetValue(cid, out strategy);
        }
        
        public void Update()
        {
#if UNITY_EDITOR || USE_INPUT
            if (InputTextFocusUtility.IsTextInputFocused()) return;

            if (Input.GetKeyDown(KeyCode.F4))
            {
                foreach (var unit in Main.MapData.UnitMap.UnitList)
                {
                    unit.SetFullActionPoint();
                    unit.Renderer(Main.MapData)?.InstantUpdateUnit(true);
                }
            }
            
            if (Input.GetKeyDown(KeyCode.F10))
            {
                IsEditor = true;
                Debug.LogWarning("F10");
            }
            if (Input.GetKeyDown(KeyCode.F11))
            {
                IsEditor = false;
                Debug.LogWarning("F11");
            }
            if (Input.GetKeyDown(KeyCode.Space))
            {
                IsGo = true;
                Debug.LogWarning("Space");
            }

            if (Data == null) return;
            if (Data.Player == null) return;
            _playerStrategy[Data.Player.Id] = Data.CountryStrategy;
            if (!_playerAttackTarget.ContainsKey(Data.Player.Id))
                _playerAttackTarget[Data.Player.Id] = new HashSet<uint>();
            _playerAttackTarget[Data.Player.Id].Clear();
            foreach (var player in Data.AttackPlayerSet) _playerAttackTarget[Data.Player.Id].Add(player.Id);
            foreach (var kv in Data.CityStrategy) _cityStrategy[kv.Key.Id] = kv.Value;
            foreach (var kv in Data.FreeUnitStrategy) _unitStrategy[kv.Key.Id] = kv.Value;
            foreach (var kv in Data.LegionStrategy) _legionStrategy[kv.Key * 10000 + Data.Player.Id] = kv.Value;
            foreach (var kv in Data.LegionStrategyTypes) _legionStrategyTypes[kv.Key * 10000 + Data.Player.Id] = kv.Value;
            foreach (var kv in Data.FreeUnitStrategyTypes) _freeUnitStrategyTypes[kv.Key] = kv.Value;
            foreach (var kv in Data.UnitTargetCity) _unitTarget[kv.Key] = kv.Value;
#endif
        }
    }

    
    public class StrategyInfo
    {
        public Strategy Strategy;
        public uint TargetCityId;
    }
}