/*
* @Author: 白哉
* @Description: 
* @Date: 2025年04月03日 星期四 11:04:31
* @Modify: 
*/


using System;
using System.Collections.Generic;
using Logic.Action;
using Logic.AI;
using Logic.Audio;
using Logic.Pool;
using MemoryPack;
using NUnit.Framework;
using TH1_Core.Events;
using TH1_Core.Managers;
using TH1_Logic.Core;
using TH1_Logic.HeroTask;
using TH1_Logic.MatchConfig;
using TH1Renderer;
using UnityEngine;


namespace RuntimeData
{
    // 奇观类型枚举
    public enum WonderTypeEnum
    {
        None,
        PEACE,
        KNOWLEDGE,
        TRADE,
        WEALTH,
        POWER,
        PARK,
        EYE
    }

    
    // 奇观状态枚举
    public enum WonderState
    {
        NO_HINT,
        HAVE_HINT,
        FINISH_NOT_BUILD,
        FINISH_BUILD,
        Max
    }
    
    
    // 外交关系枚举
    public enum DiplomacyState
    {
        NoDiplomacy, // 未建交
        Neutral, // 中立的
        League, // 联盟
        War, // 战争
        LeagueRupture, // 联盟破裂
    }
    
    
    // 好感状态枚举
    public enum FeelingState
    {
        Trust,
        Appreciate,
        Indifferent,
        Suspicion,
        Terrible,
    }
    
    
    // 好感策略枚举
    public enum FeelingStrategy
    {
        Wise,
        Charming,
        Peaceful,
        Diplomatic,
        Powerful,
        Brave,
        Violent,
        Threatening,
        Weak,
        Annoying,
        Foolish,
        Intrusive,
        Dominative,
    }

    
    [MemoryPackable]
    public partial class PlayerMapData
    {
        public List<PlayerData> PlayerDataList;
        [MemoryPackIgnore]
        public uint SelfPlayerId;
        [MemoryPackIgnore]
        public PlayerData SelfPlayerData => GetPlayerData(SelfPlayerId);
        private Dictionary<uint, PlayerData> _playerDataDict;


        // 无数据初始化
        [MemoryPackConstructor]
        public PlayerMapData()
        {
            PlayerDataList = new List<PlayerData>();
            _playerDataDict = new Dictionary<uint, PlayerData>();
        }
        
        // 配置初始化
        public PlayerMapData(MapData map, MapIdGenerator idGenerator, NetMode netMode)
        {
            PlayerDataList = new List<PlayerData>();
            _playerDataDict = new Dictionary<uint, PlayerData>();

            if (netMode == NetMode.Single)
            {
                map.MapConfig.EnsurePlayerInfosCount();
                for (int i = 0; i < map.MapConfig.PlayerCount; i++)
                {
                    uint civId = (uint)i;
                    uint forceId = (uint)i;
                    if (map.MapConfig.GetPlayerInfoByIndex((uint)i, out var playerInfo))
                    {
                        civId = playerInfo.CivId;
                        forceId = playerInfo.ForceId;
                    }
                    PlayerData player = new PlayerData(civId, forceId, idGenerator);
                    PlayerDataList.Add(player);
                    _playerDataDict[player.Id] = player;
                }
            }
            if (netMode == NetMode.Multi)
            {
                map.MapConfig.EnsurePlayerInfosCount();
                for (int i = 0; i < map.MapConfig.PlayerCount; i++)
                {
                    uint civId = (uint)i;
                    uint forceId = (uint)i;
                    if (map.MapConfig.GetPlayerInfoByIndex((uint)i, out var playerInfo))
                    {
                        civId = playerInfo.CivId;
                        forceId = playerInfo.ForceId;
                    }
                    var player = new PlayerData(civId, forceId, idGenerator);
                    PlayerDataList.Add(player);
                    _playerDataDict[player.Id] = player;
                }

                foreach (var multiCiv in map.MapConfig.MultiCivs)
                {
                    if (multiCiv.PlayerInfoIndex >= PlayerDataList.Count)
                    {
                        multiCiv.PlayerId = 0;
                        continue;
                    }
                    multiCiv.PlayerId = PlayerDataList[(int)multiCiv.PlayerInfoIndex].Id;
                }
            }
            
            if (netMode == NetMode.Single && map.MapConfig.SelfPlayerInfoIndex < PlayerDataList.Count)
                SelfPlayerId = PlayerDataList[(int)map.MapConfig.SelfPlayerInfoIndex].Id;
            else
                SelfPlayerId = PlayerDataList[0].Id;
            foreach (var self in PlayerDataList)
            {
                foreach (var target in PlayerDataList)
                {
                    if (self.Id == target.Id) continue;
                    self.DiplomacyData.AddCountryDiplomacyInfo(target.Id);
                }
            }
        }
        
        public PlayerMapData(PlayerMapData copyData)
        {
            PlayerDataList = new List<PlayerData>();
            _playerDataDict = new Dictionary<uint, PlayerData>();
            SelfPlayerId = copyData.SelfPlayerId;

            foreach (var copyPlayer in copyData.PlayerDataList)
            {
                var player = new PlayerData(copyPlayer);
                PlayerDataList.Add(player);
                _playerDataDict[player.Id] = player;
            }
        }

        public void DeepCopy(PlayerMapData copyData)
        {
            _playerDataDict.Clear();
            SelfPlayerId = copyData.SelfPlayerId;

            for (int i = 0; i < copyData.PlayerDataList.Count; i++)
            {
                var copyPlayer = copyData.PlayerDataList[i];
                if (i >= PlayerDataList.Count)
                {
                    var player = new PlayerData(copyPlayer);
                    PlayerDataList.Add(player);
                    _playerDataDict[player.Id] = player;
                }
                else
                {
                    PlayerDataList[i].DeepCopy(copyPlayer);
                    _playerDataDict[PlayerDataList[i].Id] = PlayerDataList[i];
                }
            }
            for (int i = PlayerDataList.Count - 1; i >= copyData.PlayerDataList.Count; i--)
            {
                _playerDataDict.Remove(PlayerDataList[i].Id);
                PlayerDataList.RemoveAt(i);
            }
        }

        // 裁剪玩家列表到指定数量（移除末尾多余的玩家）
        public void TrimPlayerCount(int count)
        {
            for (int i = PlayerDataList.Count - 1; i >= count; i--)
            {
                _playerDataDict.Remove(PlayerDataList[i].Id);
                PlayerDataList.RemoveAt(i);
            }
        }

        // MemoryPack 反序列化之后的后处理
        [MemoryPackOnDeserialized]
        public void OnAfterMemoryPackDeserialize()
        {
            _playerDataDict ??= new Dictionary<uint, PlayerData>();
            _playerDataDict.Clear();
            foreach (var player in PlayerDataList) _playerDataDict[player.Id] = player;
        }
        
        // 根据 pid 获取玩家数据
        public bool GetPlayerDataByPlayerID(uint pid, out PlayerData playerData)
        {
            return _playerDataDict.TryGetValue(pid, out playerData);
        }
        
        public PlayerData GetPlayerData(uint id)
        {
            if (_playerDataDict.TryGetValue(id, out var playerData))
            {
                return playerData;
            }
            return null;
        }

        public void OnTurnStart(MapData map, PlayerData player)
        {
            Main.PlayerLogic.StartNextTurn(map, player);
            player.OnTurnStart(map);
        }

        public void OnTurnEnd(MapData map, PlayerData player)
        {
            Main.PlayerLogic.EndThisTurn(map, player);
            player.OnTurnEnd(map);
        }
        
        public int GetMaxPlayerScore() 
        {
            int maxScore = -1;
            foreach (var player in PlayerDataList)
            {
                if (!player.IsSurvival) continue;
                if (player.PlayerScore <= maxScore) continue;
                maxScore = player.PlayerScore;
            }
            return maxScore;
        }
    }

    
    [MemoryPackable]
    public partial class PlayerData : IdentifierBase
    {
        // 文明 id, 阵营 id, 摇篮城市 id
        public uint Turn;
        public CivEnum CivEnum => Table.Instance.TransCivIdToCivEnum(PlayerCivId);
        public ForceEnum ForceEnum => Table.Instance.TransForceIdToForceEnum(PlayerForceId);
        public Empire Empire => new Empire(CivEnum, ForceEnum);
        public uint PlayerCivId;
        public uint PlayerForceId;
        public uint CradleCityId;
        
        // 是否存活
        public bool Alive;
        // 财富总额
        public int PlayerCoin => _playerCoin;
        public int _playerCoin;
        public int PlayerTechPoint => _playerTechPoint;
        public int _playerTechPoint;
        
        //造山点(主要给守矢使用)
        public int PlayerMountainPointUsed;
        //分数
        public int PlayerScore;
        // 视野
        public MapSightData Sight;
        // 科技
        public TechTreeData TechTree;
        // 奇观
        public WonderData Wonder;
        // 外交
        public DiplomacyData DiplomacyData;
        //英雄 
        public PlayerHeroData PlayerHeroData;
        //命名器
        public PlayerNamerData PlayerNamerData;
        
