using Snxxz.UI;
using System.Collections;

using UnityEngine;
using UnityEngine.Events;

public class GA_Hero : GActorPlayerBase, ICtrlGA
{
    public static Vector3 MapOffset;
    public static bool s_MapSwitching = false;
    //public static bool s_MapSwitching
    //{
    //    get
    //    {
    //        return _s_MapSwitching;
    //    }
    //    set
    //    {
    //        _s_MapSwitching = value;
    //        Debug.Log("---------- MapSwitching: " + value);
    //    }
    //}

    /// <summary>
    /// 当切换锁定目标的时候, 为空的时候id=0
    /// </summary>
    public static event UnityAction<uint> OnLockTargetChanged;
    public static void CallLockTargetChanged(uint sid)
    {
        if (OnLockTargetChanged != null)
        {
            OnLockTargetChanged(sid);
#if UNITY_EDITOR
            Debug.LogFormat("<color=red>执行了切换锁定目标的逻辑: {0}</color>", sid);
#endif
        }
    }

    public static event UnityAction<uint, string> OnKillPlayer;

    private GameObject m_Light;
    public static bool forceAutoFight;
    /// <summary>
    /// 锁定目标对象
    /// 用户点击锁定, 被攻击锁定攻击者...
    /// </summary>
    private GActor m_LockTarget;
    public GActor LockTarget
    {
        get { return m_LockTarget; }
        set
        {
            if (m_LockTarget == value)
            {
                return;
            }

#if UNITY_EDITOR
            if (m_LockTarget is GA_Player && value != null && !(value is GA_Player))
            {
                Debug.LogFormat("更换了锁定目标: {0} => {1}", m_LockTarget.ServerInstID, value.ServerInstID);
            }
#endif
            m_LockTarget = value;
        }
    }

    public MapArea currentBossArea;

    private uint _atkBossID;
    public uint atkBossID
    {
        get
        {
            return _atkBossID;
        }
        set
        {
            if (_atkBossID != value)
            {
                _atkBossID = value;
                //if (_atkBossID != 0)
                //{
                //    Debug.LogFormat("设置攻击的bossID: {0}", atkBossID);
                //}
                //else
                //{
                //    Debug.LogFormat("清空bossID");
                //}
            }
        }
    }

    public sealed override int NextAction
    {
        get
        {
            return base.NextAction;
        }

        set
        {
            base.NextAction = value;
        }
    }

    public sealed override GActor SelectTarget
    {
        get
        {
            return base.SelectTarget;
        }

        set
        {
            if (base.SelectTarget == value)
            {
                return;
            }

            IOtherSelectable _selectable = base.SelectTarget as IOtherSelectable;
            if (_selectable != null)
            {
                _selectable.OnUnSelect();
            }

            _selectable = value as IOtherSelectable;

            if (_selectable != null)
            {
                _selectable.OnSelect();
            }

            base.SelectTarget = value;
        }
    }

    public HeroBehaviour Behaviour;
    public HeroAIHandler aiHandler;
    private Bhv_FindEnemy m_BhvFindEnemy;
    private float m_LastSyncTickTime = 0;

    protected sealed override void OnInit(GameNetPackBasic package)
    {
        CharacterController _charCtrl = Root.AddMissingComponent<CharacterController>();
        _charCtrl.height = 1.2f;
        _charCtrl.center = new Vector3(0, .6f, 0);
        _charCtrl.radius = .4f;

        Root.gameObject.layer = LayerUtility.Hero;

        m_BhvFindEnemy = Root.AddMissingComponent<Bhv_FindEnemy>();

        JobSetup = JobSetupConfig.Get(PlayerDatas.Instance.baseData.Job);
        Behaviour = new HeroBehaviour(this);
        aiHandler = new HeroAIHandler();

        base.OnInit(package);

        ActorInfo.familyID = PlayerDatas.Instance.baseData.Family;

        OnPathFinding += MapTransferUtility.Instance.OnHeroPathFinding;

        UserInputHandler.OnCirclePanelTouched += OnCirclePanelTouched;
        UserInputHandler.OnClickedFloor += OnClickedFloor;
        HeroBehaviour.OnStopHandupAI += OnStopHandupAI;

        m_CalculAutoFightTime = Time.realtimeSinceStartup;

        m_LastSyncTickTime = Time.realtimeSinceStartup;
    }

