/*
* @Author: 白哉
* @Description: 行为逻辑类
* @Date: 2025年04月10日 星期四 11:04:44
* @Modify: 
*/


using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using Logic.AI;
using Logic.CrashSight;
using RuntimeData;
using TH1_Logic.Core;
using UnityEngine;
using TH1Renderer;
using TH1Resource;




//这里是所有BuildAction派生子类的实现模块
namespace Logic.Action
{
    public enum UnitActionType
    {
        None,Upgrade,Recover,HEAL,Examine,Gather,Capture,Disband,ROYALFLAMES,ROYALFLAMESPRO,GiantUpgrade,
        TEWIFRENCHBUFF
    }
    
    //UnitAction单位行动逻辑类
    public class UnitActionAction : ActionLogicBase
    {
        public UnitActionAction(CommonActionId id) : base(id)
        {
            
        }

        protected override bool Execute(CommonActionParams actionParams, bool isMoment)
        {
            //临时使用，用来给解除联盟的disband特判用的
            if (isMoment == false) 
            {
                
            }
            else
            {
                if (!CheckCan(actionParams)) return false;
            }
            //鲁棒性判断
            if (actionParams.UnitData == null) return false;
            var unitData = actionParams.UnitData;
            var playerData = actionParams.PlayerData;
            if (playerData == null)
                if (!actionParams.MapData.GetPlayerDataByUnitId(actionParams.UnitData.Id, out playerData))
                    return false;
            if (!actionParams.MapData.GetGridDataByUnitId(actionParams.UnitData.Id, out var gridData))
                return false;
            if (_actionId.UnitActionType == UnitActionType.Capture)
            {
                //处理捕获city的情况
                if (actionParams.MapData.GetCityDataByGid(gridData.Id, out var cityData))
                {
                    gridData.VFXRenderMarkFog = true;
                    Main.PlayerLogic.OccupyCity(actionParams.MapData,actionParams.UnitData,cityData);
                    
                    //处理占领城市的特效(所有领土会升起一面旗帜
                    HashSet<uint> gridList = new HashSet<uint>();
                    cityData.Territory.GetAllTerritoryArea(gridList);
                    foreach (var gd in gridList)
                    {
                        if (actionParams.MapData.GridMap.GetGridDataByGid(gd, out var gdd))
                        {
                            //设置gdd格子的VFXrendermark
                            var t = new GridVFXRenderMark(GridVFXType.Flag,true);
                            t.CivId = playerData.PlayerCivId;
                            gdd.SetGridVFXRenderMark(t);
                        }
                            
                    }
                    actionParams.UnitData.CP = 0;
                    actionParams.UnitData.MP = 0;
                    actionParams.UnitData.AP = 0;
                    unitData.TaskContent?.OnCaptureCity(actionParams.MapData);
                    return true;
                }
                //处理占领村庄的情况
                else
                {
                    gridData.VFXRenderMarkFog = true;
                    cityData = Main.PlayerLogic.OccupyVillage(actionParams.MapData,actionParams.UnitData,gridData);
                    
                    //处理占领城市的特效(所有领土会升起一面旗帜
                    HashSet<uint> gridList = new HashSet<uint>();
                    cityData.Territory.GetAllTerritoryArea(gridList);
                    foreach (var gd in gridList)
                    {
                        if (actionParams.MapData.GridMap.GetGridDataByGid(gd, out var gdd))
                        {
                            //设置gdd格子的VFXrendermark
                            var t = new GridVFXRenderMark(GridVFXType.Flag,true);
                            t.CivId = playerData.PlayerCivId;
                            gdd.SetGridVFXRenderMark(t);
                        }
                            
                    }
                    
                    actionParams.UnitData.CP = 0;
                    actionParams.UnitData.MP = 0;
                    actionParams.UnitData.AP = 0;
                    return true;
                }
            }
            
            if (_actionId.UnitActionType == UnitActionType.Upgrade)
            {
                if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(actionParams.UnitData.UnitType,
                        actionParams.UnitData.GiantType, actionParams.UnitData.UnitLevel,out var info))
                    return false;
                //处理CARRY的情况
                if (info.Skills.Contains(SkillType.CARRY))
                {
                    if (actionParams.UnitData.CarryVeteran)
                        return false;
                    if (actionParams.UnitData.CarryExp < 3)
                        return false;
                    actionParams.UnitData.CarryVeteran = true;
                }
                //处理非CARRY是老兵
                else
                {
                    if (actionParams.UnitData.Veteran)
                        return false;
                    if (actionParams.UnitData.Exp < 3)
                        return false;
                    actionParams.UnitData.Veteran = true;
                }
                actionParams.UnitData.Health = actionParams.UnitData.GetMaxHealth();
                actionParams.UnitData.RenderMark = true;
                return true;
            }