        // 用于记录已经连续几个 turn 没有进行攻击
        public int TurnNoAttack;
        // 用于记录累计击杀多少 unit
        public int TotalKill;
        // 英雄
        private bool _heroDictInit;
        
        
        //记录伟人的累计经验,下标直接从ChessType的Enum对应的uint转过来
        public int[] giantExp = new int[6];
        //记录伟人的复活冷却cd惩罚
        public int[] giantPenalty = new int[6];
        public List<uint> MeetPlayers;
        public List<uint> CurAttackPlayers;
        public List<uint> LastAttackPlayers;
        
        //用于记录是否死亡，是否要centMessage来宣告死亡信息
        public bool DieMark = false;
        //用于记录当前是否正在playing，主要是视觉那边使用
        public bool IsPlaying;
        
        // Moment 
        public MomentData MomentData;
        
        //PlayerCulture
        public PlayerCultureInfo PlayerCultureInfo;
        
        // 是否投降
        public bool IsSurrender;
        // 玩家是否存活要用这条来判断
        public bool IsSurvival => !IsSurrender && Alive;
        
        // 复用的临时集合，避免每回合外交计算GC
        [MemoryPackIgnore] private HashSet<uint> _tmpOriginCityBuf;
        [MemoryPackIgnore] private List<CityData> _tmpCityListBuf;
        [MemoryPackIgnore] private HashSet<CityData> _tmpCitySetBuf;
        [MemoryPackIgnore] private HashSet<uint> _tmpTerritoryGridIdBuf;
        [MemoryPackIgnore] private HashSet<uint> _tmpSelfTerritoryInfluenceGridIdBuf;
        [MemoryPackIgnore] private Dictionary<uint, float> _tmpPlayerMilitaryScoreBuf;
        [MemoryPackIgnore] private Dictionary<uint, List<uint>> _tmpPlayerUnitGridIdListBuf;
        [MemoryPackIgnore] private Dictionary<uint, HashSet<uint>> _tmpPlayerTerritoryGridIdSetBuf;
        [MemoryPackIgnore] private Dictionary<uint, DiplomacyState> _tmpSelfToOtherDiplomacyStateBuf;
        
        // 无参数初始化
        [MemoryPackConstructor]
        public PlayerData()
        {
            Sight = new MapSightData();
            TechTree = new TechTreeData();
            Wonder = new WonderData();
            DiplomacyData = new DiplomacyData();
            MeetPlayers = new List<uint>();
            CurAttackPlayers = new List<uint>();
            LastAttackPlayers = new List<uint>();
            PlayerNamerData = new PlayerNamerData();
            MomentData = new MomentData();
            PlayerCultureInfo = new PlayerCultureInfo();
        }
        
        // 带 ID 初始化
        public PlayerData(uint civId, uint forceId, MapIdGenerator idGenerator)
        {
            Turn = 0;
            Id = idGenerator.GeneratorId();
            if(Table.Instance.PlayerDataAssets.GetPlayerInfoByCivId(civId,forceId,out var info))
                TechTree = new TechTreeData(this, info.TechStart);
            else
                TechTree = new TechTreeData();
            Sight = new MapSightData();
            
            Wonder = new WonderData();
            DiplomacyData = new DiplomacyData();
            PlayerHeroData = new PlayerHeroData();
            CurAttackPlayers = new List<uint>();
            LastAttackPlayers = new List<uint>();
            PlayerNamerData = new PlayerNamerData();
            MomentData = new MomentData();
            MomentData.InitItems();
            PlayerCultureInfo = new PlayerCultureInfo();
            MeetPlayers = new List<uint>();
            MeetPlayers.Add(Id);
            InitData(civId,forceId);
        }

        public PlayerData(PlayerData copyData)
        {
            Turn = copyData.Turn;
            Id = copyData.Id;
            PlayerCivId = copyData.PlayerCivId;
            PlayerForceId = copyData.PlayerForceId;
            CradleCityId = copyData.CradleCityId;
            Alive = copyData.Alive;
            IsSurrender = copyData.IsSurrender;
            _playerCoin = copyData._playerCoin;
            _playerTechPoint = copyData._playerTechPoint;
            PlayerMountainPointUsed =  copyData.PlayerMountainPointUsed;
            
            Sight = new MapSightData(copyData.Sight);
            TechTree = new TechTreeData(copyData.TechTree);
            Wonder = new WonderData(copyData.Wonder);
            DiplomacyData = new DiplomacyData(copyData.DiplomacyData);
            PlayerHeroData = new PlayerHeroData(copyData.PlayerHeroData);
            PlayerNamerData = new PlayerNamerData(copyData.PlayerNamerData);
            MomentData = new MomentData(copyData.MomentData);
            PlayerCultureInfo = new PlayerCultureInfo(copyData.PlayerCultureInfo);
            
            CurAttackPlayers = new List<uint>();
            foreach (var id in copyData.CurAttackPlayers) CurAttackPlayers.Add(id);
            LastAttackPlayers = new List<uint>();
            foreach (var id in copyData.LastAttackPlayers) LastAttackPlayers.Add(id);
            
            MeetPlayers = new List<uint>();
            foreach (var id in copyData.MeetPlayers) MeetPlayers.Add(id);
            
            TurnNoAttack = copyData.TurnNoAttack;
            TotalKill = copyData.TotalKill;
            
            foreach (var skill in copyData.Skills) Skills.Add(skill.GetCopySkill());
            //拷贝giantExp和giantPenalty
            for (int i = 0; i < 6; i++)
            {
                giantExp[i] = copyData.giantExp[i];
                giantPenalty[i] = copyData.giantPenalty[i];
            }
        }

        public void DeepCopy(PlayerData copyData)
        {
            Turn = copyData.Turn;
            Id = copyData.Id;
            PlayerCivId = copyData.PlayerCivId;
            PlayerForceId = copyData.PlayerForceId;
            CradleCityId = copyData.CradleCityId;
            Alive = copyData.Alive;
            IsSurrender = copyData.IsSurrender;
            _playerCoin = copyData._playerCoin;
            _playerTechPoint = copyData._playerTechPoint;
            PlayerMountainPointUsed = copyData.PlayerMountainPointUsed;
            
            Sight.DeepCopy(copyData.Sight);
            TechTree.DeepCopy(copyData.TechTree);
            Wonder.DeepCopy(copyData.Wonder);
            DiplomacyData.DeepCopy(copyData.DiplomacyData);
            PlayerHeroData.DeepCopy(copyData.PlayerHeroData);
            PlayerNamerData.DeepCopy(copyData.PlayerNamerData);
            MomentData.DeepCopy(copyData.MomentData);
            PlayerCultureInfo.DeepCopy(copyData.PlayerCultureInfo);
            
            CurAttackPlayers.Clear();
            foreach (var id in copyData.CurAttackPlayers) CurAttackPlayers.Add(id);
            LastAttackPlayers.Clear();
            foreach (var id in copyData.LastAttackPlayers) LastAttackPlayers.Add(id);
            MeetPlayers.Clear();
            foreach (var id in copyData.MeetPlayers) MeetPlayers.Add(id);

            TurnNoAttack = copyData.TurnNoAttack;
            TotalKill = copyData.TotalKill;
            
            Skills.Clear();
            foreach (var skill in copyData.Skills) Skills.Add(skill.GetCopySkill());
            for (int i = 0; i < 6; i++)
            {
                giantExp[i] = copyData.giantExp[i];
                giantPenalty[i] = copyData.giantPenalty[i];
            }
        }
        
        private void InitData(uint civId,uint forceId)
        {
            Alive = true;
            IsSurrender = false;
            _playerCoin = 5;
            if (civId == 2) _playerCoin = 7;
            PlayerCivId = civId;
            PlayerForceId = forceId;
            _playerTechPoint = 0;
            PlayerMountainPointUsed = 0;
            TurnNoAttack = 0;
            TotalKill = 0;
            PlayerHeroData.Init(Table.Instance.TransCivIdToCivEnum(civId) ,Table.Instance.TransForceIdToForceEnum(forceId));
            PlayerNamerData.Init(Table.Instance.TransCivIdToCivEnum(civId));
        }
        
        // 全局通知调用
        public void OnTurnStart(MapData map)
        {
            Turn++;
            //减少1点伟人复活冷却的时间点
            for (int i = 0; i < 6; i++)
                if (giantPenalty[i] > 0) giantPenalty[i]--;
            LastAttackPlayers.Clear(); 
            foreach (var id in CurAttackPlayers) LastAttackPlayers.Add(id);
            CurAttackPlayers.Clear();
            OnSkillsTurnStart(map);

            // 这里是英雄的生命周期，先放在这里
            PlayerHeroData.OnTurnStart(map, this);
            foreach (var item in MomentData.Items) item.OnTurnStart();
            IsPlaying = true;
            
            //更新所有单位的视觉状态 TODO 之后依赖大回合的逻辑处理
            foreach (var unit in map.UnitMap.UnitList)
                unit.Renderer(map)?.InstantUpdateUnit(true);

        }