    private PlayerSuitModel _suitModel;
    private PlayerSuitModel SuitModel
    {
        get { return _suitModel ?? (_suitModel = ModelCenter.Instance.GetModel<PlayerSuitModel>()); }
    }

    private PlayerPackModel m_PlayerBackModel;
    private PlayerPackModel PlayerBackModel
    {
        get
        {
            return m_PlayerBackModel ?? (m_PlayerBackModel = ModelCenter.Instance.GetModel<PlayerPackModel>());
        }
    }

    public override void SyncSuitEffect()
    {
        var _equipModel = PlayerBackModel.GetSinglePackModel(PackType.rptEquip);

        var _suitCount = 0;

        int _start = (int)RoleEquipType.retHat;
        int _end = (int)RoleEquipType.retShoes;
        int _rank = 0;

        ItemModel _itemModel = null;

        // 先取得衣服的阶数
        _itemModel = _equipModel.GetItemModelByIndex((int)RoleEquipType.retClothes);
        if (_itemModel == null)
        {
            return;
        }

        _rank = _itemModel.chinItemModel.LV;

        for (int i = _start; i <= _end; ++i)
        {
            _itemModel = _equipModel.GetItemModelByIndex(i);

            if (_itemModel == null)
            {
                continue;
            }

            if (_itemModel.chinItemModel.SuiteiD <= 0)
            {
                continue;
            }

            if (SuitModel.suitModelDict.ContainsKey(i))
            {
                if (SuitModel.suitModelDict[i].ContainsKey(1)
                 || SuitModel.suitModelDict[i].ContainsKey(2))
                {
                    if (_itemModel.chinItemModel.LV >= _rank)
                    {
                        _suitCount += 1;
                    }
                }
            }
        }

        if (m_SuitCount == _suitCount)
        {
            return;
        }

        if (m_SuitCount < 5 && _suitCount < 5)
        {
            m_SuitCount = _suitCount;
            return;
        }

        if (_suitCount == 5)
        {
            var _itemConfig = ItemConfig.Get((int)ClothesItemID);
            if (_itemConfig != null)
            {
                var _newMat = MaterialLoader.LoadClothesMaterial(_itemConfig.ChangeOrd, false, true);
                if (_newMat)
                {
                    m_SMRenderer.material = m_Material = _newMat;
                    MaterialUtility.SwitchXrayShader(m_SMRenderer.material, this is GA_Hero);
                }
            }
        }
        else
        {
            var _itemConfig = ItemConfig.Get((int)ClothesItemID);
            if (_itemConfig != null)
            {
                var _newMat = MaterialLoader.LoadClothesMaterial(_itemConfig.ChangeOrd, false, false);
                if (_newMat)
                {
                    m_SMRenderer.material = m_Material = _newMat;
                    MaterialUtility.SwitchXrayShader(m_SMRenderer.material, this is GA_Hero);
                }
            }
        }

        m_SuitCount = _suitCount;
    }

    protected sealed override void OnUnit()
    {
        Object.Destroy(m_BhvFindEnemy);
        m_BhvFindEnemy = null;

        OnPathFinding -= MapTransferUtility.Instance.OnHeroPathFinding;
        OnPathFindStop -= MapTransferUtility.Instance.OnHeroStopPathFind;

        Behaviour = null;
        m_LockTarget = null;

        MaterialUtility.SwitchXrayShader(m_Material, false);
        MaterialUtility.SwitchXrayShader(m_WingMaterial, false);
        MaterialUtility.SwitchXrayShader(m_HorseMaterial, false);
        MaterialUtility.SwitchXrayShader(m_WeaponMaterial, false);
        MaterialUtility.SwitchXrayShader(m_SecondaryMaterial, false);

        m_WingMaterial = null;
        m_HorseMaterial = null;
        m_WeaponMaterial = null;
        m_SecondaryMaterial = null;

        ReleaseLight();

        base.OnUnit();
    }