            //处理ship
            if (_actionId.UnitType == UnitType.Ship || _actionId.UnitType == UnitType.RammerShip
                                                    || _actionId.UnitType == UnitType.BomberShip)
            {
                if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(_actionId.UnitType,GiantType.None,0, out var info ))
                    return false;
                if (actionParams.PlayerData.PlayerWealth < info.Cost)
                    return false;
                actionParams.PlayerData.PlayerWealth -= info.Cost;
                Main.UnitLogic.UnitTypeTransform(actionParams.MapData,actionParams.UnitData,_actionId.UnitType);
                Main.PlayerLogic.UpdateSight(actionParams.MapData,actionParams.PlayerData,actionParams.MapData.GridMap.GetAroundGridIdList(unitData.GetSightRange(),gridData));
                actionParams.UnitData.RenderMark = true;
                return true;
            }
            
            
            //剩下的都需要CP，消耗CP
            //TODO 这里isMoment是为了强制disband用的
            if (isMoment != false && actionParams.UnitData.CP <= 0)
                return false;
            //用ret做记录
            bool ret = false;
            
            //处理disband
            if (_actionId.UnitActionType == UnitActionType.Disband)
            {
                int earn = 0;
                //TODO 临时制作，强制解散，解除结盟时候，解散英雄
                if (!isMoment && (unitData.UnitType == UnitType.Giant) || (unitData.UnitType == UnitType.GiantJuggernaut))
                {
                    Main.UnitLogic.Die(actionParams.MapData,actionParams.UnitData);
                    gridData.VFXRenderMarkFog = true;
                    return true;
                }
                if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(actionParams.UnitData.UnitType,GiantType.None,0, out var info ))
                    return false;
                earn += info.Cost / 2;
                if (actionParams.UnitData.CarryUnitType != UnitType.None
                    && Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(actionParams.UnitData.CarryUnitType,
                        GiantType.None,0, out var carryInfo))
                    earn += carryInfo.Cost / 2;

                actionParams.PlayerData.PlayerWealth += earn;
                
                //临时做法，用来播放VFX,获取Main，理应向MapData写入一个VFX的RenderMark的
                if (actionParams.MapData == Main.MapData)
                {
                    var v1 = Table.Instance.GridToWorld(gridData);
                        
                    var startPos = Table.Instance.GridToWorld(gridData);
                    var moneyPanel = GameObject.Find("UICanvas/TopBarPanel/MoneyPanel/Icon").transform;
                    var endPos = moneyPanel.position;
                    //播放雾效
                    gridData.VFXRenderMarkFog = true;
                    
                    //播放获得钱的动画
                    if(playerData.Id == actionParams.MapData.PlayerMap.SelfPlayerId)
                        MapRenderer.Instance.ProjectileManager.CreateProjectileMulti(startPos,endPos,ProjectileType.Coin,ProjectileMoveType.CoinParabola,earn,0.05f);
                }
                
