using vnxbqy.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System;

//Arena 注册控制代码
public class ArenaManagerModel : ILModel<ArenaManagerModel>
{
    private GActorPlayerBase.PlayerInfo info;
    private float m_LastAttackTime;
    private int m_ComAtkIndex;
    private int recordDataMapId;
    DungeonModel m_DungeonModel;
    DungeonModel dungeonModel {
        get {
            return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
        }
    }

    /// stage
    public static readonly Vector3 leftBornPoint = new Vector3(4f, 0.2f, 11.5f);
    static readonly Vector3 rightBornPoint = new Vector3(11.5f, 0.2f, 4f);
    static readonly Vector3 initPoint = new Vector3(30f, 0.2f, 30f);
    public int[] s_StepTimes = null;

    static ILFightInfo fightInfo;
    static ILPKStageType pkStageType;
    public static GA_PlayerClient.PlayerInfo playerInfo;
    static GA_ILClientPlayer opponentPlayer;
    static uint roundWiner = 0;
    static ILPKStage currentStage;
    public DateTime dungeonEndTime;
    public bool fightStart = false;
    int[] _skills;

    int RobotIndex = 0;
    protected override void Init()
    {
        //ILClientPlayer  对手
        ArenaManager.OnILPlayerResult += OnILPlayerResult;
        ArenaManager.OnILInit += OnILInit;
        ArenaManager.OnILPlayerInit += OnILPlayerInit;
        ArenaManager.OnILPlayerReset += OnILPlayerReset;
        ArenaManager.OnILPlayerDestroy += OnILPlayerDestroy;
        ArenaManager.OnILPlayerUpdateAI += OnILPlayerUpdateAI;
        ArenaManager.OnILPlayerUnit += OnILPlayerUnit;
        ArenaManager.OnILPlayerRequestName += OnILPlayerRequestName;
        ArenaManager.OnILPlayerHorse += OnILPlayerHorse;
        ArenaManager.OnILPlayerSelect += OnILPlayerSelect;
        ArenaManager.OnILPlayerUnSelect += OnILPlayerUnSelect;
        ArenaManager.OnILPlayerSyncSuitEffect += OnILPlayerSyncSuitEffect;
        ArenaManager.OnILPlayerClick += OnILPlayerClick;
        ArenaManager.OnILPlayerSwitchHorse += OnILPlayerSwitchHorse;
        ArenaManager.OnILPlayerPutonWing += OnILPlayerPutonWing;
        ArenaManager.OnILPlayerPutonWeapon += OnILPlayerPutonWeapon;
        ArenaManager.OnILPlayerPutonSecondary += OnILPlayerPutonSecondary;
        ArenaManager.OnILPlayerPutonClothes += OnILPlayerPutonClothes;
        ArenaManager.OnILPlayerRefreshLifeBar += OnILPlayerRefreshLifeBar;
        //Arena Stage控制
        ArenaManager.OnILStageInitialize += OnILStageInitialize;
        ArenaManager.OnILStageUnInitialize += OnILStageUnInitialize;
        ArenaManager.OnILStageLoadFinish += OnILStageLoadFinish;
        ArenaManager.OnILStageUpdate += OnILStageUpdate;
        StageLoad.Instance.onStageLoadFinish += OnLoadMapFinish;


        //hero behavior 本人
        HeroBehaviour.OnStartHandupAI += OnILStartHandupAI;
        HeroBehaviour.OnStopHandupAI += OnILStopHandupAI;
        HeroBehaviour.onCastSkill += OnILCastSkill;
        HeroBehaviour.OnUserClickSkill += OnILUserClickSkill;
        //显示PK UI
        ArenaManager.OnILPKWinShow += OnILPKWinShow;
        DTC0320_tagFBEnd.UpdateFBEndEvent += UpdateFBEnd;
    }
    protected override void UnInit()
    {
        //ILClientPlayer
        ArenaManager.OnILPlayerResult -= OnILPlayerResult;
        ArenaManager.OnILInit -= OnILInit;
        ArenaManager.OnILPlayerInit -= OnILPlayerInit;
        ArenaManager.OnILPlayerReset -= OnILPlayerReset;
        ArenaManager.OnILPlayerDestroy -= OnILPlayerDestroy;
        ArenaManager.OnILPlayerUpdateAI -= OnILPlayerUpdateAI;
        ArenaManager.OnILPlayerUnit -= OnILPlayerUnit;
        ArenaManager.OnILPlayerRequestName -= OnILPlayerRequestName;
        ArenaManager.OnILPlayerHorse -= OnILPlayerHorse;
        ArenaManager.OnILPlayerSelect -= OnILPlayerSelect;
        ArenaManager.OnILPlayerUnSelect -= OnILPlayerUnSelect;
        ArenaManager.OnILPlayerSyncSuitEffect -= OnILPlayerSyncSuitEffect;
        ArenaManager.OnILPlayerClick -= OnILPlayerClick;
        ArenaManager.OnILPlayerSwitchHorse -= OnILPlayerSwitchHorse;
        ArenaManager.OnILPlayerPutonWing -= OnILPlayerPutonWing;
        ArenaManager.OnILPlayerPutonWeapon -= OnILPlayerPutonWeapon;
        ArenaManager.OnILPlayerPutonSecondary -= OnILPlayerPutonSecondary;
        ArenaManager.OnILPlayerPutonClothes -= OnILPlayerPutonClothes;
        ArenaManager.OnILPlayerRefreshLifeBar -= OnILPlayerRefreshLifeBar;
        //Arena Stage控制
        ArenaManager.OnILStageInitialize -= OnILStageInitialize;
        ArenaManager.OnILStageUnInitialize -= OnILStageUnInitialize;
        ArenaManager.OnILStageLoadFinish -= OnILStageLoadFinish;
        ArenaManager.OnILStageUpdate -= OnILStageUpdate;
        StageLoad.Instance.onStageLoadFinish -= OnLoadMapFinish;

        //hero behavior
        HeroBehaviour.OnStartHandupAI -= OnILStartHandupAI;
        HeroBehaviour.OnStopHandupAI -= OnILStopHandupAI;
        HeroBehaviour.onCastSkill -= OnILCastSkill;
        HeroBehaviour.OnUserClickSkill -= OnILUserClickSkill;

        //显示UI
        ArenaManager.OnILPKWinShow -= OnILPKWinShow;
        DTC0320_tagFBEnd.UpdateFBEndEvent -= UpdateFBEnd;

    }
   