    public sealed override void Destroy()
    {
    }

    public float forceAutoFightTime;

    private float m_ChkOpenAutoEscapeTime;

    private DungeonModel m_DungeonModel;
    public DungeonModel dungeonModel { get { return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>()); } }

    protected sealed override void OnUpdate()
    {
        base.OnUpdate();

        if (!forceAutoFight)
        {
            if (Time.realtimeSinceStartup - m_ChkOpenAutoEscapeTime > 2f)
            {
                int _dgDataID = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
                if (DungeonOpenTimeConfig.Has(_dgDataID))
                {
                    var dungeonOpen = DungeonOpenTimeConfig.Get(_dgDataID);
                    if (dungeonOpen.DoFight == 1)
                    {
                        forceAutoFight = true;
                    }
                }

                m_ChkOpenAutoEscapeTime = Time.realtimeSinceStartup;
            }
        }

        if (forceAutoFight
#if UNITY_EDITOR
            && RuntimeLogUtility.s_forceAutoFight
#endif
            && !CrossServerUtility.IsCrossServerOneVsOne())
        {
            if (!aiHandler.IsAuto() && !BossShowModel.Instance.BossShowing)
            {
                if (IsIdle())
                {
                    if (Time.realtimeSinceStartup - forceAutoFightTime > 6)
                    {
                        Behaviour.StartHandupAI();
                    }
                }
                else
                {
                    forceAutoFightTime = Time.realtimeSinceStartup;
                }
            }
        }

        aiHandler.Update();

        bool _isCastSkill = false;

        if (SkillMgr.CurCastSkill != null)
        {
            _isCastSkill = !SkillMgr.CurCastSkill.SkillCompelete;
        }

        // 每隔1分钟同步一次tick
        if (Time.realtimeSinceStartup - m_LastSyncTickTime > 60)
        {
            PlayerDatas.Instance.RequestWorldTick();
            m_LastSyncTickTime = Time.realtimeSinceStartup;
        }

        if ((IsRun() || IsIdle() || UserInputHandler.isTouched) && UserInputHandler.IsMoveValid())
        {
            float _distance = MathUtility.DistanceSqrtXZ(PrevPos, Pos);
            if (_distance > 0.25f)
            {
                PrevPos = Pos;
                UserInputHandler.Send_CB409_tagCMPyMove();
            }
        }

        HandleBossAttack();

        if (CrossServerUtility.IsCrossServerOneVsOne())
        {
            if (SelectTarget is GActorNpcFight)
            {
                GAMgr.Instance.Release(SelectTarget);
                SelectTarget = null;
            }

            if (LockTarget is GActorNpcFight || LockTarget == null)
            {
                var _list = GAMgr.Instance.GetTypeList(E_ActorClassType.Player);
                if (_list != null && _list.Count > 0)
                {
                    LockTarget = _list[0];
                }
            }
        }
    }

    private void HandleBossAttack()
    {
        if (PlayerDatas.Instance.extersion.bossState != 1)
        {
            return;
        }

        if (LockTarget != null)
        {
            return;
        }

        GA_Player _player = SelectTarget as GA_Player;

        if (_player == null)
        {
            return;
        }

        foreach (var _key in DungeonStage.s_MapAreaDict.Keys)
        {
            if ((int)_key < 3000)
            {
                continue;
            }

            var _areaList = DungeonStage.s_MapAreaDict[_key];
            if (_areaList == null)
            {
                continue;
            }

            MapArea _area = null;
            for (int i = 0; i < _areaList.Count; ++i)
            {
                _area = _areaList[i];
                if (_area != currentBossArea)
                {
                    continue;
                }

                if (_area.IsPosOut(_player.Pos))
                {
                    SelectTarget = null;
                    if (atkBossID != 0)
                    {
                        MapTransferUtility.Instance.MoveToNPC((int)atkBossID);
                    }
                }
            }
        }
    }

    protected sealed override void OnFixedUpdate()
    {
        base.OnFixedUpdate();

        if (IsRushing)
        {
            m_RushTime += Time.deltaTime;
            if (m_RushTime > 2)
            {
                StopRush();
            }
        }

        if (PlayerDatas.Instance.baseData.MapID == 31340)
        {
            if (State == E_ActorState.AutoRun
            || State == E_ActorState.CtrlRun)
            {
                var _collect = GAMgr.Instance.GetCloserCollectNpc(Pos) as GA_NpcCollect;

                if (_collect != null)
                {
                    var _dist = MathUtility.DistanceSqrtXZ(_collect.Pos, Pos);

                    if (_dist < 6)
                    {
                        if ((SelectTarget == null || SelectTarget is GA_NpcCollect) && SelectTarget != _collect)
                        {
                            SelectTarget = _collect;
                            _collect.Arrive();
                        }
                    }
                }
            }
            else if (State == E_ActorState.Idle)
            {
                if (SelectTarget == null)
                {
                    var _collect = GAMgr.Instance.GetCloserCollectNpc(Pos) as GA_NpcCollect;

                    if (_collect != null)
                    {
                        var _dist = MathUtility.DistanceSqrtXZ(_collect.Pos, Pos);

                        if (_dist < 6)
                        {
                            SelectTarget = _collect;
                            _collect.Arrive();
                        }
                    }
                }
            }
        }
    }

    protected sealed override void OnLateUpdate()
    {
        base.OnLateUpdate();

        UpdateAutoStartFight();
    }

    protected sealed override void OnPutonClothes(uint clothesItemID, GameObject clothed)
    {
        clothed.layer = LayerUtility.Hero;

        SkinnedMeshRenderer _renderer = clothed.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        MaterialUtility.SwitchXrayShader(m_Material, true);
        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(clothed.GetInstanceID());

        StopRush();

        Behaviour.StopKillUntilDieAI();

        int _level = PlayerDatas.Instance.baseData.godWeaponLV_4;
        if (EquipShowSwitch.IsGodWeaponEffectOn(PlayerDatas.Instance.baseData.equipShowSwitch, 4, out _level))
        {
            SwitchGodWeapon(4, _level);
        }
        else
        {
            SwitchGodWeapon(4, 0);
        }
        _level = PlayerDatas.Instance.baseData.godWeaponLV_1;
        if (EquipShowSwitch.IsGodWeaponEffectOn(PlayerDatas.Instance.baseData.equipShowSwitch, 1, out _level))
        {
            SwitchGodWeapon(1, _level);
        }
        else
        {
            SwitchGodWeapon(1, 0);
        }

        _level = PlayerDatas.Instance.baseData.godWeaponLV_2;
        _level = PlayerDatas.Instance.baseData.godWeaponLV_2;
        if (EquipShowSwitch.IsGodWeaponEffectOn(PlayerDatas.Instance.baseData.equipShowSwitch, 2, out _level))
        {
            SwitchGodWeapon(2, _level);
        }
        else
        {
            SwitchGodWeapon(2, 0);
        }
    }

    protected sealed override void OnPutonSecondary(uint secondaryItemID, GameObject secondary)
    {
        if (secondary)
        {
            Renderer _renderer = secondary.GetComponent<Renderer>();
            if (_renderer)
            {
                _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
                m_SecondaryMaterial = _renderer.material;
                MaterialUtility.SwitchXrayShader(m_SecondaryMaterial, true);
            }
            GameObjectPoolManager.Instance.AddDontDestroyGoInstID(secondary.GetInstanceID());
        }
    }

    protected sealed override void OnPutonWeapon(uint weaponItemID, GameObject weapon)
    {
        Renderer _renderer = weapon.GetComponent<Renderer>();
        if (_renderer)
        {
            _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
            m_WeaponMaterial = _renderer.material;
            MaterialUtility.SwitchXrayShader(m_WeaponMaterial, true);
        }
        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(weapon.GetInstanceID());
    }

    protected sealed override void OnPutonWing(uint wingItemID, GameObject wing)
    {
        wing.gameObject.layer = LayerUtility.Hero;

        SkinnedMeshRenderer _renderer = wing.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        m_WingMaterial = _renderer.material;
        MaterialUtility.SwitchXrayShader(m_WingMaterial, true);

        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(wing.GetInstanceID());
    }

    protected sealed override void OnSwitchHorse(uint horseID, GameObject horse)
    {
        horse.layer = LayerUtility.Hero;

        SkinnedMeshRenderer _renderer = horse.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        m_HorseMaterial = _renderer.material;
        MaterialUtility.SwitchXrayShader(m_HorseMaterial, true);

        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(horse.GetInstanceID());
    }

    public override void OnHorse(byte upOrDown)
    {
        if (upOrDown == 1)
        {
            PlayerPackModel _packModel = ModelCenter.Instance.GetModel<PlayerPackModel>();
            SinglePackModel _horsePackModel = _packModel.GetSinglePackModel(PackType.rptEquip);
            if (_horsePackModel != null)
            {
                ItemModel _horseItem = _horsePackModel.GetItemModelByIndex((int)RoleEquipType.mount);
                SwitchHorse((uint)_horseItem.itemInfo.ItemID);
            }
        }
        else
        {
            SwitchHorse(0);
        }
    }

    public sealed override void RefreshLifeBar(ulong value) { }

    public override void RequestName()
    {
        ReleaseName();

        if (MovingState == E_MovingState.Ride)
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Hero, MP_Name1, 0, CameraController.Instance.CameraObject);
        }
        else
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Hero, MP_Name, 0, CameraController.Instance.CameraObject);
        }

        // 称号
        var titleModel = ModelCenter.Instance.GetModel<TitleModel>();
        var _title = titleModel.GetTitleEquip();
        uint _titleID = 0;
        if (_title != null && titleModel.IsTitleGain(_title.id)
            && PlayerDatas.Instance.baseData.MapID != 31160)//上古战场不显示称号
        {
            _titleID = (uint)_title.id;
        }

        var _familyName = string.Empty;
        // 仙盟
        if (PlayerDatas.Instance.baseData.Family != 0)
        {
            _familyName = PlayerDatas.Instance.baseData.FamilyName;
        }

        m_HeadUpName.SetPlayerInfo(PlayerDatas.Instance.baseData.realmLevel, _titleID, PlayerDatas.Instance.baseData.PlayerName, _familyName, false);

        if (StatusMgr.Instance.IsExist(ServerInstID, StatusMgr.Instance.bossBelongBuffID))
        {
            m_HeadUpName.SetBossDropout(true);
        }

        base.SetFairyLeagueHeadUp(PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON);
        CheckAncientHeadUp();
    }

    public sealed override void SwitchRedName(bool on)
    {
        if (PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON)
        {
            return;
        }
        base.SwitchRedName(on);
    }

    public sealed override void SwitchYellowName(bool on)
    {
        if (PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON)
        {
            return;
        }
        base.SwitchYellowName(on);
    }

    public sealed override void Die()
    {
        LockTarget = null;
        SelectTarget = null;

        base.Die();
    }

    public sealed override void Collect()
    {
        if (ActorInfo.serverDie)
        {
            return;
        }

        base.Collect();

        Behaviour.StopKillUntilDieAI();
        Behaviour.StopHandupAI();
    }

    public bool CanMove()
    {
        if (IsHurt()
         || IsRushing
         || ActorInfo.serverDie
         || State == E_ActorState.Mocked
         || IsDaZuo()
         || BossShowModel.Instance.BossShowing
         || heavenBattleModel.IsBattlePrepare)
        {
            return false;
        }

        if (StatusMgr.IsValid()
        && !StatusMgr.Instance.CanMove(ServerInstID))
        {
            return false;
        }

        if (State == E_ActorState.Idle
         || State == E_ActorState.AutoRun
         || State == E_ActorState.CtrlRun)
        {
            return true;
        }

        return false;
    }

    public bool CanRotate()
    {
        return State != E_ActorState.Mocked
            && !IsDaZuo();
    }

    private HeavenBattleModel m_HeavenBattleModel = null;
    public HeavenBattleModel heavenBattleModel
    {
        get
        {
            return m_HeavenBattleModel ?? (m_HeavenBattleModel = ModelCenter.Instance.GetModel<HeavenBattleModel>());
        }
    }

    public bool CanCommonAtk()
    {
        return !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
            && !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe)
            && !IsStun()
            && !IsHurt()
            && !IsDaZuo()
            && State != E_ActorState.Roll
            && !s_MapSwitching
            && !heavenBattleModel.IsBattlePrepare
            && !m_Beating;
    }

    public bool CanCastSkill()
    {
        return !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
            && !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe)
            && !IsStun()
            && !IsHurt()
            && !IsDaZuo()
            && State != E_ActorState.Roll
            && State != E_ActorState.Mocked
            && !s_MapSwitching
            && !heavenBattleModel.IsBattlePrepare
            && !m_Beating;
    }

    public void StopAll()
    {
        Behaviour.StopHandupAI(true);
        Behaviour.StopKillUntilDieAI();

        if (State == E_ActorState.AutoRun
         || PathFindStatus == E_PathFindStatus.Moving)
        {
            StopPathFind();
        }

        if (!ActorInfo.serverDie)
        {
            IdleImmediate();
        }
    }

    public void SwitchTarget()
    {
        if (m_BhvFindEnemy)
        {
            m_BhvFindEnemy.SwitchTarget();
        }
    }

    public void RequestLight()
    {
        ReleaseLight();
        if (PlayerDatas.Instance.baseData.MapID == 31160)
        {
            m_Light = Object.Instantiate(BuiltInLoader.LoadPrefab("Zhujiao_Pointlight"));
            m_Light.transform.SetParent(MP_Name);
            m_Light.transform.localPosition = Vector3.zero;
            m_Light.transform.localScale = Vector3.one;
            m_Light.transform.localRotation = Quaternion.identity;
        }
    }

    public void ReleaseLight()
    {
        if (m_Light)
        {
            Object.Destroy(m_Light);
            m_Light = null;
        }
    }

    public void KillPlayer(uint sid, string name)
    {
#if UNITY_EDITOR
        Debug.LogFormat("杀死了玩家: {0}, {1}", sid, name);
#endif
        if (OnKillPlayer != null)
        {
            OnKillPlayer(sid, name);
        }
    }

    #region 地图区域相关处理

    private int m_CurMapArea = 1 << (int)MapArea.E_Type.Normal;
    public int CurMapArea
    {
        get
        {
            return m_CurMapArea;
        }
        set
        {
            m_CurMapArea = value;
        }
    }

    public static UnityAction<MapArea.E_Type, bool> OnEnterOrExitArea;

    public void EnterArea(int type)
    {
        if (type < 3000)
        {
            CurMapArea |= type;
            if (OnEnterOrExitArea != null)
            {
                OnEnterOrExitArea((MapArea.E_Type)type, true);
            }

            if (type == (int)MapArea.E_Type.RebornSafe
             || type == (int)MapArea.E_Type.Safe)
            {
                if (aiHandler.IsAuto())
                {
                    Behaviour.StopKillUntilDieAI();
                    Behaviour.StopHandupAI();
                }
            }
        }
    }

    public void ExitArea(int type)
    {
        if (type < 3000)
        {
            CurMapArea &= ~type;
            if (OnEnterOrExitArea != null)
            {
                OnEnterOrExitArea((MapArea.E_Type)type, false);
            }
        }
    }

    #endregion

    #region 站前冲锋相关逻辑

    public bool IsNeedRush(float distanceSqrt)
    {
        if (IsRushing)
        {
            return false;
        }

        if (PreFightMission.Instance.IsFinished())
        {
            if (Time.time - m_LastRushTime <= JobSetup.RushInterval * Constants.F_DELTA)
            {
                return false;
            }
        }

        if (JobSetup.RushTargetType == 0
        || (JobSetup.RushTargetType == 2 && SelectTarget is GActorNpcFight)
        || (JobSetup.RushTargetType == 1 && SelectTarget is GA_Player))
        {
            float _minDistSqrt = JobSetup.RushMinDist * Constants.F_DELTA;
            _minDistSqrt *= _minDistSqrt;

            float _maxDistSqrt = JobSetup.RushMaxDist * Constants.F_DELTA;
            _maxDistSqrt *= _maxDistSqrt;

            if (PreFightMission.Instance.IsFinished() == false)
            {
                _minDistSqrt = 1f;
                _maxDistSqrt = 100f;
            }

            if (distanceSqrt > _minDistSqrt && distanceSqrt < _maxDistSqrt)
            {
                return true;
            }
        }

        return false;
    }

    #endregion

    #region 攻击相关逻辑

    public void ComAtk()
    {
        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        if (!CanCommonAtk())
        {
            return;
        }

        if (!PreFightMission.Instance.IsFinished())
        {
            if (SelectTarget != null)
            {
                if (!PathFinder.WalkAble(Pos, SelectTarget.Pos))
                {
                    SelectTarget = GAMgr.Instance.FindAtkTarget(Pos, 10, 360);
                }
            }
        }

        if (UserInputHandler.isTouched)
        {
            int _index = nextComAtkIndex == -1 ? 0 : nextComAtkIndex;
            int _skillID = GetCommonSkillID(_index);
            Skill _skill = SkillMgr.Get(_skillID);
            float _skillDist = _skill.skillInfo.config.AtkDist * .5f;
            GActor _dirTarget = GAMgr.Instance.FindAtkTarget(Pos, _skillDist, 90);
            if (_dirTarget != null)
            {
                LockTarget = _dirTarget;
                SelectTarget = _dirTarget;
            }
        }

        Behaviour.StartKillUntilDieAI();
    }

    public void CastSkill(int skillID)
    {
        if (!PreFightMission.Instance.IsFinished())
        {
            if (SelectTarget != null)
            {
                destForward = -SelectTarget.Forward;
                Forward = destForward;
            }
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        if (!PreFightMission.Instance.IsFinished() && skillID == 190)
        {

        }
        else
        {
            if (!CanCastSkill())
            {
                return;
            }
        }

        Skill _skill = SkillMgr.Get(skillID);
        if (!_skill.IsValid())
        {
            return;
        }

        if (!PreFightMission.Instance.IsFinished())
        {
            if (skillID == 190)
            {
                if (State != E_ActorState.Roll)
                {
                    if (SkillMgr.CurCastSkill != null)
                    {
                        SkillMgr.CurCastSkill.SkillCompelete = true;
                    }

                    Behaviour.StartKillUntilDieAI(skillID);
                    aiHandler.currentType = E_HeroAIType.None;
                    Behaviour.DoAttack(_skill);

                    return;
                }
            }
            else
            {
                if (!PreFightMission.Instance.IsHeroCanCastSkill)
                {
                    return;
                }
            }
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        Behaviour.StartKillUntilDieAI(skillID);
    }

    #endregion

    #region 自动开启自动战斗逻辑

    private float m_CalculAutoFightTime;
    public float calculAutoFightTime { get { return m_CalculAutoFightTime; } }

    PlayerTaskDatas m_TaskModel;
    PlayerTaskDatas taskmodel { get { return m_TaskModel ?? (m_TaskModel = ModelCenter.Instance.GetModel<PlayerTaskDatas>()); } }
    PlayerMainDate m_MainModel;
    PlayerMainDate onMainModel { get { return m_MainModel ?? (m_MainModel = ModelCenter.Instance.GetModel<PlayerMainDate>()); } }

    public float Second = 2.5f;
    private float timeType = 0f;
    private bool isbool = true;
    private void UpdateAutoStartFight()
    {
        timeType += Time.deltaTime;
        if (timeType > Second && !isbool)
        {
            timeType = 0f;
            isbool = true;
        }
        if (timeType > Second && isbool)
        {
            timeType = 0f;
        }
        if (DTCB105_tagMCPlayerWallow.forceOffLine)
        {
            return;
        }

        if (ActorInfo.serverDie)
        {
            return;
        }

        if (taskmodel.IsTaskMove())
        {
            if (Time.realtimeSinceStartup - m_CalculAutoFightTime > taskmodel.TaskAutoTime
                 && !NewBieCenter.Instance.inGuiding
                 && PlayerTaskDatas.IsOPenAutoResolve())
            {
                if (PlayerDatas.Instance.hero != null && PlayerDatas.Instance.hero.State == E_ActorState.AutoRun
             && onMainModel.MoveBool)
                {

                }
                else
                {
                    SnxxzGame.Instance.StartCoroutine(Wait());
                }
            }
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            return;
        }

        // 打坐状态下不自动开始战斗
        if (IsDaZuo())
        {
            return;
        }

        if (!aiHandler.IsAuto())
        {
            if (HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoHangUp))
            {
                if (Time.realtimeSinceStartup - m_CalculAutoFightTime > 60
                 && !NewBieCenter.Instance.inGuiding
                 && PlayerTaskDatas.IsOPenAutoResolve())
                {
                    MapTransferUtility.Instance.Clear();
                    Behaviour.StartHandupAI();
                }
            }
        }
    }
    private IEnumerator Wait()
    {
        if (WindowCenter.Instance.IsOpen("VipExperienceWin") || !WindowCenter.Instance.IsOpen("MainInterfaceWin"))
        {
            yield break;
        }
        yield return WaitingForSecondConst.WaitMS1500;
        if (PlayerDatas.Instance.extersion.bossState == 1)
        {
            yield break;
        }
        var IsAuto = PlayerDatas.Instance.hero.aiHandler.IsAuto();
        var inDungeon = IsDungeon();//是否在副本中
        if (inDungeon || IsAuto)
        {
            yield break;
        }
        if (PlayerDatas.Instance.hero != null && PlayerDatas.Instance.hero.State == E_ActorState.AutoRun
           && onMainModel.MoveBool)
        {
            yield break;
        }
        if (isbool)
        {
            isbool = false;
            taskmodel.TaskMove(taskmodel.currentMission);
        }

    }
    private bool IsDungeon()//判断是否在副本中
    {
        var mapId = PlayerDatas.Instance.baseData.MapID;
        var mapConfig = MapConfig.Get(mapId);
        return mapConfig != null && mapConfig.MapFBType != 0;
    }
    private SFXController m_ArrowEffect;

    public void ShowArrow(bool showOrHide)
    {
        if (showOrHide)
        {
            if (!m_ArrowEffect)
            {
                m_ArrowEffect = SFXPlayUtility.Instance.PlayBattleEffect(1052, this);
                if (PlayerDatas.Instance.baseData.MapID == 31230)
                {
                    FaceTargetXZ _f = m_ArrowEffect.gameObject.AddComponent<FaceTargetXZ>();
                    _f.targetPos = new Vector3(5.877f, 7.73f, 20.243f);
                }
            }
        }
        else
        {
            if (m_ArrowEffect)
            {
                FaceTargetXZ _f = m_ArrowEffect.GetComponent<FaceTargetXZ>();
                Object.Destroy(_f);
                SFXPlayUtility.Instance.Release(m_ArrowEffect);
                m_ArrowEffect = null;
            }
        }
    }

    private void OnClickedFloor(Vector3 dest)
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    private void OnCirclePanelTouched()
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    private void OnStopHandupAI()
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    #endregion
}