                Main.UnitLogic.Die(actionParams.MapData,actionParams.UnitData);
                ret = true;
            }
            
            //处理recover
            if (_actionId.UnitActionType == UnitActionType.Recover)
            {
                int recoverV = 4;
                if (!actionParams.MapData.GetPlayerDataByTerritoryGridId(gridData.Id, out var terrPlayerData))
                    recoverV = 2;
                else if (!actionParams.MapData.SameUnion(terrPlayerData.Id , actionParams.PlayerData.Id))
                    recoverV = 2;
                actionParams.UnitData.Health += recoverV;
                gridData.VFXRenderMarkHeal = true;
                if (actionParams.UnitData.Health > actionParams.UnitData.GetMaxHealth())
                    actionParams.UnitData.Health = actionParams.UnitData.GetMaxHealth();
                ret = true;
                actionParams.UnitData.RenderMark = true;
            }
            
            //处理gather
            if (_actionId.UnitActionType == UnitActionType.Gather)
            {
                gridData.Resource = ResourceType.None;
                actionParams.PlayerData.PlayerWealth += 10;
                gridData.RenderMark = true;
                ret = true;
                if (actionParams.MapData == Main.MapData && actionParams.MapData.PlayerMap.SelfPlayerId == playerData.Id)
                {
                    var v1 = Table.Instance.GridToWorld(gridData);
                        
                    var startPos = Table.Instance.GridToWorld(gridData);
                    var moneyPanel = GameObject.Find("UICanvas/TopBarPanel/MoneyPanel/Icon").transform;
                    var endPos = moneyPanel.position;
                    //播放获得钱的动画
                    MapRenderer.Instance.ProjectileManager.CreateProjectileMulti(startPos,endPos,ProjectileType.Coin,ProjectileMoveType.CoinParabola,10,0.05f);
                    //MapRenderer.Instance.ProjectileManager.CreateProjectileMulti(main,actionParams.MapData,v1,v2,ProjectileType.CityExp,ProjectileMoveType.CityExpHighParabola,wonderInfo.Exp);
                }
            }
                
            
            //处理examine
            if (_actionId.UnitActionType == UnitActionType.Examine)
            {
                unitData.TaskContent?.OnTreasure(actionParams.MapData);
                gridData.Resource = ResourceType.None;
                gridData.RenderMark = true;
                if (actionParams.MapData.Net.GetRandom().Next(0, 100) < 50)
                {
                    actionParams.PlayerData.PlayerWealth += 10;
                    
                    //播放获得钱的动画
                    if (actionParams.MapData == Main.MapData && actionParams.MapData.PlayerMap.SelfPlayerId == playerData.Id)
                        MapRenderer.Instance.ProjectileManager.CreateCoinProjectile(Table.Instance.GridToWorld(gridData),10);
                        
                    
                }
                //给一个随机科技
                else if (UnityEngine.Random.Range(0, 100) < 0)
                {
                    var tt = new List<TechType>(); 
                    foreach (TechType tech in System.Enum.GetValues(typeof(TechType)))
                    {
                        if (actionParams.PlayerData.TechTree.CheckIfHasTech(tech))
                            continue;
                        tt.Add(tech);
                    }
                    if(tt.Count <= 0)
                        actionParams.PlayerData.PlayerWealth += 10;
                    else
                    {
                        Main.PlayerLogic.ResearchTech(actionParams.MapData,actionParams.PlayerData,tt[UnityEngine.Random.Range(0, tt.Count)],0);
                    }
                }
                //给一个单位
                else
                {
                    Main.UnitLogic.PassiveMoveAway(actionParams.MapData, actionParams.UnitData);
                    if(!actionParams.MapData.GetCapitalCityDataByPlayerId(actionParams.PlayerData.Id, out var capital))
                        return false;
                    if (gridData.Terrain == TerrainType.Land)
                    {
                        var unit = actionParams.MapData.AddUnitData(gridData.Id,capital.Id,UnitType.Swordsman);
                        unit.Exp = 3;
                        unit.Veteran = true;
                        unit.Health = unit.GetMaxHealth();
                        unit.RenderMark = true;
                    }
                    else
                    {
                        var unit = actionParams.MapData.AddUnitData(gridData.Id,capital.Id,UnitType.RammerShip);
                        unit.CarryExp = 3;
                        unit.CarryVeteran = true;
                        unit.Health = unit.GetMaxHealth();
                        unit.RenderMark = true;
                    }
                        
                        
                    if(gridData.Terrain == TerrainType.Land)
                        capital.CityInfoRenderMark = true;
                }
                ret = true;
            }
                

            //处理ROYALFLAMES
            if (_actionId.UnitActionType == UnitActionType.ROYALFLAMES)
            {
                var unitA = actionParams.UnitData;
                var gridA = gridData;
                var gridList = actionParams.MapData.GridMap.GetAroundGridData(2,2,gridA);
                var t = new GridVFXRenderMark(GridVFXType.ROYALFLAMES);
                gridA.SetGridVFXRenderMark(t);
                
                Timer.Instance.TimerRegister(this,()=>
                {
                    if (!actionParams.MapData.GetPlayerIdByUnitId(unitA.Id, out var pidA)) return;
                    foreach (var gridB in gridList)
                    {
                        //如果有地方单位，造成伤害
                        if (actionParams.MapData.GetUnitDataByGid(gridB.Id, out var unitB))
                        {
                            if (!actionParams.MapData.GetPlayerIdByUnitId(unitB.Id, out var pidB)) continue;
                            //如果是友军，跳过
                            if (actionParams.MapData.SameUnion(pidB,pidA)) continue;
                            var dis = Table.Instance.CalcDistance(gridA,gridB );
                            //处理内圈伤害
                            if (dis == 1)
                            {
                                //var damage = Table.Instance.CalcDamage(actionParams.MapData, unitA, unitB);
                                Main.UnitLogic.DamageSettlement(actionParams.MapData,unitA, unitB,6, DamageType.Splash);
                                //播放伤害数字特效
                                var damageMark1 = new GridVFXRenderMark(GridVFXType.Damage);
                                damageMark1.Damage = 6;
                                gridB.SetGridVFXRenderMark(damageMark1);
                                //更新unit的显示
                                unitB.RenderMark = true;
                    
                                //TODO 下面的是不规范做法，后面要迭代
                                //播放受伤特效
                                gridB.VFXRenderMarkHurt = true;
                                // 执行相关动画，包括伤害特效、伤害数字、以及可能得死亡特效
                                MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                            }
                            //处理外圈伤害
                            if (dis == 2)
                            {
                                //var damage = Table.Instance.CalcDamage(actionParams.MapData, unitA, unitB,damagePara:0.5f);
                                Main.UnitLogic.DamageSettlement(actionParams.MapData,unitA, unitB,3, DamageType.Splash);
                                //播放伤害数字特效
                                var damageMark2 = new GridVFXRenderMark(GridVFXType.Damage);
                                damageMark2.Damage = 3;
                                gridB.SetGridVFXRenderMark(damageMark2);
                                //更新unit的显示
                                unitB.RenderMark = true;
                    
                                //TODO 下面的是不规范做法，后面要迭代
                                //播放受伤特效
                                gridB.VFXRenderMarkHurt = true;
                                // 执行相关动画，包括伤害特效、伤害数字、以及可能得死亡特效
                                MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                            }
                        }
                        else
                        //如果没有单位，造成地块震荡的效果
                        {
                            //处理动画效果
                            MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                        }
                        
                        
                    }
                },0.5f,"ActionLogic_UnitAction_Execute_Anim");
                ret = true;
            }
            

            if (ret)
            {
                actionParams.UnitData.CP = 0;
                actionParams.UnitData.AP = 0;
                actionParams.UnitData.MP = 0;
                actionParams.UnitData.RenderMark = true;
            }
                
            return ret;
        }

        public override bool CheckCan(CommonActionParams actionParams)
        {
            
            //鲁棒性判断
            if (actionParams.UnitData == null) return false;
            if (actionParams.PlayerData == null) return false;
            if (!actionParams.MapData.GetGridDataByUnitId(actionParams.UnitData.Id, out var gridData))
                return false;
            //如果unit不是player的，退出
            if(!actionParams.MapData.GetPlayerDataByUnitId(actionParams.UnitData.Id, out var playerData) || 
               playerData != actionParams.PlayerData)
                return false;
            //判断钱够不够
            if (GetCost() > actionParams.PlayerData.PlayerWealth)
                return false;
            //如果不具备科技
            if (!actionParams.PlayerData.TechTree.CheckActionCan(_actionId))
                return false;
            
            if (_actionId.UnitActionType == UnitActionType.Upgrade)
            {
                //鲁棒性处理
                if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(actionParams.UnitData.UnitType,
                        actionParams.UnitData.GiantType, actionParams.UnitData.UnitLevel,out var info))
                    return false;
                //处理CARRY的情况
                if (info.Skills.Contains(SkillType.CARRY))
                {
                    if (actionParams.UnitData.CarryVeteran)
                        return false;
                    if (actionParams.UnitData.CarryExp >= 3)
                        return true;
                    return false;
                }
                //处理非CARRY是老兵
                if (actionParams.UnitData.Veteran)
                    return false;
                if (actionParams.UnitData.Exp >= 3)
                    return true;
                return false;
            }

            //先处理不需要CP的 Upgrade UnitShip UnitRammerShip UnitBattleShip 这4个
            if (_actionId.UnitType == UnitType.Ship || _actionId.UnitType == UnitType.RammerShip
                                                    || _actionId.UnitType == UnitType.BomberShip)
            {
                
                if(actionParams.UnitData.UnitType != UnitType.Boat)
                    return false;
                
                if (!actionParams.MapData.GetPlayerDataByTerritoryGridId(gridData.Id, out var player1))
                    return false;
                if(!actionParams.MapData.SameUnion(player1.Id,actionParams.PlayerData.Id))
                    return false;
                
                return true;
            }
            
            //剩下的都需要CP，如果Unit有没有CP了，return false
            if (actionParams.UnitData.CP <= 0)
                return false;
            
            //处理capture
            if (_actionId.UnitActionType == UnitActionType.Capture)
            {
                //如果是占领别的城市
                if (actionParams.MapData.GetCityDataByGid(gridData.Id, out var cityData))
                {
                    actionParams.MapData.GetPlayerDataByCityId(cityData.Id,out var playerId1);
                    actionParams.MapData.GetPlayerDataByUnitId(actionParams.UnitData.Id,out var playerId2);
                    return playerId1 != playerId2;
                }
                //如果是占领村庄
                else
                {
                    return gridData.Resource == ResourceType.CityCenter;
                }
            }
            
            //处理disband
            if (_actionId.UnitActionType == UnitActionType.Disband)
            {
                if (actionParams.UnitData.UnitType == UnitType.Giant || actionParams.UnitData.CarryUnitType == UnitType.Giant)
                    return false;
                return true;
            }
                
            
            //处理recover
            if (_actionId.UnitActionType == UnitActionType.Recover)
            {
                if (actionParams.UnitData.Health < actionParams.UnitData.GetMaxHealth())
                    return true;
                return false;
            }
            
            //处理gather
            if (_actionId.UnitActionType == UnitActionType.Gather)
                return gridData.Resource == ResourceType.Starfish;
            
            //处理examine
            if (_actionId.UnitActionType == UnitActionType.Examine)
                return gridData.Resource == ResourceType.Treasure;
            
            //处理战技ROYALFLAMES 
            if (_actionId.UnitActionType == UnitActionType.ROYALFLAMES)
            {
                if (!actionParams.UnitData.GetSkill(SkillType.ROYALFLAMES, out var skillInfo))
                    return false;
                return true;
            }
            
            return false;
        }
        public override bool CheckShow(CommonActionParams actionParams)
        {
            //鲁棒性判断
            if (actionParams.UnitData == null) return false;
            if (actionParams.PlayerData == null) return false;
            if (!actionParams.MapData.GetGridDataByUnitId(actionParams.UnitData.Id, out var gridData))
                return false;
            //如果unit不是player的，退出
            if(!actionParams.MapData.GetPlayerDataByUnitId(actionParams.UnitData.Id, out var playerData) || 
               playerData.Id != actionParams.PlayerData.Id)
                return false;
            //判断钱够不够 checkshow中 即使钱不够，也可以显示的
            //if (GetCost() > actionParams.PlayerData.PlayerWealth)
              //  return false;
            //如果不具备科技
            if (!actionParams.PlayerData.TechTree.CheckActionCan(_actionId))
                return false;
            //先处理不需要CP的 Upgrade UnitShip UnitRammerShip UnitBattleShip 这4个
            if (_actionId.UnitActionType == UnitActionType.Upgrade)
            {
                //鲁棒性处理
                if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(actionParams.UnitData.UnitType,
                        actionParams.UnitData.GiantType, actionParams.UnitData.UnitLevel,out var info))
                    return false;
                //处理CARRY的情况
                if (info.Skills.Contains(SkillType.CARRY))
                {
                    if (actionParams.UnitData.CarryVeteran)
                        return false;
                    if (actionParams.UnitData.CarryExp >= 3)
                        return true;
                    return false;
                }
                //处理非CARRY是老兵
                if (actionParams.UnitData.Veteran)
                    return false;
                if (actionParams.UnitData.Exp >= 3)
                    return true;
                return false;
            }

            
            if (_actionId.UnitType == UnitType.Ship || _actionId.UnitType == UnitType.RammerShip
                                                    || _actionId.UnitType == UnitType.BomberShip)
            {
                
                if(actionParams.UnitData.UnitType != UnitType.Boat)
                    return false;
                
                if (!actionParams.MapData.GetPlayerDataByTerritoryGridId(gridData.Id, out var player1))
                    return false;
                if(!actionParams.MapData.SameUnion(player1.Id,actionParams.PlayerData.Id))
                    return false;
                
                return true;
            }
            
            //剩下的都需要CP，如果Unit有没有CP了，return false
            if (actionParams.UnitData.CP <= 0)
                return false;
            
            //处理capture
            if (_actionId.UnitActionType == UnitActionType.Capture)
            {
                //如果是占领别的城市
                if (actionParams.MapData.GetCityDataByGid(gridData.Id, out var cityData))
                {
                    actionParams.MapData.GetPlayerDataByCityId(cityData.Id,out var playerId1);
                    actionParams.MapData.GetPlayerDataByUnitId(actionParams.UnitData.Id,out var playerId2);
                    return playerId1 != playerId2;
                }
                //如果是占领村庄
                else
                {
                    return gridData.Resource == ResourceType.CityCenter;
                }
            }
            
            //处理disband
            if (_actionId.UnitActionType == UnitActionType.Disband)
            {
                if (actionParams.UnitData.UnitType == UnitType.Giant || actionParams.UnitData.CarryUnitType == UnitType.Giant)
                    return false;
                return true;
            }
                
            
            //处理recover
            if (_actionId.UnitActionType == UnitActionType.Recover)
            {
                if (actionParams.UnitData.Health < actionParams.UnitData.GetMaxHealth())
                    return true;
                return false;
            }
            
            //处理gather
            if (_actionId.UnitActionType == UnitActionType.Gather)
                return gridData.Resource == ResourceType.Starfish;
            
            //处理examine
            if (_actionId.UnitActionType == UnitActionType.Examine)
                return gridData.Resource == ResourceType.Treasure;
            
            //处理战技ROYALFLAMES 
            if (_actionId.UnitActionType == UnitActionType.ROYALFLAMES)
            {
                
                if (!actionParams.UnitData.GetSkill(SkillType.ROYALFLAMES, out var skillInfo))
                    return false;
                return true;
            }
            
            return false;
        }
        public override ActionShowState CheckShowState(CommonActionParams actionParams) { return ActionShowState.None; }
        public override bool ExecuteViewBefore(CommonActionParams actionParams)
        {
            return false;
        }

        public override bool ExecuteViewAfter(CommonActionParams actionParams)
        { 
            return false;
        }
        
        //付钱
        protected bool UnitActionPayMoney(CommonActionParams actionParam)
        {
            if (actionParam.PlayerData.PlayerWealth - GetCost() < 0) return false;
            actionParam.PlayerData.PlayerWealth -= GetCost();
            return true;
        }
        
        //确认是否满足基本信息,并且补全actionParam(主要是补充unit所处的grid)
        protected bool UnitActionCheckBaseInfo(CommonActionParams actionParam)
        {
            //鲁棒性判断，必须包含unitData和playerData，表明是哪个玩家正在操作哪个单位
            if (actionParam.UnitData == null) return false;
            if (actionParam.PlayerData == null) return false;
            if (!actionParam.MapData.GetGridDataByUnitId(actionParam.UnitData.Id, out var grid)) return false;
            actionParam.GridData = grid;
            return true;
        }
        protected bool UnitActionCheckUnitBelongPlayer(CommonActionParams actionParam)
        {
            //如果unit不是player的，退出
            if(!actionParam.MapData.GetPlayerDataByUnitId(actionParam.UnitData.Id, out var playerData) || 
               playerData != actionParam.PlayerData)
                return false;
            return true;
        }
        //确认是否有科技
        protected bool UnitActionCheckHasTech(CommonActionParams actionParam)
        {
            //如果没有对应科技，return false
            if (!actionParam.PlayerData.TechTree.CheckActionCan(_actionId))
                return false;
            return true;
        }

        //确认是否有钱
        protected bool UnitActionCheckHasMoney(CommonActionParams actionParam)
        {
            //判断钱够不够
            if (GetCost() > actionParam.PlayerData.PlayerWealth)
                return false;
            return true;
            
        }

        //确认unit是否有CP
        protected bool UnitActionCheckUnitHasCP(CommonActionParams actionParam)
        {
            if (actionParam.UnitData == null || actionParam.UnitData.CP <= 0)
                return false;
            return true;
        }

        //确认unit是否拥有这个skill
        protected bool UnitActionCheckUnitHasSkill(CommonActionParams actionParam)
        {
            //将unitActionType转化为skillType
            if (!Enum.TryParse(_actionId.UnitActionType.ToString(), out SkillType skillType)) return false;
            if (actionParam.UnitData == null || !actionParam.UnitData.GetSkill(skillType, out var _)) return false;
            return true;
        }
        
    }
    
    public class UnitActionROYALFLAMESPRO : UnitActionAction
    {
        public UnitActionROYALFLAMESPRO(CommonActionId id) : base(id)
        {
            
        }

        protected override bool Execute(CommonActionParams actionParams, bool isMoment)
        {
            var unitA = actionParams.UnitData;
            var gridA = actionParams.GridData;
            if(gridA == null)
                if(!actionParams.MapData.GetGridDataByUnitId(unitA.Id, out gridA)) return false;
            var gridList = actionParams.MapData.GridMap.GetAroundGridData(3,3,gridA);
            var t = new GridVFXRenderMark(GridVFXType.ROYALFLAMES);
            gridA.SetGridVFXRenderMark(t);
            
            Timer.Instance.TimerRegister(this,()=>
            {
                if (!actionParams.MapData.GetPlayerIdByUnitId(unitA.Id, out var pidA)) return;
                foreach (var gridB in gridList)
                {
                    //如果有地方单位，造成伤害
                    if (actionParams.MapData.GetUnitDataByGid(gridB.Id, out var unitB))
                    {
                        if (!actionParams.MapData.GetPlayerIdByUnitId(unitB.Id, out var pidB)) continue;
                        //如果是友军，跳过
                        if (actionParams.MapData.SameUnion(pidB,pidA)) continue;
                        var dis = Table.Instance.CalcDistance(gridA,gridB );
                        //处理内圈伤害
                        if (dis == 1)
                        {
                            //var damage = Table.Instance.CalcDamage(actionParams.MapData, unitA, unitB);
                            Main.UnitLogic.DamageSettlement(actionParams.MapData,unitA, unitB,10, DamageType.Splash);
                            //播放伤害数字特效
                            var damageMark1 = new GridVFXRenderMark(GridVFXType.Damage);
                            damageMark1.Damage = 10;
                            gridB.SetGridVFXRenderMark(damageMark1);
                            //更新unit的显示
                            unitB.RenderMark = true;
                
                            //TODO 下面的是不规范做法，后面要迭代
                            //播放受伤特效
                            gridB.VFXRenderMarkHurt = true;
                            // 执行相关动画，包括伤害特效、伤害数字、以及可能得死亡特效
                            MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                        }
                        //处理外圈伤害
                        if (dis == 2)
                        {
                            //var damage = Table.Instance.CalcDamage(actionParams.MapData, unitA, unitB,damagePara:0.5f);
                            Main.UnitLogic.DamageSettlement(actionParams.MapData,unitA, unitB,6, DamageType.Splash);
                            //播放伤害数字特效
                            var damageMark2 = new GridVFXRenderMark(GridVFXType.Damage);
                            damageMark2.Damage = 6;
                            gridB.SetGridVFXRenderMark(damageMark2);
                            //更新unit的显示
                            unitB.RenderMark = true;
                
                            //TODO 下面的是不规范做法，后面要迭代
                            //播放受伤特效
                            gridB.VFXRenderMarkHurt = true;
                            // 执行相关动画，包括伤害特效、伤害数字、以及可能得死亡特效
                            MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                        }
                        //处理3圈伤害
                        if (dis == 3)
                        {
                            //var damage = Table.Instance.CalcDamage(actionParams.MapData, unitA, unitB,damagePara:0.5f);
                            Main.UnitLogic.DamageSettlement(actionParams.MapData,unitA, unitB,3, DamageType.Splash);
                            //播放伤害数字特效
                            var damageMark2 = new GridVFXRenderMark(GridVFXType.Damage);
                            damageMark2.Damage = 3;
                            gridB.SetGridVFXRenderMark(damageMark2);
                            //更新unit的显示
                            unitB.RenderMark = true;
                
                            //TODO 下面的是不规范做法，后面要迭代
                            //播放受伤特效
                            gridB.VFXRenderMarkHurt = true;
                            // 执行相关动画，包括伤害特效、伤害数字、以及可能得死亡特效
                            MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                        }
                    }
                    else
                    //如果没有单位，造成地块震荡的效果
                    {
                        //处理动画效果
                        MapRenderer.Instance.ROGridMap[gridB.Id].SetBounceAnim(NeedRandomWait:true);
                    }
                    
                    
                }
            },0.5f,"UnitActionLogic_Execute_ROYALFLAMESPRO");
            actionParams.UnitData.ClearAPMPCP();
            actionParams.UnitData.RenderMark = true;
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParam)
        {
            //step #1 check基本信息
            if (!UnitActionCheckBaseInfo(actionParam)) return false;
            //#step #2 check unit属于player
            if (!UnitActionCheckUnitBelongPlayer(actionParam)) return false;
            //step #3 check是否有CP释放技能
            if (!UnitActionCheckUnitHasCP(actionParam)) return false;
            //step #4 check unit是否拥有skill技能
            if (!UnitActionCheckUnitHasSkill(actionParam)) return false;
            return true;
        }

        public override bool CheckShow(CommonActionParams actionParam)
        {
            return CheckCan(actionParam);   
        }
        
        public override bool ExecuteViewBefore(CommonActionParams actionParams)
        {
            return true;
        }

        public override bool ExecuteViewAfter(CommonActionParams actionParams)
        {
            //如果不是真mapdata在播放动画
            if (Main.MapData != actionParams.MapData) return false;
            return true;
        }
    }

    //英雄升级
    public class UnitActionGiantUpgrade : UnitActionAction
    {
        private int _healthBeforeAnim;

        private bool CheckUnitCanGiantUpgrade(CommonActionParams actionParams)
        {
            var unit = actionParams.UnitData;
            var player = actionParams.PlayerData;
            if (player == null) return false;
            if(unit == null || unit.UnitType != UnitType.Giant || unit.GiantType == GiantType.None || unit.UnitLevel >= 5) return false;
            if(!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(unit.UnitType,unit.GiantType,unit.UnitLevel,out var info)) return false;
            
            return unit.TaskContent.CheckFinished();
            
        }

        public UnitActionGiantUpgrade(CommonActionId id) : base(id)
        {
            
        }

        protected override bool Execute(CommonActionParams actionParams, bool isMoment)
        {
            //if (!CheckCan(actionParams)) return false;
            var unit = actionParams.UnitData;
            if (!Table.Instance.UnitTypeDataAssets.GetUnitTypeInfo(unit.UnitType, unit.GiantType, unit.UnitLevel,
                    out var info)) return false;
            //step #1 已经升到满级就return
            if (unit.UnitLevel + 1 > 3) return false;
            //Step #2 修改Player HeroData
            if (!actionParams.PlayerData.PlayerHeroData.HeroUpgrade(unit.GiantType, out var newLevel)) return false;
            //step #3 transfrom升级
            Main.UnitLogic.UnitTypeTransform(actionParams.MapData,unit,unit.UnitType,unit.GiantType,newLevel);
            
            //step #4 回复10点血
            unit.AddHealth(10);
            
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParam)
        {
            //step #1 check基本信息
            if (!UnitActionCheckBaseInfo(actionParam)) return false;
            //#step #2 check unit属于player
            if (!UnitActionCheckUnitBelongPlayer(actionParam)) return false;
            //step #3 check unit是否是hero并满足升级条件
            if (!CheckUnitCanGiantUpgrade(actionParam)) return false; 
            return true;
        }

        public override bool CheckShow(CommonActionParams actionParam)
        {
            return CheckCan(actionParam);
        }
        
        public override bool ExecuteViewBefore(CommonActionParams actionParams)
        {
            _healthBeforeAnim = actionParams.UnitData.Health;
            return true;
        }

        public override bool ExecuteViewAfter(CommonActionParams actionParams)
        {
            //如果不是真mapdata在播放动画
            if (Main.MapData != actionParams.MapData) return false;
            
            //step #1设置回血动画
            if (!actionParams.MapData.GetGridDataByUnitId(actionParams.UnitData.Id, out var grid)) return false;
            grid.SetGridVFXRenderMark(new GridVFXRenderMark(GridVFXType.Heal));
            
            //step #2更新unit的renderMark
            actionParams.UnitData.RenderMark = true;
            
            return true;
        }
    }


    public class UnitActionHEAL : UnitActionAction
    {
        public UnitActionHEAL(CommonActionId id) : base(id)
        {
            
        }
        protected override bool Execute(CommonActionParams actionParams,bool isMoment)
        {
            var map =  actionParams.MapData;
            var unit = actionParams.UnitData;
            if (map == null || unit == null) return false;
            if (!map.GetGridDataByUnitId(actionParams.UnitData.Id, out var targetGrid)) return false;  
            var roundGrid = map.GridMap.GetAroundGridData(1, 1, targetGrid);
            foreach (var grid in roundGrid)
            {
                if (!map.GetUnitDataByGid(grid.Id, out var tunit)) continue;
                if(tunit.Id == unit.Id)continue;
                if (!map.SameUnionByUnitId(unit.Id,tunit.Id)) continue;
                tunit.AddHealth(4);
                tunit.RenderMark = true;
                grid.VFXRenderMarkHeal = true;
            }
            unit.ClearAPMPCP();
            unit.RenderMark = true;
            return true;
        } 
        
        public override bool CheckCan(CommonActionParams actionParam)
        {
            //step #1 check基本信息
            if (!UnitActionCheckBaseInfo(actionParam)) return false;
            //#step #2 check unit属于player
            if (!UnitActionCheckUnitBelongPlayer(actionParam)) return false;
            //step #3 check是否有CP释放技能
            if (!UnitActionCheckUnitHasCP(actionParam)) return false;
            //step #4 check unit是否拥有skill技能
            if (!UnitActionCheckUnitHasSkill(actionParam)) return false;
            return true;
        }

        public override bool CheckShow(CommonActionParams actionParam)
        {
            return CheckCan(actionParam);
        }
        
        public override bool ExecuteViewBefore(CommonActionParams actionParams) { return true; }

        public override bool ExecuteViewAfter(CommonActionParams actionParams) { return true; }
        
    }

    public class UnitActionTEWIFRENCHBUFF : UnitActionAction
    {
        public UnitActionTEWIFRENCHBUFF(CommonActionId id) : base(id)
        {
            
        }

        protected override bool Execute(CommonActionParams actionParams, bool isMoment)
        {
            var selfUnit = actionParams.UnitData;
            var selfGrid = actionParams.GridData;
            if(selfGrid == null)
                if(!actionParams.MapData.GetGridDataByUnitId(selfUnit.Id, out selfGrid)) return false;
            if (!actionParams.MapData.GetPlayerDataByUnitId(selfUnit.Id, out var selfPlayer)) return false;
            var gridList = actionParams.MapData.GridMap.GetAroundGridData(1,1,selfGrid);
            foreach (var grid in gridList)
            {
                if(!actionParams.MapData.GetUnitDataByGid(grid.Id,out var targetUnit))continue;
                if(!actionParams.MapData.GetPlayerDataByUnitId(targetUnit.Id, out var targetPlayer)) continue;
                if(!actionParams.MapData.SameUnion(targetPlayer.Id,selfPlayer.Id)) continue;
                targetUnit.AddSkill(SkillType.MOVERANGEUP);
                targetUnit.GetSkill(SkillType.MOVERANGEUP,out var targetSkill1);
                targetSkill1.SetTurnsLimit(1);
                targetUnit.AddSkill(SkillType.KAGUYAFRENCHSYNERGY);
                targetUnit.GetSkill(SkillType.KAGUYAFRENCHSYNERGY,out var targetSkill2);
                targetSkill2.SetTurnsLimit(1);
                var gridVFX = new GridVFXRenderMark(GridVFXType.TewiFrenchBuff);
                grid.SetGridVFXRenderMark(gridVFX);
            }
            
            actionParams.UnitData.ClearAPMPCP();
            actionParams.UnitData.RenderMark = true;
            return true;
        }

        public override bool CheckCan(CommonActionParams actionParam)
        {
            //step #1 check基本信息
            if (!UnitActionCheckBaseInfo(actionParam)) return false;
            //#step #2 check unit属于player
            if (!UnitActionCheckUnitBelongPlayer(actionParam)) return false;
            //step #3 check是否有CP释放技能
            if (!UnitActionCheckUnitHasCP(actionParam)) return false;
            //step #4 check unit是否拥有skill技能
            if (!UnitActionCheckUnitHasSkill(actionParam)) return false;
            return true;
        }

        public override bool CheckShow(CommonActionParams actionParam)
        {
            return CheckCan(actionParam);   
        }
        
        public override bool ExecuteViewBefore(CommonActionParams actionParams) { return true; }

        public override bool ExecuteViewAfter(CommonActionParams actionParams) { return true; }
    }
    
}