    //关闭竞技场后重新打开UI
    private void OnLoadMapFinish()
    {
        var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
        if (recordDataMapId == ArenaManager.MapID && ArenaModel.Instance.bFirstStageLoadCheck)
        {
            WindowCenter.Instance.OpenIL<ArenaWin>();
            ArenaModel.Instance.bFirstStageLoadCheck = false;
        }
        recordDataMapId = dataMapId;
    }
    
    //副本结算界面
    void UpdateFBEnd()
    {
        if (ArenaManager.isArenaClient)
        {
            WindowCenter.Instance.OpenIL<ArenaSettlementWin>();            
            //更新排名
            ArenaRankModel.Instance.SetMyRank(ArenaModel.Instance.RankType, dungeonModel.dungeonResult.updOrder);
        }

    }  
    void OnILPKWinShow(bool bShow)
    {
        if (bShow)
        {
            WindowCenter.Instance.OpenIL<ArenaFightingPKWin>();
        }
        else
        {
            WindowCenter.Instance.CloseIL<ArenaFightingPKWin>();
        }
    }
    void OnILStartHandupAI()
    {
        if (!ArenaManager.isArenaClient)
            return;
        //PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();
    }
    void OnILStopHandupAI()
    {
        if (!ArenaManager.isArenaClient)
            return;
        PlayerDatas.Instance.hero.SkillMgr.ResetAllCD();
    }
    void OnILCastSkill(int SkillID)
    {
        if (!ArenaManager.isArenaClient)
            return;
        Skill _skill = PlayerDatas.Instance.hero.SkillMgr.Get(SkillID);
        if (!_skill.IsValid())
            return;
        if (Skill.RefreshCD != null)
        {
            _skill.cd = _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA;
            Skill.RefreshCD(_skill.id, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
        }
    }

    void OnILUserClickSkill(int skill)
    {

    }
    void OnILPlayerResult(bool winOrLose)
    {
        ArenaModel.Instance.WinnerID = winOrLose ? PlayerDatas.Instance.baseData.PlayerID : ArenaModel.Instance.OPPONENT_PLAYERID;
    }
    void OnILInit(uint serverInstID, uint clientInstID, GActorPlayerBase.PlayerInfo playerInfo, E_ActorGroup group)
    {
        info = playerInfo;
        ArenaManager.iLClientPlayer.Init(serverInstID, clientInstID, group, null);

    }
    void OnILPlayerInit(GameNetPackBasic package)
    {
        CapsuleCollider _capCollider = ArenaManager.iLClientPlayer.Root.AddMissingComponent<CapsuleCollider>();
        _capCollider.height = 1.2f;
        _capCollider.center = new Vector3(0, .6f, 0);
        _capCollider.radius = .4f;

        Evt_PlayerClick _evtClick = ArenaManager.iLClientPlayer.Root.AddMissingComponent<Evt_PlayerClick>();
        _evtClick.ownerSID = ArenaManager.iLClientPlayer.ServerInstID;

        // 初始化坐标
        ArenaManager.iLClientPlayer.AdjustPos(PlayerDatas.Instance.baseData.PosX, PlayerDatas.Instance.baseData.PosY);

        ArenaManager.iLClientPlayer.ActorInfo.moveSpeed = 500f / 150;
        ArenaManager.iLClientPlayer.ActorInfo.atkSpeed = 1;

        ArenaManager.iLClientPlayer.JobSetup = JobSetupConfig.Get(info.job);
        GActorPlayerBase.CEquipInfo _itemInfo;
        if (info.itemDatas != null)
        {
            // 因为衣服是所有装备的父节点, 需要预先处理衣服
            for (int i = 0; i < info.itemDatas.Length; ++i)
            {
                _itemInfo = info.itemDatas[i];

                if (_itemInfo.place == (int)RoleEquipType.Clothes)
                {
                    ArenaManager.iLClientPlayer.SwitchClothes((uint)_itemInfo.id);
                    break;
                }
            }
        }

        // 如果没有任何衣服, 则穿上默认装备
        if (ArenaManager.iLClientPlayer.ClothesItemID == 0 || ArenaManager.iLClientPlayer.ClothesItemID == uint.MaxValue)
        {
            ArenaManager.iLClientPlayer.SwitchClothes(0);
        }

        if (info.itemDatas != null)
        {
            for (int i = 0; i < info.itemDatas.Length; ++i)
            {
                _itemInfo = info.itemDatas[i];

                if (_itemInfo.place == (int)RoleEquipType.Weapon)
                {
                    ArenaManager.iLClientPlayer.SwitchWeapon((uint)_itemInfo.id);
                }
                else if (_itemInfo.place == (int)RoleEquipType.Weapon2)
                {
                    ArenaManager.iLClientPlayer.SwitchSecondary((uint)_itemInfo.id);
                }
                else if (_itemInfo.place == (int)RoleEquipType.Wing)
                {
                    ArenaManager.iLClientPlayer.SwitchWing((uint)_itemInfo.id);
                }
            }
        }

        if (ArenaManager.iLClientPlayer.WeaponItemID == 0 || ArenaManager.iLClientPlayer.WeaponItemID == uint.MaxValue)
        {
            ArenaManager.iLClientPlayer.SwitchWeapon(0);
        }

        ArenaManager.iLClientPlayer.ActorInfo.Job = (byte)ArenaManager.iLClientPlayer.JobSetup.Job;
        ArenaManager.iLClientPlayer.ActorInfo.PlayerName = info.name;
        ArenaManager.iLClientPlayer.ActorInfo.MaxHp = info.hp;
        ArenaManager.iLClientPlayer.ActorInfo.Hp = info.maxHp;
        ArenaManager.iLClientPlayer.ActorInfo.LV = info.level;
        int realmLv = 0;
        if (info.playerID > 10000)
        {
            realmLv = ArenaManager.playInfo[1][32];
        }
        else
        { 
            realmLv = ArenaModel.Instance.GetRealm(info.level);
        }
        ArenaManager.iLClientPlayer.ActorInfo.realm = (uint)realmLv;

        _skills = ArenaManager.GetJobSkill(ArenaManager.iLClientPlayer.JobSetup.Job, info.level);
       
    }
    void OnILPlayerReset()
    {
        var _list = GAMgr.Instance.GetTypeList(E_ActorClassType.ILClientPlayer);
        if (_list != null)
        {
            _list[0].ActorInfo.ResetHp((long)_list[0].ActorInfo.MaxHp);
            _list[0].ActorInfo.serverDie = false;
            _list[0].IdleImmediate();
        }

        PlayerDatas.Instance.FightRefreshPlayerHp(PlayerDatas.Instance.extersion.MaxHP);
        PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)PlayerDatas.Instance.extersion.MaxHP);
        PlayerDatas.Instance.hero.IdleImmediate();
    }
    void OnILPlayerDestroy()
    {

    }
    void OnILPlayerUpdateAI()
    {
        if (!ArenaManager.isArenaClient)
            return;
        if (Application.isEditor)
        {
            if(Input.GetKey(KeyCode.F5))               
            {
                opponentPlayer.ActorInfo.Hp = 0;
            }

            if (Input.GetKey(KeyCode.F6))
            {
                PlayerDatas.Instance.hero.ActorInfo.Hp = 0;
            }
        }
        CameraController.Instance.rotationX = 45;
        CameraController.Instance.Apply();
        if (!ArenaModel.Instance.bILAI)
            return;
        if (dungeonModel.dungeonFightStage != DungeonFightStage.Normal)
        {
            dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
            return;
        }
        if (PlayerDatas.Instance.hero == null)
            return;

        ArenaManager.iLClientPlayer.SelectTarget = PlayerDatas.Instance.hero;
        if (PlayerDatas.Instance.hero.ActorInfo.RealHp == 0)
            PlayerDatas.Instance.hero.ActorInfo.serverDie = true;
        if (ArenaManager.iLClientPlayer.SelectTarget == null || ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.serverDie)
        {
            return;
        }

        // 攻击间隔中
        if (Time.time - m_LastAttackTime
            < (1f / ArenaManager.iLClientPlayer.ActorInfo.atkSpeed) * .8f)
        {
            return;
        }

        Skill _skill = ArenaManager.iLClientPlayer.SkillMgr.CurCastSkill;
        
        // 判断主角当前是否有技能尚未释放完毕
        if (_skill != null)
        {
            if (!_skill.SkillCompelete)
            {
                return;
            }

            if (ArenaManager.iLClientPlayer.SkillMgr.DoingPrepareSkill)
            {
                return;
            }
        }

        if (RobotIndex >= _skills.Length - 1)
            RobotIndex = 0;
        for (int i = RobotIndex; i < _skills.Length; ++i)
        {
            _skill = ArenaManager.iLClientPlayer.SkillMgr.Get(_skills[i]);
            RobotIndex = i + 1;
            if (_skill.IsValid())
            {
                _skill.cd = _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA;
                //if (Skill.RefreshCD != null)
                //{
                //    Skill.RefreshCD(_skill.id, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA, _skill.skillInfo.config.CoolDownTime * Constants.F_GAMMA);
                //}
                break;
            }
            else
            {
                _skill = null;
            }
        }

        if (_skill == null)
        {
            if (m_ComAtkIndex > ArenaManager.iLClientPlayer.JobSetup.ComAtkIdList.Length - 1)
            {
                m_ComAtkIndex = 0;
            }
            int _comSkillId = ArenaManager.iLClientPlayer.JobSetup.ComAtkIdList[m_ComAtkIndex];
            _skill = ArenaManager.iLClientPlayer.SkillMgr.Get(_comSkillId);
            m_ComAtkIndex += 1;
        }
      
        // 判断技能范围, 不在可释放范围需要移动至目标
        float _compareDist = _skill.skillInfo.config.AtkDist * .5f;
        float _compareDistSqrt = _compareDist * _compareDist;

        // 计算当前和目标的距离
        float _currentDistSqrt = MathUtility.DistanceSqrtXZ(ArenaManager.iLClientPlayer.Pos, ArenaManager.iLClientPlayer.SelectTarget.Pos);
        // 比较距离
        if (_currentDistSqrt >= _compareDistSqrt)
        {
            // 移动至目标
            ArenaManager.iLClientPlayer.MoveToTarget(ArenaManager.iLClientPlayer.SelectTarget, _compareDist, true);

            return;
        }

        Vector3 _forward = MathUtility.ForwardXZ(ArenaManager.iLClientPlayer.SelectTarget.Pos, ArenaManager.iLClientPlayer.Pos);
        ArenaManager.iLClientPlayer.destForward = ArenaManager.iLClientPlayer.Forward = _forward;

        Vector3 _targetPosition = ArenaManager.iLClientPlayer.Pos + ArenaManager.iLClientPlayer.Forward * (_skill.skillInfo.config.AtkDist * .5f);
        _targetPosition.y = 0;
        UnityEngine.AI.NavMeshHit _navMeshHit;
        if (UnityEngine.AI.NavMesh.Raycast(ArenaManager.iLClientPlayer.Pos, _targetPosition, out _navMeshHit, -1))
        {
            _targetPosition = _navMeshHit.position;
        }
        _targetPosition.y = ArenaManager.iLClientPlayer.Pos.y;
        _skill.targetPosition = _targetPosition;

        E_SkillCastType _castType = (E_SkillCastType)(_skill.skillInfo.config.Tag % 10);
        if (_castType == E_SkillCastType.NeedTarget)
        {
            _skill.targetPosition = ArenaManager.iLClientPlayer.SelectTarget.Pos;
            _skill.mainTarget = ArenaManager.iLClientPlayer.SelectTarget as GActorFight;
        }

        ArenaManager.iLClientPlayer.SkillMgr.CastSkill(ArenaManager.iLClientPlayer.ServerInstID, _skill.id);

        if (_skill.skillInfo.config.Skillactmark > 0
                        && _skill.skillInfo.config.Skillactmark < 20)
        {
            switch (_skill.skillInfo.config.Skillactmark)
            {
                case 10:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack1Hash, 0);
                    break;
                case 11:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack2Hash, 0);
                    break;
                case 12:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack3Hash, 0);
                    break;
                case 13:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Attack4Hash, 0);
                    break;
            }

        }
        else
        {
            switch (_skill.skillInfo.config.Skillactmark)
            {
                case 21:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill21, 0);
                    break;
                case 22:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill22, 0);
                    break;
                case 23:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill23, 0);
                    break;
                case 24:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill24, 0);
                    break;
                case 25:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill25, 0);
                    break;
                case 26:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill26, 0);
                    break;
                case 27:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill27, 0);
                    break;
                case 28:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill28, 0);
                    break;
                case 29:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_Skill29, 0);
                    break;
                case 99:
                    ArenaManager.iLClientPlayer.Play(GAStaticDefine.State_RollHash, 0);
                    break;
            }
        }

        ulong hurtValue = 0;
        byte attackType = 0;
        //本人伤害计算
        AttackHandler.CalculateDamage(ArenaManager.iLClientPlayer, ArenaManager.iLClientPlayer.SelectTarget as GActorFight, _skill, 0, ref hurtValue, ref attackType);

        ulong _hp = ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.Hp;

        if (_hp < hurtValue)
        {
            hurtValue = _hp;
            _hp = 0;
        }
        else
        {
            _hp = _hp - hurtValue;
        }

        AttackHandler.HurtObjs _hurtObject = new AttackHandler.HurtObjs
        {
            AttackType = attackType,
            clientInstID = ArenaManager.iLClientPlayer.SelectTarget.ClientInstID,
            CurHP = _hp,
            RealHurtHP = hurtValue,
            HurtHP = hurtValue,
            ObjID = ArenaManager.iLClientPlayer.SelectTarget.ServerInstID,
            ObjType = (byte)ArenaManager.iLClientPlayer.SelectTarget.ActorType
        };

        _skill.hurtClientList.Add(_hurtObject);
        ArenaManager.iLClientPlayer.SelectTarget.ActorInfo.SyncServerHp = _hp;
        m_LastAttackTime = Time.time;

    }
    void OnILPlayerUnit()
    {

    }
    void OnILPlayerRequestName()
    {
        if (ArenaManager.iLClientPlayer.MovingState == E_MovingState.Ride)
        {
            ArenaManager.iLClientPlayer.m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, ArenaManager.iLClientPlayer.MP_Name1, 0, CameraController.Instance.CameraObject);
        }
        else
        {
            ArenaManager.iLClientPlayer.m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, ArenaManager.iLClientPlayer.MP_Name, 0, CameraController.Instance.CameraObject);
        }

        ArenaManager.iLClientPlayer.m_HeadUpName.SetPlayerInfo(new HeadUpName.PlayerInfo()
        {
            realm = ArenaManager.iLClientPlayer.ActorInfo.realm,
            title = ArenaManager.iLClientPlayer.ActorInfo.titleID,
            name = ArenaManager.iLClientPlayer.ActorInfo.PlayerName,
            alliance = ArenaManager.iLClientPlayer.ActorInfo.familyName,
        });
    }
    void OnILPlayerHorse(byte upOrDown)
    {

    }

    void OnILPlayerSelect()
    {
        if (CanAtked())
        {
            SelectionManager.Request(SelectionManager.E_Type.Red, ArenaManager.iLClientPlayer);
        }
        else
        {
            SelectionManager.Request(SelectionManager.E_Type.Green, ArenaManager.iLClientPlayer);
        }

        if (GA_Player.s_OnSelected != null)
        {
            GA_Player.s_OnSelected(ArenaManager.iLClientPlayer.ServerInstID, true);
        }
    }
    bool CanAtked()
    {
        return !ArenaManager.iLClientPlayer.ActorInfo.serverDie;
    }

    void OnILPlayerUnSelect()
    {

    }
    void OnILPlayerSyncSuitEffect(bool onOrOff)
    {

    }
    void OnILPlayerClick()
    {
        GA_Hero _hero = PlayerDatas.Instance.hero;
        if (_hero == null)
        {
            return;
        }

        _hero.LockTarget = ArenaManager.iLClientPlayer;
        _hero.SelectTarget = ArenaManager.iLClientPlayer;
    }

    void OnILPlayerSwitchHorse(uint horseID, GameObject horse)
    {

    }
    void OnILPlayerPutonWing(uint wingItemID, GameObject wing)
    {
        SkinnedMeshRenderer _renderer = wing.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }
    void OnILPlayerPutonWeapon(uint weaponItemID, GameObject weapon)
    {
        Renderer _renderer = weapon.GetComponentInChildren<Renderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }
    void OnILPlayerPutonSecondary(uint secondaryItemID, GameObject secondary)
    {
        Renderer _renderer = secondary.GetComponentInChildren<Renderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }
    void OnILPlayerPutonClothes(uint clothesItemID, GameObject clothed)
    {
        clothed.layer = LayerUtility.Player;
        SkinnedMeshRenderer _renderer = clothed.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }
    void OnILPlayerRefreshLifeBar(ulong value)
    {
        if (ArenaManager.iLClientPlayer.ActorInfo.serverDie)
            return;
        GA_Hero _hero = PlayerDatas.Instance.hero;
        if (_hero != null && _hero.SelectTarget == ArenaManager.iLClientPlayer)
        {
            if (GA_Player.s_OnRefreshLife != null)
            {
                GA_Player.s_OnRefreshLife(ArenaManager.iLClientPlayer.ServerInstID, ArenaManager.iLClientPlayer.ActorInfo.RealHp, ArenaManager.iLClientPlayer.ActorInfo.RealMaxHp);
            }
        }
    }
    //////////////////////////////////////////////////////////////////Arena Stage控制///////////////////////////////////////////////////////////////
    void OnILStageInitialize()
    {        
        ArenaModel.Instance.FakeMatchOk();
        fightInfo = default(ILFightInfo);
        fightInfo.isOver = false;
        fightInfo.roundWinnerIds = new List<uint>();
        currentStage = null;
    }
    void OnILStageUnInitialize()
    {
        fightInfo = default(ILFightInfo);
        roundWiner = 0;
        currentStage = null;
        ArenaManager.isArenaClient = false;
        if (opponentPlayer != null)
        {
            opponentPlayer.Destroy();
            opponentPlayer = null;
        }
        
        ArenaManager.isArenaClient = false;
        ArenaManager.isArenaPK = false;
        ArenaManagerModel.Instance.ReleasePlayer();
        ClientDungeonStageUtility.SetClientDungeon(false, 0);
        PlayerDatas.Instance.extersion.pkState = 0;
        ModelCenter.Instance.GetModel<DungeonModel>().ResetBufData();
        PersonalEnemy.ReleaseAll();
        PlayerDatas.Instance.baseData.MapID = PlayerDatas.Instance.baseData.mainServerMapIdRecord;
    }
    public void OnILStageLoadFinish()
    {
        if (!ArenaManager.IsArenaStage())
            return;
        ArenaManager.isArenaPK = true;
        

        ArenaModel.Instance.IsArenaWork = true;
        recordDataMapId = ArenaManager.MapID;
        ArenaModel.Instance.StartInit();
        pkStageType = ILPKStageType.WaitStart;        

        // B2 10 竞技场挑战玩家  通知后端登记挑战目标ID
        uint PlayerID = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID;
        ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID, 0);

        if (opponentPlayer != null)
        {
            PersonalEnemy.ReleaseILPlayer(opponentPlayer, false);
            opponentPlayer = null;
        }

       
        
        //Debug.Log("s_StepTimes" + s_StepTimes[0] + "    " + s_StepTimes[1] + "    " + s_StepTimes[2]);
        //创建对手
        var job = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].Job;
        var playerName = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerName;
        var level = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].LV; //等级
        var maxHp = ArenaModel.Instance.GetLevel(level, 1); //hp
        var scoreClass = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].RealmLV; //大境界，

        

        if (PlayerID < 10000) //大于10000 真人，小于10000 机器人，读配表
        {
            ArenaManager.isArenaRobot = true;
            //机器人读境界表取等级对应大境界
            scoreClass = (ushort)ArenaModel.Instance.GetRealmLarge(level);

            playerInfo = GetRobotPlayerInfo(scoreClass, job, playerName, level, (ulong)maxHp);
            playerInfo.playerID = PlayerID;
            PersonalEnemy.Create(30000, rightBornPoint, playerInfo,false);
            PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
            SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
        }
        else
        {
            ArenaManager.isArenaRobot = false;
            //发送命令获得个人详细信息

            RoleParticularModel.OnRevPackage += OnRevA705;
            ModelCenter.Instance.GetModel<RoleParticularModel>().ViewPlayerCacheData((int)PlayerID, (int)ViewPlayerType.viewPlayerDataArena);
        }
    }
    private void OnRevA705(int viewType, int playerID, RoleParticularModel.ViewPlayerData data)
    {
        if (viewType != (int)ViewPlayerType.viewPlayerDataArena)
            return;
        uint PlayerID = ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID;
        if (playerID != PlayerID)
            return;
        RoleParticularModel.OnRevPackage -= OnRevA705;
        playerInfo = GetRealPlayerInfo(data.rolePropData);
        playerInfo.playerID = PlayerID;
        PersonalEnemy.Create(30000, rightBornPoint, playerInfo,false);
        PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
        SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
        
    }
    
    private void OnPlayerAppear(GA_ILClientPlayer player)
    {
        PersonalEnemy.OnILPlayerAppear -= OnPlayerAppear;
        opponentPlayer = player;
        opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
        dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
    }
    public void ReleasePlayer()
    {
        if (opponentPlayer != null && !opponentPlayer.ActorInfo.serverDie)
        {
            PersonalEnemy.ReleaseILPlayer(opponentPlayer, false);
            opponentPlayer = null;
        }
    }
    public void GetRobotViewPlayerData(RankPageData m_pageData, out RoleParticularModel.ViewPlayerData m_ViewPlayerData)
    {
        m_ViewPlayerData = new RoleParticularModel.ViewPlayerData();
        m_ViewPlayerData.getTime = DateTime.Now;
        m_ViewPlayerData.rolePlusData = new RoleParticularModel.RolePlusData();
        m_ViewPlayerData.rolePlusData = new RoleParticularModel.RolePlusData();

        int level = (int)m_pageData.value2;
        int job = m_pageData.subType;
        int realm = ArenaModel.Instance.GetRealm(level);
        m_ViewPlayerData.rolePropData.Name = ArenaModel.Instance.RobotName;
        m_ViewPlayerData.rolePropData.LV = level;
        m_ViewPlayerData.rolePropData.RealmLV = realm;
        m_ViewPlayerData.rolePropData.MaxHP = ArenaModel.Instance.GetLevel(level, 1); //hp
        m_ViewPlayerData.rolePropData.FightPower = ArenaModel.Instance.GetLevel(level, 2); //fight
        m_ViewPlayerData.rolePropData.Job = job;
        //此处用竞技场机器人配置表
        int realmlarge = ArenaModel.Instance.GetRealmLarge(level);
        var config = ArenaRobotConfig.GetRandomRobotConfig(realmlarge);
        var jsonData = JsonMapper.ToObject(config.equips);


        if (jsonData.Keys.Contains(job.ToString()))
        {
            var equipJson = jsonData[job.ToString()];
            m_ViewPlayerData.rolePropData.EquipShowID = new int[equipJson.Count];
            for (var i = 0; i < equipJson.Count; i++)
            {
                m_ViewPlayerData.rolePropData.EquipShowID[i] = (int)equipJson[i];
            }
        }

    }
    //AtkFightPower 挑战方战力，DefFightPower防守方战力
    float GetFightPowerRate(ulong AtkFightPower, ulong DefFightPower)
    {
        Equation.Instance.Clear();
        Equation.Instance.AddKeyValue("AtkFightPower", AtkFightPower);
        Equation.Instance.AddKeyValue("DefFightPower", DefFightPower);
        var funcConfig = FuncConfigConfig.Get("ArenaLVSet");
        string formula = funcConfig.Numerical4;
        return Equation.Instance.Eval<float>(formula);
    }
    GA_PlayerClient.PlayerInfo GetRobotPlayerInfo(int scoreClass, int job, string playerName, int level, ulong maxHp)
    {
        //此处用竞技场机器人配置表
        var config = ArenaRobotConfig.GetRandomRobotConfig(scoreClass);
        var jsonData = JsonMapper.ToObject(config.equips);
        var equipItems = new List<int>();
        if (jsonData.Keys.Contains(job.ToString()))
        {
            var equipJson = jsonData[job.ToString()];
            for (var i = 0; i < equipJson.Count; i++)
            {
                equipItems.Add((int)equipJson[i]);
            }
        }

        var equipInfos = new GA_PlayerClient.CEquipInfo[equipItems.Count];
        for (int i = 0; i < equipInfos.Length; i++)
        {
            var equipInfo = new GA_PlayerClient.CEquipInfo();
            var itemConfig = ItemConfig.Get(equipItems[i]);
            equipInfo.id = itemConfig.ID;
            equipInfo.place = itemConfig.EquipPlace;
            equipInfos[i] = equipInfo;
        }

        var playerInfo = new GA_PlayerClient.PlayerInfo()
        {
            maxHp = maxHp,
            hp = maxHp,
            level = (ushort)level,
            job = (byte)job,
            face = AvatarHelper.GetAvatarDefaultID(job),
            facePic = AvatarHelper.GetAvatarFrameDefaultID(job),
            pos = Vector3.zero,
            name = playerName,
            itemDatas = equipInfos,
        };

        ulong AtkFightPower = PlayerDatas.Instance.baseData.FightPoint;// 挑战方战力，
        ulong DefFightPower = (ulong)ArenaModel.Instance.GetLevel(level, 2); //防守方战力
        //fight rate
        float rate = GetFightPowerRate(AtkFightPower, DefFightPower);
        Debug.Log("守护者 GetFightPowerRate:" + rate+ "  AtkFightPower:"+ AtkFightPower+ "   DefFightPower:"+ DefFightPower);
        ArenaManager.playInfo[0][0] = (int)(ArenaRobotLVConfig.Get(level).ReMinAtk * rate);
        ArenaManager.playInfo[0][1] = (int)(ArenaRobotLVConfig.Get(level).ReMaxAtk * rate);
        ArenaManager.playInfo[0][2] = (int)(ArenaRobotLVConfig.Get(level).ReDef * rate);
        ArenaManager.playInfo[0][4] = (int)(ArenaRobotLVConfig.Get(level).ReMiss * rate);
        ArenaManager.playInfo[0][3] = (int)(ArenaRobotLVConfig.Get(level).ReHit * rate);

        return playerInfo;
    }
    GA_PlayerClient.PlayerInfo GetRealPlayerInfo(RoleParticularModel.RolePropData propData)
    {
        var equipInfos = new GA_PlayerClient.CEquipInfo[propData.EquipShowID.Length];
        for (int i = 0; i < equipInfos.Length; i++)
        {
            var equipInfo = new GA_PlayerClient.CEquipInfo();
            var itemConfig = ItemConfig.Get(propData.EquipShowID[i]);
            equipInfo.id = itemConfig.ID;
            equipInfo.place = itemConfig.EquipPlace;
            equipInfos[i] = equipInfo;
        }

        var playerInfo = new GA_PlayerClient.PlayerInfo()
        {
            maxHp = (ulong)propData.MaxHP,
            hp = (ulong)propData.MaxHP,
            level = (ushort)propData.LV,
            job = (byte)propData.Job,
            face = (int)propData.Face,
            facePic = (int)propData.FacePic,
            pos = Vector3.zero,
            name = propData.Name,
            itemDatas = equipInfos,
        };
        ulong AtkFightPower = PlayerDatas.Instance.baseData.FightPoint;// 挑战方战力，
        ulong DefFightPower = (ulong)propData.FightPower; //防守方战力
        //fight rate
        float rate = GetFightPowerRate(AtkFightPower, DefFightPower);
        Debug.Log("玩家机器人 GetFightPowerRate:" + rate + "  AtkFightPower:" + AtkFightPower + "   DefFightPower:" + DefFightPower);
        ArenaManager.playInfo[1][0] = (int)(propData.MinAtk * rate);
        ArenaManager.playInfo[1][1] = (int)(propData.MaxAtk * rate);
        ArenaManager.playInfo[1][2] = (int)(propData.Def * rate);
        ArenaManager.playInfo[1][3] = (int)(propData.Hit * rate);
        ArenaManager.playInfo[1][4] = (int)(propData.Miss * rate);
        ArenaManager.playInfo[1][5] = (int)(propData.SkillAtkRate * rate);                              // 技能攻击比例加成
        ArenaManager.playInfo[1][6] = (int)(propData.SkillAtkRateReduce * rate);                 // 技能攻击比例减少
        ArenaManager.playInfo[1][7] = (int)(propData.LuckyHitRate * rate);                        // 会心一击几率
        ArenaManager.playInfo[1][8] = (int)(propData.LuckyHitVal * rate);                            // 会心一击伤害固定值
        ArenaManager.playInfo[1][9] = (int)(propData.LuckyHitRateReduce * rate);               // 会心一击概率抗性
        ArenaManager.playInfo[1][10] = (int)(propData.LuckyHitReduce * rate);                      // 会心一击伤害减免固定值
        ArenaManager.playInfo[1][11] = (int)(propData.SuperHitRate * rate);                        // 暴击概率
        ArenaManager.playInfo[1][12] = (int)(propData.SuperHit * rate);                             // 暴击伤害固定值
        ArenaManager.playInfo[1][13] = (int)(propData.SuperHitRateReduce * rate);            // 暴击概率抗性
        ArenaManager.playInfo[1][14] = (int)(propData.SuperHitReduce * rate);                    // 暴击伤害抗性固定值
        ArenaManager.playInfo[1][15] = (int)(propData.IceAtk * rate);                                  // 真实伤害            固定值
        ArenaManager.playInfo[1][16] = (int)(propData.IceDef * rate);                                  // 真实伤害防御        固定值
        ArenaManager.playInfo[1][17] = (int)(propData.IgnoreDefRate * rate);                     // 无视防御几率
        ArenaManager.playInfo[1][18] = (int)(propData.IgnoreDefRateReduce * rate);          // 无视防御概率抗性
        ArenaManager.playInfo[1][19] = (int)(propData.IgnoreDefReducePer * rate);          // 无视防御伤害减免
        ArenaManager.playInfo[1][20] = (int)(propData.DamagePVE * rate);                       //伤害输出计算固定值PVE
        ArenaManager.playInfo[1][21] = (int)(propData.DamagePerPVP * rate);                // 伤害输出计算百分比PVP
        ArenaManager.playInfo[1][22] = (int)(propData.DamagePerPVPReduce * rate);      //伤害输出计算百分比PVP减少
        ArenaManager.playInfo[1][23] = (int)(propData.DamagePVP * rate);                       // PVP固定伤害
        ArenaManager.playInfo[1][24] = (int)(propData.DamagePVPReduce * rate);          // PVP固定减伤
        ArenaManager.playInfo[1][25] = (int)(propData.FinalHurt * rate);                            // 最终固定伤害增加
        ArenaManager.playInfo[1][26] = (int)(propData.FinalHurtReduce * rate);              // 最终固定伤害减少
        ArenaManager.playInfo[1][27] = (int)(propData.FinalHurtPer * rate);                    // 最终伤害百分比
        ArenaManager.playInfo[1][28] = (int)(propData.FinalHurtReducePer * rate);         // 最终伤害减少百分比
        ArenaManager.playInfo[1][29] = (int)(propData.OnlyFinalHurt * rate);                   // 额外输出伤害
        ArenaManager.playInfo[1][30] = (int)(propData.DamChanceDef * rate);              // 20%的概率抵御伤害比率
        ArenaManager.playInfo[1][31] = (int)(propData.NPCHurtAddPer * rate);              // 对怪物伤害加成
        ArenaManager.playInfo[1][32] = (int)(propData.RealmLV);              // 境界

        //    ArenaManager.playInfo[1][32] = (int)(propData.AtkBackHPPer * rate);               //攻击回复血量固定值
        //    ArenaManager.playInfo[1][33] = (int)(propData.PVPAtkBackHP * rate);              //PVP攻击回血
        //    ArenaManager.playInfo[1][34] = (int)(propData.FaintRate * rate);                        //击晕概率
        //    ArenaManager.playInfo[1][35] = (int)(propData.FaintDefRate * rate);                  //击晕抵抗概率

        return playerInfo;
    }
    private IEnumerator WaitForPlayerCreate()
    {
        while (opponentPlayer == null)
        {
            yield return null;
        }

        if (pkStageType != ILPKStageType.Fight)
        {
            opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
            currentStage = new ILWaitStartStage();
            currentStage.Begin();
        }
    }
    void OnILStageUpdate()
    {
        if (currentStage != null)
        {
            currentStage.Update();
            if (currentStage.completed)
            {
                currentStage.End();
                switch (pkStageType)
                {
                    case ILPKStageType.WaitStart:
                        currentStage = new ILFightStage();
                        break;
                    case ILPKStageType.Fight:
                        if (fightInfo.isOver)
                        {
                            currentStage = new ILFightOverStage();
                        }
                        else
                        {
                            currentStage = new ILRoundPrepareState();
                        }
                        break;
                    case ILPKStageType.RoundPrepare:
                        //currentStage = new ILFightStage();
                        break;
                    case ILPKStageType.FightOver:
                        currentStage = null;
                        break;
                    default:
                        break;
                }

                if (currentStage != null)
                {
                    currentStage.Begin();
                }
            }
        }
    }
   
    public abstract class ILPKStage
    {
        public float timer { get; protected set; }
        public float duration { get; protected set; }
        public bool completed { get; protected set; }

        public abstract void Begin();
        public abstract void Update();
        public abstract void End();
    }

    public class ILWaitStartStage : ILPKStage
    {
        public override void Begin()
        {
            pkStageType = ILPKStageType.WaitStart;
            duration = ArenaManagerModel.Instance.s_StepTimes[1];
            
            opponentPlayer.ActorInfo.serverDie = false;
            opponentPlayer.IdleImmediate();

            PlayerDatas.Instance.baseData.HP = PlayerDatas.Instance.extersion.MaxHP;
            var maxHp = PlayerDatas.Instance.extersion.MaxHP;
            PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)maxHp, (long)maxHp);
            PlayerDatas.Instance.FightRefreshPlayerHp(maxHp);
            PlayerDatas.Instance.hero.IdleImmediate();
            PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
            PlayerDatas.Instance.hero.StopPathFind();

            opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
            PlayerDatas.Instance.hero.Pos = ArenaModel.Instance.myPlace == 1 ? leftBornPoint : rightBornPoint;
            ArenaModel.Instance.FakeWaitFight((int)duration);

            ArenaModel.Instance.CallUpdatePKInfo(1);
        }

        public override void End()
        {
            fightInfo.roundCount++;
            ArenaModel.Instance.FakeRoundBegin(fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration && opponentPlayer != null;
        }
    }
    public class ILFightOverStage : ILPKStage
    {
        public override void Begin()
        {
            if (ArenaModel.Instance.WinnerID != PlayerDatas.Instance.baseData.PlayerID)
            {
                ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID, 2);
                LocalSave.SetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId, "");
            }
            else
            {
                ArenaModel.Instance.SendArenaBattle(ArenaModel.Instance.m_PlayerInfo[ArenaModel.Instance.SelectMatchPlayer].PlayerID, 1);
                string MatchInfoPlayerFightNow = LocalSave.GetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId);
                if(MatchInfoPlayerFightNow != "")
                {
                    string inputString = LocalSave.GetString("MatchInfoPlayerFight" + PlayerDatas.Instance.PlayerId);
                    inputString = StringUtility.Contact(inputString, "|", MatchInfoPlayerFightNow);
                    LocalSave.SetString("MatchInfoPlayerFight" + PlayerDatas.Instance.PlayerId, inputString);
                    LocalSave.SetString("MatchInfoPlayerFightNow" + PlayerDatas.Instance.PlayerId,"");
                }
            }

            pkStageType = ILPKStageType.FightOver;
            duration = ArenaManagerModel.Instance.s_StepTimes[2];
            
            ArenaModel.Instance.FakeDungeonExit((int)duration);
        }

        public override void End()
        {
            if (ArenaManager.isArenaClient)
            {
                ArenaModel.Instance.StopClientArena();
            }
            WindowCenter.Instance.CloseIL<ArenaSettlementWin>();
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration;
        }

    }
    public class ILFightStage : ILPKStage
    {
        bool figthCompleted = false;
        float restTime = 2f;
        float restTimeTimer = 0f;
  
       
        public override void Begin()
        {
            pkStageType = ILPKStageType.Fight;
            duration = ArenaManagerModel.Instance.s_StepTimes[0];
            roundWiner = 0;
            figthCompleted = false;
            restTimeTimer = 0f;

            opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
            PlayerDatas.Instance.hero.Behaviour.StartHandupAI();
            ArenaModel.Instance.bILAI = true;
            opponentPlayer.SelectTarget = PlayerDatas.Instance.hero;
            PlayerDatas.Instance.hero.SelectTarget = opponentPlayer;
        }

        public override void End()
        {
            ArenaManagerModel.Instance.fightStart = false;
            fightInfo.roundWinnerIds.Add(roundWiner);//记录获胜者的id
            if (fightInfo.roundCount >= 1)
            {
                fightInfo.isOver = true;
            }

            if (fightInfo.isOver)
            {
                PersonalEnemy.ReleaseILPlayer(opponentPlayer,false);
                opponentPlayer.Destroy();
            }

            ArenaModel.Instance.FakeRoundEnd(fightInfo.isOver, fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            if (!ArenaManagerModel.Instance.fightStart)
                return;
            if (PlayerDatas.Instance.hero == null)
                return;
            timer += Time.deltaTime;
            if (PlayerDatas.Instance.hero.ActorInfo.Hp <= 0)
            {
                figthCompleted = true;
                PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                PlayerDatas.Instance.hero.StopPathFind();
                ArenaModel.Instance.bILAI = false;
                roundWiner = ArenaModel.Instance.OPPONENT_PLAYERID;
                ArenaModel.Instance.WinnerID = ArenaModel.Instance.OPPONENT_PLAYERID;
            }
            if (opponentPlayer.ActorInfo.Hp <= 0)
            {
                figthCompleted = true;
                PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                PlayerDatas.Instance.hero.StopPathFind();
                ArenaModel.Instance.bILAI = false;
                roundWiner = PlayerDatas.Instance.baseData.PlayerID; 
                ArenaModel.Instance.WinnerID = PlayerDatas.Instance.baseData.PlayerID; 
            }
            if (!figthCompleted)
            {
                var surplus = ArenaManagerModel.Instance.dungeonEndTime - TimeUtility.ServerNow;
                int EndTime = Mathf.CeilToInt((float)surplus.TotalSeconds);

                if (roundWiner != 0)
                {
                    figthCompleted = true;
                    PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                    PlayerDatas.Instance.hero.StopPathFind();
                    ArenaModel.Instance.bILAI = false;
                }
                else if (EndTime <= 0)
                //else if (timer >= duration)
                {
                    figthCompleted = true;
                    PlayerDatas.Instance.hero.Behaviour.StopHandupAI(true);
                    PlayerDatas.Instance.hero.StopPathFind();
                    ArenaModel.Instance.bILAI = false;
                    if (opponentPlayer.ActorInfo.RealHp <= 0)
                    {
                        roundWiner = PlayerDatas.Instance.baseData.PlayerID;
                    }
                    else
                    {
                        roundWiner = ArenaModel.Instance.OPPONENT_PLAYERID;
                    }
                    ArenaModel.Instance.WinnerID = roundWiner;
                }
                else
                {
                    figthCompleted = false;
                }
            }

            if (figthCompleted)
            {
                restTimeTimer += Time.deltaTime;
                completed = restTimeTimer >= restTime;
            }
        }

    }

    public class ILRoundPrepareState : ILPKStage
    {
        public override void Begin()
        {
            pkStageType = ILPKStageType.RoundPrepare;
            GA_PVPClientPlayer.AutoAI(false);
            duration = 3f;
            Debug.LogFormat("进入阶段：{0}", pkStageType);

            if (fightInfo.roundWinnerIds[fightInfo.roundWinnerIds.Count - 1] == PlayerDatas.Instance.baseData.PlayerID)
            {
                if (!opponentPlayer.ActorInfo.serverDie)
                {
                    PersonalEnemy.ReleaseILPlayer(opponentPlayer, false);
                    opponentPlayer = null;
                }
                playerInfo.hp = playerInfo.maxHp;
                PersonalEnemy.Create(30000, ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint, playerInfo,false);
                PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
                SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());

                if (PlayerDatas.Instance.hero.ActorInfo.RealHp <= 0)
                {
                    PlayerDatas.Instance.baseData.HP = 1;
                    PlayerDatas.Instance.hero.ActorInfo.ResetHp(1, (long)PlayerDatas.Instance.extersion.MaxHP);
                    PlayerDatas.Instance.FightRefreshPlayerHp(1);
                    PlayerDatas.Instance.hero.IdleImmediate();
                }
            }
            else
            {
                PlayerDatas.Instance.baseData.HP = PlayerDatas.Instance.extersion.MaxHP;
                var maxHp = PlayerDatas.Instance.extersion.MaxHP;
                PlayerDatas.Instance.hero.ActorInfo.ResetHp((long)maxHp, (long)maxHp);
                PlayerDatas.Instance.FightRefreshPlayerHp(maxHp);
                PlayerDatas.Instance.hero.IdleImmediate();                

                if (opponentPlayer.ActorInfo.RealHp <= 0)
                {
                    opponentPlayer = null;
                    playerInfo.hp = 1;
                    PersonalEnemy.Create(30000, rightBornPoint, playerInfo,false);
                    PersonalEnemy.OnILPlayerAppear += OnPlayerAppear;
                    SnxxzGame.Instance.StartCoroutine(WaitForPlayerCreate());
                }
            }

            PlayerDatas.Instance.hero.Pos = ArenaModel.Instance.myPlace == 1 ? leftBornPoint : rightBornPoint;

        }

        private void OnPlayerAppear(GA_ILClientPlayer player)
        {
            PersonalEnemy.OnILPlayerAppear -= OnPlayerAppear;
            opponentPlayer = player;
            opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
        }

        private IEnumerator WaitForPlayerCreate()
        {
            while (opponentPlayer == null)
            {
                yield return null;
            }

            opponentPlayer.Pos = ArenaModel.Instance.myPlace == 1 ? rightBornPoint : leftBornPoint;
            opponentPlayer.ActorInfo.ResetHp((long)playerInfo.maxHp, (long)playerInfo.maxHp);
        }

        public override void End()
        {
            fightInfo.roundCount++;
            ArenaModel.Instance.FakeRoundBegin(fightInfo.roundCount, fightInfo.roundWinnerIds.ToArray());
        }

        public override void Update()
        {
            timer += Time.deltaTime;
            completed = timer >= duration && opponentPlayer != null;
        }
    }

    public enum ILPKStageType
    {
        WaitStart,
        Fight,
        RoundPrepare,
        FightOver,
    }

    public struct ILFightInfo
    {
        public int myBornPoint;
        public bool isOver;
        public int roundCount;
        public List<uint> roundWinnerIds;
    }
}