        public void OnTurnEnd(MapData map)
        {
            OnSkillsTurnEnd(map);
            foreach (var player in map.PlayerMap.PlayerDataList)
            {
                if (player.Id == Id) continue;
                this.GetCountryDiplomacyInfo(player.Id, out var selfToPlayer);
                // 回合结束处理联盟破裂标记
                if (selfToPlayer.DiplomacyState == DiplomacyState.LeagueRupture) selfToPlayer.IsLeagueRupture = true;
                // 回合结束处理AI 冷静期计数
                if (selfToPlayer.IsCalm > 0) selfToPlayer.IsCalm--;
            }
            IsPlaying = false;
        }
        
        public bool IsSelfPlayer()
        {
            return Main.MapData.PlayerMap.SelfPlayerData == this;
        }
        // 添加当前回合攻击者
        public void AddAttacker(uint playerId)
        {
            this.AddTurnAttacker(playerId, Turn);
        }

        public CivEnum Civ()
        {
            return Table.Instance.TransCivIdToCivEnum(PlayerCivId);
        }

        public void AddTechPoint(int tech)
        {
            _playerTechPoint += tech;
            //foreach (var kv in PlayerHeroData.HeroTaskDict) kv.Value.OnAddCoin((uint)coin);
            EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateTech });
            
        }

        public void AddCulturePoint(int culture)
        {
             PlayerCultureInfo.PlayerCulture += culture;
             EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateCulture });
        }
        
        //增加金币(目前处理了逻辑和动画 TODO 现在还是逻辑和动画没有分开，后续还是要分开 
        public void AddCoin(int coin, Vector3 startPos)
        {
            _playerCoin += coin;
            foreach (var kv in PlayerHeroData.HeroTaskDict) kv.Value.OnAddCoin((uint)coin);
            //如果加钱的是真人自己玩家，并且有金币来源位置，那么播动画
            if (Main.MapData.PlayerMap.SelfPlayerData == this)
            {
                EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateCoin });
                MapRenderer.Instance.ProjectileManager.CreateCoinProjectile(startPos,coin);
                AudioManager.Instance.PlayAudio("SFX/PLAYER_coin");
                //真人自己玩家，提前检查财富奇观，方便弹出提示
                Main.PlayerLogic.UpdateWonder(Main.MapData,Main.MapData.PlayerMap.SelfPlayerData,WonderTypeEnum.WEALTH);
            }
        }
        
        public void AddCoin_ViewOnly(int coin, Vector3 startPos)
        {
            if (Main.MapData.PlayerMap.SelfPlayerData == this)
            {
                EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateCoin });
                MapRenderer.Instance.ProjectileManager.CreateCoinProjectile(startPos,coin);
                AudioManager.Instance.PlayAudio("SFX/PLAYER_coin");
                //真人自己玩家，提前检查财富奇观，方便弹出提示
                Main.PlayerLogic.UpdateWonder(Main.MapData,Main.MapData.PlayerMap.SelfPlayerData,WonderTypeEnum.WEALTH);
            }
        }

        public void AddCoin_LogicOnly(int coin)
        {
            _playerCoin += coin;
            foreach (var kv in PlayerHeroData.HeroTaskDict) kv.Value.OnAddCoin((uint)coin);
        }


        public void AddCoin(int coin,GridData grid = null)
        {
            _playerCoin += coin;
            
            foreach (var kv in PlayerHeroData.HeroTaskDict) kv.Value.OnAddCoin((uint)coin);
            //如果加钱的是真人自己玩家，并且有金币来源位置，那么播动画。暂时用legacy方案
            if (Main.MapData.PlayerMap.SelfPlayerData == this && grid != null)
            {
                EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateCoin });
                var startPos = Table.Instance.GridToWorld(grid);
                MapRenderer.Instance.ProjectileManager.CreateCoinProjectile(startPos,coin);
                AudioManager.Instance.PlayAudio("SFX/PLAYER_coin");
                //真人自己玩家，提前检查财富奇观，方便弹出提示
                Main.PlayerLogic.UpdateWonder(Main.MapData,Main.MapData.PlayerMap.SelfPlayerData,WonderTypeEnum.WEALTH);
            }
            
            
        }

        public void SpendCoin(int coin, GridData grid = null)
        {
            _playerCoin -= coin;
            EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateCoin });
        }

        public void SpendTechPoint(int tech)
        {
            _playerTechPoint -= tech;
            EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateTech });
        }
        
        //增加faith的动画目前处理了逻辑和动画 TODO  现在还是逻辑和动画没有分开，后续还是要分开 
        
        public void AddFaith(int faith,Vector3 startPos)
        {
            
            //如果加钱的是真人自己玩家，并且有金币来源位置
            if (Main.MapData.PlayerMap.SelfPlayerData == this)
            {
                EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateFaith });
                MapRenderer.Instance.ProjectileManager.CreateProjectileFaith(startPos,faith);
            }
        }
        
        public void AddFaith(int faith,GridData grid = null)
        {
            //如果加钱的是真人自己玩家，并且有金币来源位置
            if (Main.MapData.PlayerMap.SelfPlayerData == this && grid != null)
            {
                EventManager.Publish(new UpdateUITopTopBar() { UpdateType = UpdateTopBarType.UpdateFaith });
                var startPos = Table.Instance.GridToWorld(grid);
                MapRenderer.Instance.ProjectileManager.CreateProjectileFaith(startPos,faith);
            }
        }
        
        // 检查前几回合内是否有攻击者
        public bool CheckTurnsAttacker(uint turns, uint playerId)
        {
            if (turns >= Turn) turns = Turn;
            return this.CheckTurnAttacker(playerId, Turn - turns);
        }
        
        // 刷新对他国好感值
        public void RefreshFeelingValue(MapData map)
        {
            var playerDataList = map.PlayerMap.PlayerDataList;
            int maxScore = -1;
            uint maxScorePlayer = 0;
            _tmpOriginCityBuf ??= new HashSet<uint>();
            _tmpOriginCityBuf.Clear();
            foreach (var player in playerDataList)
            {
                _tmpOriginCityBuf.Add(player.CradleCityId);
                if (!player.IsSurvival) continue;
                if (player.PlayerScore <= maxScore) continue;
                maxScore = player.PlayerScore;
                maxScorePlayer = player.Id;
            }
            var originCityHalfCount = _tmpOriginCityBuf.Count * 0.5f;
            
            _tmpTerritoryGridIdBuf ??= new HashSet<uint>();
            _tmpSelfTerritoryInfluenceGridIdBuf ??= new HashSet<uint>();
            _tmpPlayerMilitaryScoreBuf ??= new Dictionary<uint, float>();
            _tmpPlayerUnitGridIdListBuf ??= new Dictionary<uint, List<uint>>();
            _tmpPlayerTerritoryGridIdSetBuf ??= new Dictionary<uint, HashSet<uint>>();
            _tmpSelfToOtherDiplomacyStateBuf ??= new Dictionary<uint, DiplomacyState>();
            _tmpPlayerMilitaryScoreBuf.Clear();
            _tmpSelfToOtherDiplomacyStateBuf.Clear();
            foreach (var kv in _tmpPlayerUnitGridIdListBuf)
            {
                kv.Value.Clear();
            }
            foreach (var kv in _tmpPlayerTerritoryGridIdSetBuf)
            {
                kv.Value.Clear();
            }
            foreach (var unit in map.UnitMap.UnitList)
            {
                if (!map.GetPlayerIdByUnitId(unit.Id, out var ownerId)) continue;
                _tmpPlayerMilitaryScoreBuf[ownerId] = _tmpPlayerMilitaryScoreBuf.GetValueOrDefault(ownerId) + unit.GetMilitary();
                if (!map.GetGridDataByUnitId(unit.Id, out var unitGrid)) continue;
                if (!_tmpPlayerUnitGridIdListBuf.TryGetValue(ownerId, out var unitGridIdList))
                {
                    unitGridIdList = new List<uint>();
                    _tmpPlayerUnitGridIdListBuf[ownerId] = unitGridIdList;
                }
                unitGridIdList.Add(unitGrid.Id);
            }
            var selfScore = _tmpPlayerMilitaryScoreBuf.GetValueOrDefault(Id);

            _tmpTerritoryGridIdBuf.Clear();
            map.GetPlayerTerritoryGridIdSet(Id, _tmpTerritoryGridIdBuf);
            _tmpSelfTerritoryInfluenceGridIdBuf.Clear();
            foreach (var selfGridId in _tmpTerritoryGridIdBuf)
            {
                if (!map.GridMap.GetGridDataByGid(selfGridId, out var selfGrid)) continue;
                for (int x = selfGrid.Pos.X - 1; x <= selfGrid.Pos.X + 1; x++)
                {
                    for (int y = selfGrid.Pos.Y - 1; y <= selfGrid.Pos.Y + 1; y++)
                    {
                        if (!map.GridMap.GetGridDataByPos(x, y, out var aroundGrid)) continue;
                        _tmpSelfTerritoryInfluenceGridIdBuf.Add(aroundGrid.Id);
                    }
                }
            }
            foreach (var player in playerDataList)
            {
                if (!player.IsSurvival) continue;
                if (!_tmpPlayerTerritoryGridIdSetBuf.TryGetValue(player.Id, out var territorySet))
                {
                    territorySet = new HashSet<uint>();
                    _tmpPlayerTerritoryGridIdSetBuf[player.Id] = territorySet;
                }

                if (player.Id == Id)
                {
                    foreach (var gid in _tmpTerritoryGridIdBuf) territorySet.Add(gid);
                }
                else
                {
                    map.GetPlayerTerritoryGridIdSet(player.Id, territorySet);
                }
            }
            foreach (var player in playerDataList)
            {
                if (player.Id == Id) continue;
                this.GetCountryDiplomacyInfo(player.Id, out var selfToOtherPlayer);
                if (selfToOtherPlayer == null) continue;
                _tmpSelfToOtherDiplomacyStateBuf[player.Id] = selfToOtherPlayer.DiplomacyState;
            }

            var aiDiff = map.MapConfig.AIDiff;
            var selfIsAi = map.CheckIsAI(Id);

            foreach (var player in playerDataList)
            {
                if (!player.IsSurvival) continue;
                if (player.Id == Id) continue;
                this.GetCountryDiplomacyInfo(player.Id, out var selfToPlayer);
                player.GetCountryDiplomacyInfo(Id, out var playerToSelf);
                selfToPlayer.FeelingStrategyList.Clear();
                if (playerToSelf == null || selfToPlayer == null) continue;
                var score = 50f;
                
                // 明智的 愚蠢的
                var score1 = 0f;
                foreach (var otherPlayer in playerDataList)
                {
                    if (!player.IsSurvival) continue;
                    if (otherPlayer.Id == Id || otherPlayer.Id == player.Id) continue;
                    if (!_tmpSelfToOtherDiplomacyStateBuf.TryGetValue(otherPlayer.Id, out var selfToOtherPlayerState)) continue;
                    if (selfToOtherPlayerState == DiplomacyState.NoDiplomacy) continue;
                    player.GetCountryDiplomacyInfo(otherPlayer.Id, out var playerToOtherPlayer);
                    if (playerToOtherPlayer.DiplomacyState == DiplomacyState.NoDiplomacy) continue;

                    if (selfToOtherPlayerState == playerToOtherPlayer.DiplomacyState) score1 += 5;
                    else score1 -= 5;
                }
                if (score1> 0)
                {
                    score1 += 5;
                    score += Mathf.Min(20, score1);
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Wise);
                }
                if (score1 < 0)
                {
                    score1 -= 5;
                    score += Mathf.Max(-20, score1);
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Foolish);
                }

                // 迷人的 恼人的
                if (aiDiff == AIDifficult.EASY && map.CheckIsRealPlayer(player.Id) && selfIsAi)
                {
                    score += 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Charming);
                }

                if (aiDiff == AIDifficult.LUNATIC && map.CheckIsRealPlayer(player.Id) && selfIsAi)
                {
                    score -= 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Annoying);
                }

                // 和平的 暴力的
                if (!CheckTurnsAttacker(3, player.Id))
                {
                    score += 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Peaceful);
                }
                else
                {
                    score -= 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Violent);
                }

                // 外交的
                if (selfToPlayer.IsEmbassy || playerToSelf.IsEmbassy)
                {
                    score += 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Diplomatic);
                }

                // A的军事分>B 强大的  A的军事分<B弱小的
                var playerScore2 = _tmpPlayerMilitaryScoreBuf.GetValueOrDefault(player.Id);
                if (selfScore < playerScore2)
                {
                    score += 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Powerful);
                }
                if (selfScore > playerScore2)
                {
                    score -= 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Weak);
                }

                // 勇敢的
                if (maxScorePlayer != Id)
                {
                    player.GetCountryDiplomacyInfo(maxScorePlayer, out var playerToMaxScorePlayer);
                    if (playerToMaxScorePlayer != null && playerToMaxScorePlayer.DiplomacyState == DiplomacyState.War)
                    {
                        score += 15;
                        selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Brave);
                    }
                }
                
                // 威胁的
                if (_tmpPlayerUnitGridIdListBuf.TryGetValue(player.Id, out var enemyUnitGridIdList) &&
                    HasAnyOverlap(_tmpSelfTerritoryInfluenceGridIdBuf, enemyUnitGridIdList))
                {
                    score -= 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Threatening);
                }
                
                // 侵略的  A和B的领土边界相邻，则持有该观点
                if (_tmpPlayerTerritoryGridIdSetBuf.TryGetValue(player.Id, out var playerTerritorySet) &&
                    HasAnyOverlap(_tmpSelfTerritoryInfluenceGridIdBuf, playerTerritorySet))
                {
                    score -= 15;
                    selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Intrusive);
                }
                
                // 主宰的
                var count = 0f;
                if (maxScorePlayer == player.Id)
                {
                    _tmpCityListBuf ??= new List<CityData>();
                    _tmpCityListBuf.Clear();
                    map.GetCityDataListByPlayerId(player.Id, _tmpCityListBuf);
                    foreach (var city in _tmpCityListBuf)
                    {
                        if (_tmpOriginCityBuf.Contains(city.Id)) count++;
                    }

                    if (count >= originCityHalfCount)
                    {
                        score -= 15;
                        selfToPlayer.FeelingStrategyList.Add(FeelingStrategy.Dominative);
                    }
                }

                score = Mathf.Max(0, score);
                selfToPlayer.FeelingValue = score;
                if (score <= 10) selfToPlayer.FeelingState = FeelingState.Terrible;
                else if (score <= 30) selfToPlayer.FeelingState = FeelingState.Suspicion;
                else if (score <= 60) selfToPlayer.FeelingState = FeelingState.Indifferent;
                else if (score <= 85) selfToPlayer.FeelingState = FeelingState.Appreciate;
                else if (score <= 100) selfToPlayer.FeelingState = FeelingState.Trust;
            }
        }

        private bool HasAnyOverlap(HashSet<uint> targetSet, List<uint> sourceList)
        {
            foreach (var id in sourceList)
            {
                if (targetSet.Contains(id)) return true;
            }

            return false;
        }

        private bool HasAnyOverlap(HashSet<uint> setA, HashSet<uint> setB)
        {
            if (setA.Count == 0 || setB.Count == 0) return false;
            var source = setA.Count <= setB.Count ? setA : setB;
            var target = source == setA ? setB : setA;
            foreach (var gridId in source)
            {
                if (target.Contains(gridId)) return true;
            }

            return false;
        }
        
        // 刷新对他国的外交关系，回合开始时调用
        public void RefreshDiplomacyState(MapData map)
        {
            foreach (var player in map.PlayerMap.PlayerDataList)
            {
                if (!player.IsSurvival) continue;
                if (player.Id == Id) continue;
                this.GetCountryDiplomacyInfo(player.Id, out var selfToPlayer);
                player.GetCountryDiplomacyInfo(Id, out var playerToSelf);
                // 如果没有外交关系，且没有见过面，则设置为无外交关系
                if (!MeetPlayers.Contains(player.Id)) selfToPlayer.DiplomacyState = DiplomacyState.NoDiplomacy;
                // 如果没有外交关系，且见过面，则设置为中立
                else if (selfToPlayer.DiplomacyState == DiplomacyState.NoDiplomacy) 
                    selfToPlayer.DiplomacyState = DiplomacyState.Neutral;
                // 如果上一回合回合内双方未发生战斗，则该回合开始时变为中立关系
                //判断有没有对方单位站在我方city上
                bool otherPlayerOnSelfCity = false;
                _tmpCitySetBuf ??= new HashSet<CityData>();
                _tmpCitySetBuf.Clear();
                map.GetCityDataListByPlayerId(Id,_tmpCitySetBuf);
                foreach (var city in _tmpCitySetBuf)
                {
                    if(!map.GetGridDataByCityId(city.Id,out var grid))continue;
                    if(!map.GetUnitDataByGid_Core(grid.Id,out var unit))continue;
                    if(!map.GetPlayerDataByUnitId(unit.Id,out var tPlayer))continue;
                    if (tPlayer.Id == player.Id)
                    {
                        otherPlayerOnSelfCity = true;
                        break;
                    }
                }
                if (selfToPlayer.DiplomacyState == DiplomacyState.War && !LastAttackPlayers.Contains(player.Id) && !otherPlayerOnSelfCity)
                    selfToPlayer.DiplomacyState = DiplomacyState.Neutral;
                // 联盟破裂转中立
                if (selfToPlayer.DiplomacyState == DiplomacyState.LeagueRupture &&
                    playerToSelf.DiplomacyState == DiplomacyState.LeagueRupture &&
                    selfToPlayer.IsLeagueRupture && playerToSelf.IsLeagueRupture)
                {
                    selfToPlayer.DiplomacyState = DiplomacyState.Neutral;
                    playerToSelf.DiplomacyState = DiplomacyState.Neutral;
                    selfToPlayer.IsLeagueRupture = false;
                    playerToSelf.IsLeagueRupture = false;
                }
            }
        }
     
        public int GetTechCost(TechInfo techInfo)
        {
            return Main.MapData.GetCityCount(Id) * techInfo.CostLevel + 4;
        }
        
        //判断该玩家能否"显示"某个资源，如metal,crop,starfish
        public bool CanShowResource(ResourceType resource)
        {
            if (resource is ResourceType.Metal)
                return TechTree.CheckIfHasTechAtom(TechAtom.UnitSkillMOUNTAINMOVE)
                       || TechTree.CheckIfHasTechAtom(TechAtom.BuildMine)
                       || TechTree.CheckIfHasTechAtom(TechAtom.BuildForge);
            
            if (resource is ResourceType.Starfish)
                return TechTree.CheckIfHasTechAtom(TechAtom.UnitSkillOCEANMOVE)
                       || TechTree.CheckIfHasTechAtom(TechAtom.UnitActionGather);

            if (resource is ResourceType.Crop)
                return TechTree.CheckIfHasTechAtom(TechAtom.BuildFarm)
                       || TechTree.CheckIfHasTechAtom(TechAtom.GainFruit);
            return true;
        }
        
        //获取英雄相关所有消耗折扣
        public float GetHeroCostDiscount(MapData mapData, out float discount)
        {
            discount = 1;
            foreach (var card in PlayerCultureInfo.CardList)
            {
                var cardDiscount = card.GetHeroCostDiscount(mapData, this);
                if (cardDiscount < discount) discount = cardDiscount;
            }
            return discount;
        }

        // 是否可以用文化值购买巨人
        public virtual bool CanBuyBigGuyWithCulture(MapData mapData)
        {
            foreach (var card in PlayerCultureInfo.CardList)
            {
                if (card.CanBuyBigGuyWithCulture(mapData, this)) return true;
            }

            return false;
        }

        // 文化值是否能转换成金币
        public virtual bool CanConvertCultureToGold(MapData mapData)
        {
            foreach (var card in PlayerCultureInfo.CardList)
            {
                if (card.CanConvertCultureToGold(mapData, this)) return true;
            }

            return false;
        }
        
        // 检查是否开启了对应 Temple Resource
        public bool CheckResourceOpen(MapData mapData, ResourceType resourceType)
        {
            foreach (var card in PlayerCultureInfo.CardList)
            {
                if (card.CheckResourceOpen(mapData, this, resourceType)) return true;
            }
            return false;
        }

        // 投降
        public void Surrender(MapData map)
        {
            // 退出前解除所有盟友/刚背盟关系：League / LeagueRupture → Neutral
            // LeagueRupture 自动转 Neutral 依赖双方都跑 OnTurnEnd 标 IsLeagueRupture，投降后该标记永远凑不齐 → 必须主动清
            foreach (var otherPlayer in map.PlayerMap.PlayerDataList)
            {
                if (otherPlayer.Id == Id) continue;
                if (!this.GetCountryDiplomacyInfo(otherPlayer.Id, out var selfToOther)) continue;
                if (selfToOther.DiplomacyState != DiplomacyState.League
                    && selfToOther.DiplomacyState != DiplomacyState.LeagueRupture) continue;

                Main.PlayerLogic.SetDiplomacyLeague(map, this, otherPlayer, DiplomacyState.Neutral);
                selfToOther.IsEmbassy = false;
                selfToOther.IsLeagueRupture = false;
                if (otherPlayer.GetCountryDiplomacyInfo(Id, out var otherToSelf))
                {
                    otherToSelf.IsEmbassy = false;
                    otherToSelf.IsLeagueRupture = false;
                }
            }

            IsSurrender = true;
            using var pooledSelfUnits = THCollectionPool.GetHashSetHandle<UnitData>(out var selfUnits);
            map.GetUnitDataListByPlayerId(Id, selfUnits);
            // 先播放Fog特效并销毁渲染层，再清除数据层
            foreach (var unit in selfUnits)
            {
                unit.Grid(map)?.Renderer(map)?.PlayVFXInSight(new GridVFXParams(GridVFXType.Fog));
                unit.Renderer(map)?.Die();
            }
            foreach (var unit in selfUnits) Main.UnitLogic.UnitUnnaturalDie(map, unit);
        }
    }
    
    
    // 奇观信息
    [MemoryPackable]
    public partial class WonderData
    {
        // 所有奇观信息
        public Dictionary<WonderTypeEnum, WonderState> WonderInfoDict;
        public HashSet<WonderTypeEnum> WonderRenderMark;

        
        [MemoryPackConstructor]
        public WonderData()
        {
            WonderInfoDict = new Dictionary<WonderTypeEnum, WonderState>();
            WonderRenderMark = new HashSet<WonderTypeEnum>();
            foreach (WonderTypeEnum wonderType in System.Enum.GetValues(typeof(WonderTypeEnum)))
                WonderInfoDict[wonderType] = WonderState.NO_HINT;
        }
        
        public WonderData(WonderData copyData)
        {
            WonderInfoDict = new Dictionary<WonderTypeEnum, WonderState>(copyData.WonderInfoDict);
            WonderRenderMark = new HashSet<WonderTypeEnum>(copyData.WonderRenderMark);
            foreach (var kv in copyData.WonderInfoDict)
            {
                WonderInfoDict[kv.Key] = kv.Value;
            }

            foreach (var typeEnum in copyData.WonderRenderMark) WonderRenderMark.Add(typeEnum);
        }
        
        public void DeepCopy(WonderData copyData)
        {
            WonderInfoDict.Clear();
            WonderRenderMark.Clear();
            foreach (var kv in copyData.WonderInfoDict) WonderInfoDict[kv.Key] = kv.Value;
            foreach (var typeEnum in copyData.WonderRenderMark) WonderRenderMark.Add(typeEnum);
        }

        // 获取某个奇观的状态
        public WonderState GetWonderState(WonderTypeEnum wonderType)
        {
            if (WonderInfoDict.TryGetValue(wonderType, out var state))
            {
                return state;
            }
            return WonderState.NO_HINT;
        }

        public void SetWonderState(WonderTypeEnum wonderType, WonderState state)
        {
            WonderInfoDict[wonderType] = state;
            WonderRenderMark.Add(wonderType);
        }
        // 判断某个奇观是否变动
        public bool IsWonderRenderMark(WonderTypeEnum wonderType)
        {
            return WonderRenderMark.Contains(wonderType);
        }
        
        public bool IsWonderLibraryBuilt(WonderLibrary wonderLibrary,PlayerData player)
        {
            var empire = new Empire(player.CivEnum, player.ForceEnum);
            foreach (WonderTypeEnum wonderType in Enum.GetValues(typeof(WonderTypeEnum)))
                if (Table.Instance.LibraryDataAssets.GetLibraryInfoByWonder(empire, wonderType, out var info)
                    && info.WonderLibraryID == wonderLibrary
                    && WonderInfoDict.TryGetValue(wonderType, out var v) && v == WonderState.FINISH_BUILD)
                    return true;
            return false;
        }
    }


    // 视野信息
    [MemoryPackable]
    public partial class MapSightData
    {
        public HashSet<uint> SightGidSet;

        
        [MemoryPackConstructor]
        public MapSightData()
        {
            SightGidSet = new HashSet<uint>();
        }
        
        public MapSightData(MapSightData copyData)
        {
            SightGidSet = new HashSet<uint>(copyData.SightGidSet);
        }
        
        public void DeepCopy(MapSightData copyData)
        {
            SightGidSet.Clear();
            foreach (var gid in copyData.SightGidSet) SightGidSet.Add(gid);
        }
        
        // 判断是否在视野内
        public bool CheckIsInSight(uint gid)
        {
            return SightGidSet.Contains(gid);
        }
        
        //更新unit移动路径上的视野 便捷版 unit在gridpos上 更新视野
        public bool UpdateSightByPath(UnitData unit,PlayerData player,Vector2Int pos,MapData map)
        {
            if (!map.GridMap.GetGridDataByPos(pos.x, pos.y, out var grid))
            {
                Debug.Log("错误!UpdateSightByPath 时无法通过x,y获得grid");
                return false;
            }
            var range = unit?.GetSightRange(map,grid) ?? 1;
            var list = map.GridMap.GetAroundGridIdList(range,grid);
            var count = Main.PlayerLogic.UpdateSight_LogicView(map, player, list);
            unit.HeroTask(map)?.OnExploredGrids(map, unit, count);
            foreach (var kv in player.PlayerHeroData.HeroTaskDict) kv.Value.OnAnyExploredGrids(map, unit, count);
            return true;
        }
    }
    
    
    // 科技信息
    [MemoryPackable]
    public partial class TechTreeData
    {
        public HashSet<TechType> TechSet;
        [MemoryPackIgnore] public HashSet<uint> TechAtomActionCacheSet;
        [MemoryPackIgnore] public HashSet<TechAtom> TechAtomCacheSet;

        
        [MemoryPackConstructor]
        public TechTreeData()
        {
            TechSet = new HashSet<TechType>();
            TechAtomActionCacheSet = new HashSet<uint>();
            TechAtomCacheSet = new HashSet<TechAtom>();
        }

        public TechTreeData(PlayerData player, List<TechType> startTechList = null)
        {
            TechSet = new HashSet<TechType>();
            TechAtomActionCacheSet = new HashSet<uint>();
            TechAtomCacheSet = new HashSet<TechAtom>();
            if (startTechList != null)
            {
                foreach(var t in startTechList) LearnTech(t, player);
            }
        }
        
        public TechTreeData(TechTreeData copyData)
        {
            TechSet = new HashSet<TechType>(copyData.TechSet);
            TechAtomActionCacheSet = new HashSet<uint>(copyData.TechAtomActionCacheSet);
            TechAtomCacheSet = new HashSet<TechAtom>(copyData.TechAtomCacheSet);
        }
        
        // MemoryPack 反序列化之后的后处理
        [MemoryPackOnDeserialized]
        public void OnAfterMemoryPackDeserialize()
        {
            TechAtomActionCacheSet ??= new HashSet<uint>();
            foreach (var tech in TechSet)
            {
                var techInfo = Table.Instance.TechDataAssets.GetTechInfo(tech);
                foreach (var techAtom in techInfo.TechAtomList)
                {
                    TechAtomCacheSet.Add(techAtom);
                    if (!Table.Instance.TechDataAssets.GetTechAtomInfo(techAtom, out var info)) continue;
                    if(info.EnableAction)
                        foreach(var t in info.TechActions)
                            TechAtomActionCacheSet.Add(t.Id);
                }
                    
            }
        }
        
        public void DeepCopy(TechTreeData copyData)
        {
            TechSet.Clear();
            TechAtomActionCacheSet.Clear();
            foreach (var tech in copyData.TechSet) TechSet.Add(tech);
            foreach (var act in copyData.TechAtomActionCacheSet) TechAtomActionCacheSet.Add(act);
            foreach (var atom in copyData.TechAtomCacheSet) TechAtomCacheSet.Add(atom);
        }

        public void LearnTech(TechType techType, PlayerData player)
        {
            if (!TechSet.Add(techType)) return;

            if (player.PlayerHeroData != null)
            {
                foreach (var kv in player.PlayerHeroData.HeroTaskDict) 
                    kv.Value.OnTechGet(player);
            }
            var techInfo = Table.Instance.TechDataAssets.GetTechInfo(techType);
            foreach (var techAtom in techInfo.TechAtomList)
            {
                TechAtomCacheSet.Add(techAtom);
                if (!Table.Instance.TechDataAssets.GetTechAtomInfo(techAtom, out var info)) continue;
                if(info.EnableAction)
                    foreach(var t in info.TechActions)
                        TechAtomActionCacheSet.Add(t.Id);
            }
        }
        
        // 删除科技
        public void RemoveTech(TechType techType)
        {
            TechSet.Remove(techType);
        }

        // 是否拥有某个科技
        public bool CheckIfHasTech(TechType techType) { return TechSet.Contains(techType); }

        public bool CheckIfHasTech(List<TechType> techType)
        {
            foreach (var tech in techType)
                if (CheckIfHasTech(tech))
                    return true;
            return false;
        }
        
        //是否拥有某个原子科技
        public bool CheckIfHasTechAtom(TechAtom atom) { return TechAtomCacheSet.Contains(atom); }

        public bool HasAllTech(PlayerData player)
        {
            bool ret = true;
            Table.Instance.PlayerDataAssets.GetPlayerInfo(player, out var info);
            foreach (TechType tech in info.TechPool)
            {
                var techInfo = Table.Instance.TechDataAssets.GetTechInfo(tech);
                if (CheckIfHasTech(tech))
                    continue;
                ret = false;
                break;
            }
            return ret;
        }

        public int GetScore()
        {
            int ret = 0;
            foreach (var tech in TechSet)
            {
                var techInfo = Table.Instance.TechDataAssets.GetTechInfo(tech);
                ret += techInfo.CostLevel * 100;
            }

            return ret;
        }
        
        public bool CheckActionCan(CommonActionId actionId)
        {
            if (!Table.Instance.ActionDataAssets.GetActionInfo(actionId, out var info)) return false;
            if (info.NoNeedTech) return true;
            return TechAtomActionCacheSet.Contains(actionId.Id);
        }

        public bool CheckIfTechUnsee(TechType techType)
        {
            return !HasFatherTech(Table.Instance.TechDataAssets.GetTechInfo(techType).FatherTechList);
        }

        private bool HasFatherTech(List<TechType> techList)
        {
            foreach(var tech in techList)
                if (TechSet.Contains(tech))
                    return true;
            return false;
        }
        
        public bool CheckIfTechCanLearn(TechType techType)
        {
            
            //Debug.Log(techType);
            return !TechSet.Contains(techType) && !CheckIfTechUnsee(techType);
            
        }
    }
    
    
    // 外交信息
    [MemoryPackable]
    public partial class DiplomacyData
    {
        public List<CountryDiplomacyInfo> Info;
        private Dictionary<uint, CountryDiplomacyInfo> _infoDict;
        
        
        [MemoryPackConstructor]
        public DiplomacyData()
        {
            Info = new List<CountryDiplomacyInfo>();
        }
        
        public DiplomacyData(DiplomacyData copyData)
        {
            Info = new List<CountryDiplomacyInfo>();
        }
        
        // MemoryPack 反序列化之后的后处理
        [MemoryPackOnDeserialized]
        public void OnAfterMemoryPackDeserialize()
        {
            Refresh();
        }
        
        public void DeepCopy(DiplomacyData copyData)
        {
            for (int i = 0; i < copyData.Info.Count; i++)
            {
                if (Info.Count <= i)   Info.Add(new CountryDiplomacyInfo());
                Info[i].DeepCopy(copyData.Info[i]);
            }
        }

        public bool CheckTurnAttacker(uint selfId, uint targetId, uint turn)
        {
            GetCountryDiplomacyInfo(selfId, targetId, out var info);
            if (info == null) return false;
            return info.AttackTurn != 0 && info.AttackTurn >= turn;
        }

        public void AddTurnAttacker(uint selfId, uint targetId, uint turn)
        {
            GetCountryDiplomacyInfo(selfId, targetId, out var info);
            if (info == null) return;
            info.AttackTurn = turn;
        }
        
        public void AddCountryDiplomacyInfo(uint targetId)
        {
            Refresh();
            if (_infoDict.ContainsKey(targetId)) return;
            var info = new CountryDiplomacyInfo { PlayerId = targetId };
            Info.Add(info);
        }
        
        public bool GetCountryDiplomacyInfo(uint selfId, uint targetId, out CountryDiplomacyInfo info)
        {
            info = null;
            if (selfId == targetId) return false;
            Refresh();
            return _infoDict.TryGetValue(targetId, out info);
            
        }

        private void Refresh()
        {
            if (_infoDict == null) _infoDict = new Dictionary<uint, CountryDiplomacyInfo>();
            if (_infoDict.Count == Info.Count) return;
            
            _infoDict.Clear();
            foreach (var countryDiplomacy in Info) _infoDict[countryDiplomacy.PlayerId] = countryDiplomacy;
        }
    }
    
    
    public static class DiplomacyDataExtensions
    {
        public static bool GetCountryDiplomacyInfo(this PlayerData player, uint targetId, out CountryDiplomacyInfo info)
        {
            return player.DiplomacyData.GetCountryDiplomacyInfo(player.Id, targetId, out info);
        }

        public static void GetCountryDiplomacyInfo(this PlayerData player, PlayerData targetPlayer, out CountryDiplomacyInfo info)
        {
            player.DiplomacyData.GetCountryDiplomacyInfo(player.Id, targetPlayer.Id, out info);
        }
        
        public static void AddTurnAttacker(this PlayerData player, uint targetId, uint turn)
        {
            player.DiplomacyData.AddTurnAttacker(player.Id, targetId, turn);
        }

        public static void AddTurnAttacker(this PlayerData player, PlayerData targetPlayer, uint turn)
        {
            player.DiplomacyData.AddTurnAttacker(player.Id, targetPlayer.Id, turn);
        }
        
        public static bool CheckTurnAttacker(this PlayerData player, uint targetId, uint turn)
        {
            return player.DiplomacyData.CheckTurnAttacker(player.Id, targetId, turn);
        }

        public static bool CheckTurnAttacker(this PlayerData player, PlayerData targetPlayer, uint turn)
        {
            return player.DiplomacyData.CheckTurnAttacker(player.Id, targetPlayer.Id, turn);
        }
    }
    
    
    // 对他国的数据
    [MemoryPackable]
    public partial class CountryDiplomacyInfo
    {
        public uint PlayerId;
        // 我对国家 PlayerId 的外交关系
        public DiplomacyState DiplomacyState;
        // 我对国家 PlayerId 的好感值
        public float FeelingValue;
        // 我对国家 PlayerId 的好感态度
        public FeelingState FeelingState;
        // 我对国家 PlayerId 的好感策略
        public List<FeelingStrategy> FeelingStrategyList;
        // 国家 PlayerId 攻击我的回合记录
        public uint AttackTurn;
        // 国家 PlayerId 是否在我国建立了大使馆
        public bool IsEmbassy;
        // 联盟破裂回合结束标记
        public bool IsLeagueRupture;
        // 国家对我发起的结盟请求
        public bool IsLeagueRequest;
        // 冷静期标记
        [MemoryPackIgnore]
        public int IsCalm;
        // PlayerId 是我的队友 (逻辑相当于同盟)
        public bool IsTeammate;
        
        
        [MemoryPackConstructor]
        public CountryDiplomacyInfo()
        {
            AttackTurn = 0;
            IsCalm = 0;
            IsEmbassy = false;
            IsLeagueRupture = false;
            IsLeagueRequest = false;
            IsTeammate = false;
            FeelingStrategyList = new List<FeelingStrategy>();
        }

        public CountryDiplomacyInfo(CountryDiplomacyInfo copyData)
        {
            PlayerId = copyData.PlayerId;
            AttackTurn = copyData.AttackTurn;
            DiplomacyState = copyData.DiplomacyState;
            FeelingValue = copyData.FeelingValue;
            FeelingState = copyData.FeelingState;
            FeelingStrategyList=  new List<FeelingStrategy>();
            foreach (var strategy in copyData.FeelingStrategyList)FeelingStrategyList.Add(strategy);
            IsEmbassy = copyData.IsEmbassy;
            IsLeagueRupture = copyData.IsLeagueRupture;
            IsLeagueRequest = copyData.IsLeagueRequest;
            IsCalm = copyData.IsCalm;
            IsTeammate = copyData.IsTeammate;
        }

        public void DeepCopy(CountryDiplomacyInfo copyData)
        {
            PlayerId = copyData.PlayerId;
            AttackTurn = copyData.AttackTurn;
            DiplomacyState = copyData.DiplomacyState;
            FeelingValue = copyData.FeelingValue;
            FeelingState = copyData.FeelingState;
            FeelingStrategyList.Clear();
            foreach (var strategy in copyData.FeelingStrategyList)FeelingStrategyList.Add(strategy);
            IsEmbassy = copyData.IsEmbassy;
            IsLeagueRupture = copyData.IsLeagueRupture;
            IsLeagueRequest = copyData.IsLeagueRequest;
            IsCalm = copyData.IsCalm;
            IsTeammate = copyData.IsTeammate;
        }
    }
 
    // 英雄的数据
    [MemoryPackable]
    public partial class PlayerHeroData
    {
        //当前最多获取英雄数量
        public int MaxHeroCount;
        //当前已经拥有的英雄数量
        public int HeroCount => HeroList.Count;
        //当前已经有的英雄
        public List<UnitFullType> HeroList;
        public GiantType LeaderGiantType;
        public Dictionary<UnitFullType, HeroTaskContentBase> HeroTaskDict;
        [MemoryPackIgnore] private List<GridData> _tmpGridListBuf;
        
        [MemoryPackConstructor]
        public PlayerHeroData()
        {
            MaxHeroCount = 1;
            HeroList = new List<UnitFullType>();
            LeaderGiantType = GiantType.None;
            HeroTaskDict = new Dictionary<UnitFullType, HeroTaskContentBase>();
        }
        
        public PlayerHeroData(PlayerHeroData copyData)
        {
            MaxHeroCount = copyData.MaxHeroCount;
            HeroList = new List<UnitFullType>(copyData.HeroList);
            LeaderGiantType = copyData.LeaderGiantType;
            HeroTaskDict = new Dictionary<UnitFullType, HeroTaskContentBase>();
            foreach (var kv in copyData.HeroTaskDict) HeroTaskDict.TryAdd(kv.Key,kv.Value?.GetCopyHeroTaskContent());
        }
        
        public void DeepCopy(PlayerHeroData copyData)
        {
            MaxHeroCount = copyData.MaxHeroCount;
            HeroList = new List<UnitFullType>(copyData.HeroList);
            LeaderGiantType = copyData.LeaderGiantType;
            HeroTaskDict.Clear();
            foreach (var kv in copyData.HeroTaskDict) HeroTaskDict.TryAdd(kv.Key,kv.Value?.GetCopyHeroTaskContent());
        }
        
        public void Init(CivEnum civEnum, ForceEnum forceEnum)
        {
            LeaderGiantType = civEnum switch
            {
                CivEnum.Egyptian => GiantType.EgyptianRemilia,
                CivEnum.French => GiantType.FrenchKaguya,
                CivEnum.Germany => GiantType.GermanyKanako,
                CivEnum.Indian => GiantType.IndianSatori,
                _ => GiantType.None
            };
        }
        public GiantType GetLeaderGiantType()
        {
            return LeaderGiantType;
        }

        public void OnTurnStart(MapData map, PlayerData player)
        {
            foreach (var heroType in HeroList)
            {
                if (heroType.GiantType != GiantType.IndianKoishi) continue;
                var count = 0;
                foreach (var unit in map.UnitMap.UnitList)
                {
                    if (unit.GiantType != GiantType.IndianKoishi) continue;
                    if (!map.GetPlayerIdByUnitId(unit.Id, out var ownerId)) continue;
                    if (ownerId != player.Id) continue;
                    count++;
                }
                if (count >= heroType.UnitLevel) continue;
                map.GetCapitalCityDataByPlayerId(player.Id, out var city);
                var cityGrid = city?.Grid(map);
                if (cityGrid == null) continue;
                _tmpGridListBuf ??= new List<GridData>();
                _tmpGridListBuf.Clear();
                map.GridMap.GetAroundGridData(1, 1, cityGrid, _tmpGridListBuf);
                using var pooledRandomList = THCollectionPool.GetListHandle<GridData>(out var randomList);
                foreach (var grid in _tmpGridListBuf)
                {
                    if (grid == cityGrid) continue;
                    if (grid.RealUnit(map,out _)) continue;
                    if(!map.CheckLandTypeForGrid(heroType, grid))continue;
                    randomList.Add(grid);
                }
                if (randomList.Count == 0) continue;
                var index = map.Net.GetRandom(map).Next(0, randomList.Count - 1); // 生成 index
                if (map.AddUnitData(randomList[index].Id, city.Id, heroType, out var newUnit))
                {
                    // 更新新单位的视野
                    Main.PlayerLogic.UpdateSight_LogicView(map, player,
                        map.GridMap.GetAroundGridIdList(newUnit.GetSightRange(map), randomList[index]));
                }
            }
        }
        
        public bool HasHero(GiantType giantType)
        {
            foreach (var heroType in HeroList)
                if (heroType.GiantType == giantType)
                    return true;
            return false;
        }

        public bool AddHero(MapData map,PlayerData player,GiantType giantType)
        {
            var type = new UnitFullType(UnitType.Giant, giantType, 1);
            //如果是三发英雄，起步是Lv2
            //if (HeroCount > 1) type.UnitLevel = 2;
            if (HasHero(giantType)) return false;
            HeroList.Add(type);
            //如果Lv3或者其他意外，就不需要填加对应task了
            if (HeroTaskManager.Instance.GetHeroTaskContent(type, out var task))
            {
                HeroTaskDict.Add(type,task);
                task.OnTaskInit(map,player);
            }
            // moment
            foreach (var item in player.MomentData.Items) item.OnAddHero(map, player, type);
            return true;
        }
        
        //发生在英雄升级的时候，更新heroList，让新的英雄type替换旧的type
        public bool UpdateHero(MapData map,PlayerData player,UnitFullType newType)
        {
            if (!HasHero(newType.GiantType)) return false;
            
            //通知UI界面 更新heroButton按钮
            if (this == Main.MapData.PlayerMap.SelfPlayerData.PlayerHeroData)
            {
                EventManager.Publish(new UpdateUIBottomBottomBarHeroButtonAvatar());
                //UIManager.Instance.BottomBarUI.UpdateHeroButtonSprite();
            }
            for(int i =0;i < HeroCount;i++)
                if (HeroList[i].GiantType == newType.GiantType)
                {
                    HeroTaskDict.Remove(HeroList[i]);
                    HeroList[i] = newType;
                    //如果不是满级，要更新新的任务
                    if(newType.UnitLevel < 4){
                        if (!HeroTaskManager.Instance.GetHeroTaskContent(newType, out var task)) return false;
                        HeroTaskDict.Add(newType,task);
                        task.OnTaskInit(map,player);
                    }
                    return true;
                }
            return false;
        }

        public bool ForceFinishHeroTask(GiantType giant)
        {
            if (!HasHero(giant)) return false;
            if(!GetHeroTask(giant,out var task))return false;
            //task.Level = task.TargetLevel;
            if (task.IsForceFinished) return false;
            task.ForceFinish();
            return true;
        }

        public bool GetHeroTask(GiantType giant, out HeroTaskContentBase task)
        {
            foreach(var t in HeroTaskDict)
                if (t.Key.GiantType == giant)
                {
                    task = t.Value;
                    return true;
                }
            task = null;
            return false;
        }

        public void UpdateHeroMaxCount(uint unitLevel)
        {
            if (unitLevel > MaxHeroCount)
                MaxHeroCount = Mathf.Min(3, (int)unitLevel);
        }
        
        //获取英雄的升级费用值
        public int GetHeroFinishTaskCost(GiantType giant, float discount = 1f)
        {
            foreach (var heroType in HeroList)
                if (heroType.GiantType == giant)
                {
                    if(GetHeroTask(giant,out var task))
                    {
                        var baseCost = task.GetFinishCost() * (int)heroType.UnitLevel;
                        if (discount < 1f && discount > 0f)
                            return Mathf.CeilToInt(baseCost * discount);
                        return baseCost;
                    }
                }
            return 0;
        }
        
        public uint GetHeroLevel(GiantType giant)
        {
            foreach (var heroType in HeroList)
                if (heroType.GiantType == giant)
                    return heroType.UnitLevel;
            return 0;
        }

        //返回现在外部的herobutton应该显示谁的头像
        public Sprite GetHeroButtonSprite()
        {
            var giant = GetLeaderGiantType();
            if (HeroCount > 0)
                giant = HeroList[HeroCount - 1].GiantType;
            if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(new UnitFullType(UnitType.Giant, giant, 1),
                    out var info))
                return null;
            if (!Table.Instance.UnitTypeDataAssets.GetUnitSpriteByInfo(info,Main.MapData.PlayerMap.SelfPlayerData,out var sprite))
                return null;
            return sprite;
        }
        
        //返回现在外部的herobutton是否应该显示提示符号
        public bool GetHeroButtonHint()
        {
            return HeroCount < MaxHeroCount;
        }
    }
    
    // 命名器的数据
    [MemoryPackable]
    public partial class PlayerNamerData
    {
        //City命名
        [MemoryPackInclude]
        private List<CityLibrary> _cityNamer;
        [MemoryPackInclude]
        private int _cityNamerPointer;

        [MemoryPackConstructor]
        public PlayerNamerData()
        {
            _cityNamer =  new List<CityLibrary>();
            _cityNamerPointer = 0;
        }

        public void Init(CivEnum civEnum)
        {
            var civId = Table.Instance.TransCivEnumToCivId(civEnum);
            if (!Table.Instance.CivDataAssets.GetCivInfo(civId, out var info))
            {
                Debug.LogError($"PlayerNamerData.Init: CivDataAssets missing for CivEnum={civEnum}, CivId={civId}, fallback to CivId=0");
                // fallback: 借用埃及的城市名，防止空列表导致崩溃
                if (Table.Instance.CivDataAssets.GetCivInfo(CivEnum.Egyptian, out var fallbackInfo))
                {
                    foreach (var t in fallbackInfo.CityInfoList)
                        _cityNamer.Add(t.CityNameEnum);
                }
                else
                {
                    _cityNamer.Add(CityLibrary.Cairo);
                }
                Table.Instance.ShuffleRange(_cityNamer, 1);
                return;
            }
            foreach (var t in info.CityInfoList)
                _cityNamer.Add(t.CityNameEnum);
            Table.Instance.ShuffleRange(_cityNamer, 1);
        }
        public PlayerNamerData(PlayerNamerData copyData)
        {
            _cityNamer = new List<CityLibrary>(copyData._cityNamer);
            _cityNamerPointer = copyData._cityNamerPointer;
        }

        public void DeepCopy(PlayerNamerData copyData)
        {
            _cityNamer = new List<CityLibrary>(copyData._cityNamer);
            _cityNamerPointer = copyData._cityNamerPointer;
        }

        public CityLibrary GetSetNextCity()
        {
            if (_cityNamer.Count == 0)
            {
                Debug.LogError($"PlayerNamerData: _cityNamer is empty, CivDataAssets may be missing for this player");
                return CityLibrary.Cairo; // fallback to prevent crash
            }
            if (_cityNamerPointer >= _cityNamer.Count)
                _cityNamerPointer = 1;//重复命名的时候，跳过首都
            if (_cityNamerPointer >= _cityNamer.Count)
                _cityNamerPointer = 0; // 如果只有一个城市，回到0
            return _cityNamer[_cityNamerPointer++];
        }

        public bool CheckIsCityNameSelfBuild(CityLibrary cityLibrary)
        {
            for (int i = 0; i < _cityNamerPointer; i++)
            {
                if (i >= _cityNamer.Count) break;
                if (_cityNamer[i] == cityLibrary) return true;
            }
            return false;
            
        }
    }

    
    // 文化值系统
    [MemoryPackable]
    public partial class PlayerCultureInfo
    {
        public int PlayerCulture;
        public List<CultureCardType> CultureCardList;
        public List<CultureCardBase> CardList;
        
        
        [MemoryPackConstructor]
        public PlayerCultureInfo()
        {
            PlayerCulture = 0;
            CultureCardList = new List<CultureCardType>();
            CardList = new List<CultureCardBase>();
        }

        public PlayerCultureInfo(PlayerCultureInfo copyData)
        {
            PlayerCulture = copyData.PlayerCulture;
            CultureCardList = new List<CultureCardType>();
            foreach (var card in copyData.CultureCardList) CultureCardList.Add(card);
            CardList = new List<CultureCardBase>();
            foreach (var card in copyData.CardList)
            {
                CardList.Add(CultureCardFactory.GetCultureCardBase(card.GetCardType()));
            }
        }

        public void DeepCopy(PlayerCultureInfo copyData)
        {
            PlayerCulture = copyData.PlayerCulture;
            CultureCardList ??= new List<CultureCardType>();
            CultureCardList.Clear();
            foreach (var card in copyData.CultureCardList) CultureCardList.Add(card);
            CardList ??= new List<CultureCardBase>();
            CardList.Clear();
            foreach (var card in copyData.CardList)
            {
                CardList.Add(CultureCardFactory.GetCultureCardBase(card.GetCardType()));
            }
        }

        // 购买文化卡
        public bool TryBuyCultureCard(MapData map, PlayerData player, CultureCardType cardType)
        {
            if (!Table.Instance.CultureCardDataAssets.GetCultureCardInfo(cardType, out var info)) return false;
            if (!info.CheckEmpireCanUseCard(player.Empire)) return false;
            if (!info.CheckPrerequisiteCardsOwned(player)) return false;
            if (PlayerCulture < info.Cost) return false;
            PlayerCulture -= info.Cost;
            CultureCardList.Add(cardType);
            var card = CultureCardFactory.GetCultureCardBase(cardType);
            card.OnGetCultureCard(map, player);
            CardList.Add(card);
            return true;
        }
        
        // 能否购买文化卡
        public bool CheckCanBuyCultureCard(MapData map, PlayerData player, CultureCardType cardType)
        {
            if (!Table.Instance.CultureCardDataAssets.GetCultureCardInfo(cardType, out var info)) return false;
            if (!info.CheckEmpireCanUseCard(player.Empire)) return false;
            if (!info.CheckPrerequisiteCardsOwned(player)) return false;
            if (PlayerCulture < info.Cost) return false;
            return true;
        }
        
        public void OnTurnStart(MapData map, PlayerData player)
        {
            /*if (!player.IsSurvival) return;
            if (map.CityMap.GetCityById(player.CradleCityId, out var cradleCity))
            {
                if (cradleCity.Player(map) == player) PlayerCulture += 3;
            }
            var cityList = new List<CityData>();
            map.GetCityDataListByPlayerId(player.Id, cityList);
            foreach (var city in cityList)
            {
                if (city == cradleCity) continue;
                if (city.IsCapital) PlayerCulture += 1;
            }*/
        }

        public void OnUnitTransform(MapData map, UnitData unit, UnitFullType origin, UnitFullType target)
        {
            if (origin.UnitLevel == 2 && target.UnitLevel == 3) PlayerCulture += 15;
            if (origin.UnitLevel == 3 && target.UnitLevel == 4) PlayerCulture += 50;
        }

        public void OnWonderBuild(MapData map, PlayerData player, WonderTypeEnum wonderType)
        {
            PlayerCulture += 5;
        }
    }
}