//#define FIGHT_TEST
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System;
using DG.Tweening;
using BehaviorDesigner.Runtime;
using BehaviorDesigner.Runtime.Tasks;
using UnityEngine.AI;
using YLBattle;
using UnityGameFramework.Runtime;
using AdonGameKit;
using Adon.Game.BO;

/// <summary>
/// 角色管理者
/// </summary>
public class RoleManager : MonoBehaviour
{
    // <summary>
    /// 单键
    /// </summary>
    private static RoleManager m_Instance;

    /// <summary>
    /// 已创建的怪物角色
    /// </summary>
    public Dictionary<int, List<Role>> mCreateMonsterRoles = new Dictionary<int, List<Role>>();

    /// <summary>
    /// 玩家创建的角色
    /// </summary>
    private Dictionary<int, Role> mPlayerRoles = new Dictionary<int, Role>();

    private Dictionary<int, Role> mFriendRoles = new Dictionary<int, Role>();

    ///// <summary>
    ///// 玩家镜像角色
    ///// </summary>
    //private List<Role> mMirrorPlayerRoles = new List<Role>();

    /// <summary>
    /// 英雄的数据
    /// </summary>
    private List<GameHeroVo> mHeroVos = new List<GameHeroVo>();

    ///// <summary>
    ///// 玩家镜像的英雄数据
    ///// </summary>
    //private List<GameHeroVo> mMirrorHeroVos = new List<GameHeroVo>();

    /// <summary>
    /// 当前的区域
    /// </summary>
    private int mCurArea = 1;

    /// <summary>
    /// 创建的言灵
    /// </summary>
    private Dictionary<int, YanLingBattleInfo> mCreateYanLings = new Dictionary<int, YanLingBattleInfo>();

    /// <summary>
    /// 本场角色资源数据
    /// </summary>
    private Dictionary<string, int> mRoleRes = new Dictionary<string, int>();

    /// <summary>
    /// 镜像的行为树
    /// </summary>
    private List<BehaviorTree> mMirrorBTS = new List<BehaviorTree>();

    private List<Role> mMonsterList = new List<Role>();

    /// <summary>
    /// 言灵资源
    /// </summary>
    private List<string> mYanLingRess = new List<string>();

    private bool _bossLive = false;

    private Vector3 diePos;

    /// <summary>
    /// 传送门
    /// </summary>
    private ChuanSongMen chuanSongMen = null;

    public bool BoosLive
    {
        get
        {
            return this._bossLive;
        }
    }

    /// <summary>
    /// 刷新时间
    /// </summary>
    private float _refreshTime = 1.0f;

    /// <summary>
    /// 刷新计时器
    /// </summary>
    private float _refreshNowTime = 0.0f;

    /// <summary>
    ///  上次的玩家索引
    /// </summary>
    private int lastPlayerIndex = -1;
    private int curPlayerIndex = -1;
    
    /// <summary>
    /// 单键
    /// </summary>
    public static RoleManager Instance
    {
        get
        {
            if (m_Instance == null)
            {
                m_Instance = GameObject.Find("RoleManager").AddComponent<RoleManager>();
            }

            return m_Instance;
        }
    }

    public void SetFriendPosition(string uid, float x, float y, float z)
    {
        foreach (var r in this.mFriendRoles)
        {
            if (uid == r.Value.playerUID)
            {
                Vector3 pos = new Vector3(x, y, z);
                r.Value.mNavMeshAgent.SetDestination(pos);
                float speed = (pos - r.Value.transform.position).magnitude;
                if (speed > 1.0f)
                {
                    speed = 1;
                }
                else if (speed < 0.05f)
                {
                    speed = 0;
                }
                r.Value.mAnimator.SetFloat(Animator.StringToHash("ForwardSpeed"), speed);
            }
        }
    }

    public void SetFiendStatus(string uid, string propertyName, string pValue)
    {
        foreach (var r in this.mFriendRoles)
        {
            if (uid == r.Value.playerUID)
            {
                switch (propertyName)
                {
                    case "SetBool":
                        {
                            Adon.Game.Data.StructData.Attack_MsgData msgData = new Adon.Game.Data.StructData.Attack_MsgData();
                            CommonManager.Desrialize<Adon.Game.Data.StructData.Attack_MsgData>(msgData, pValue);
                            BaseHero bh = r.Value.gameObject.GetComponent<BaseHero>();
                            bh.SetAnimatorStatusAttack(msgData);
                        }

                        break;
                    case "SetTrigger":
                        r.Value.mAnimator.SetTrigger(int.Parse(pValue));
                        break;
                    case "DashAttack":
                        {
                            Adon.Game.Data.StructData.Rush_MsgData msgData = new Adon.Game.Data.StructData.Rush_MsgData();
                            CommonManager.Desrialize<Adon.Game.Data.StructData.Rush_MsgData>(msgData, pValue);
                            BaseHero bh = r.Value.gameObject.GetComponent<BaseHero>();
                            bh.OnMsg_DashAttack(msgData);
                        }
                        break;
                    case "Rush":
                        {
                            BaseHero bh = r.Value.gameObject.GetComponent<BaseHero>();
                            bh.SetAnimatorStatusRush();
                        }
                        break;
                    case "Skill":
                        {
                            BaseHero bh = r.Value.gameObject.GetComponent<BaseHero>();
                            bh.SetAnimatorStatusSkill();
                        }
                        break;
                    case "Idle":
                        {
                            BaseHero bh = r.Value.gameObject.GetComponent<BaseHero>();
                            bh.SetAnimatorStatusIdle();
                        }
                        break;
                }
                //r.Value.mAnimator.SetBool(int.Parse(propertyName), bool.Parse(pValue));
            }
        }
    }

    public void SetDiePosition(Vector3 pos)
    {
        diePos = pos;
    }
    /// <summary>
    /// 获取玩家
    /// </summary>
    public Role GetPlayer(bool containHide = false)
    {
        foreach (var item in mPlayerRoles)
        {
            if (item.Value == null)
            {
                continue;
            }

            if (containHide)
            {
                return item.Value;
            }
            else if (item.Value.gameObject.activeSelf)
            {
                return item.Value;
            }
        }

        return null;
    }

    // 刷新玩家数据
    public void UpdatePlayerDate()
    {
        foreach (var item in mPlayerRoles)
        {
            if (item.Value == null)
            {
                continue;
            }

            BattleUnitBase battleUnitBase = item.Value as BattleUnitBase;
            battleUnitBase.Init(new YLBattleUnit(item.Value.mData.mHeroVo.mo, item.Value.mData.mHeroVo));
        }
    }

    /// <summary>
    /// 通过自然id 返回
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public Role GetRole(int id)
    {
        // 在我的英雄里查找
        foreach (var item in mPlayerRoles)
        {
            if (item.Value != null && id == item.Value.mData.UID)
            {
                return item.Value;
            }
        }

        // 在创建的怪物中查找
        foreach (var area in this.mCreateMonsterRoles)
        {
            foreach (var role in area.Value)
            {
                if (role != null && id == role.mData.UID)
                {
                    return role;
                }
            }
        }

        return null;
    }

    /// <summary>
    /// 获取生存的怪物
    /// </summary>
    /// <returns></returns>
    public List<Role> GetLiveMonsters()
    {
        mMonsterList.Clear();
        foreach (var item in mCreateMonsterRoles)
        {
            foreach (var monster in item.Value)
            {
                mMonsterList.Add(monster);
            }
        }
        return mMonsterList;
    }

    /// <summary>
    /// 初始化英雄
    /// </summary>
    public void InitHeros(bool isGuide = false)
    {
        mCreateYanLings.Clear();
        mHeroVos.Clear();
        //mMirrorHeroVos.Clear();
        //mMirrorPlayerRoles.Clear();

        var teamVo = UserProxy.Instance.player.heroTeamConfig;
        Ins_TeamInfo curVo = teamVo.teamDic[teamVo.curUseTeamID];

        // 获取队伍角色
        for (int i = 0; i < curVo.heros.Count; i++)
        {
            GameHeroVo heroVo = UserProxy.Instance.player.collectHero.GetHeroGameInfoByHeroUId(curVo.heros[i]);
            if (heroVo != null)
            {
                heroVo.isLocked = false;
                mHeroVos.Add(heroVo);
            }
        }

        // 创建角色
        if (!isGuide)
        {
            StartCoroutine("CreatePlayers", 0);
            StartCoroutine("CreatePlayers", 1);
            StartCoroutine("CreatePlayers", 2);
        }
        // 挂载战报系统
        this.gameObject.AddComponent<WarReport.WarReportShowAdapter>();
    }

    /// <summary>
    /// 初始化挑战英雄
    /// </summary>
    public void InitChallengeHeros()
    {
        mCreateYanLings.Clear();
        mHeroVos.Clear();
        //mMirrorHeroVos.Clear();
        //mMirrorPlayerRoles.Clear();

        VSHeroInfo _heroInfo = LevelManager.Instance().mParameter as VSHeroInfo;
        if (_heroInfo == null)
        {
            Debug.LogError("挑战镜像数据异常！！！");
            return;
        }

        mHeroVos.AddRange(_heroInfo.selfHeros);
        //mMirrorHeroVos.AddRange(_heroInfo.otherHeros);
    }

    /// <summary>
    /// 设置玩家角色
    /// </summary>
    /// <param name="index">角色索引</param>
    public IEnumerator CreatePlayers(int index)
    {
        if (index >= 0 && index < mHeroVos.Count)
        {
            // 存在
            if (mPlayerRoles.ContainsKey(index))
            {
                yield break; ;
            }

            // 创建 默认地图出生点
            Vector3 createPos = Vector3.zero;
            Quaternion createRotation = Quaternion.identity;
            // 返回副本记录点
            if (GameDateManager.Instance.IsBackDoor)
            {
                createPos = GameDateManager.Instance.CreatePosition;
            }
            // 返回据点传送阵 MapTcpProxy.Instance.Peer.MapData.BirthPoint 为非死亡时 zheng chan存储
            else if (GameDateManager.Instance.CreateMapSwitchPoint == 0 || GameDateManager.Instance.isBackDie)
            {
                Transform liveTran = GameObject.Find("AIManager/Area1/0").transform;
                createPos = liveTran.position;
                createRotation = liveTran.rotation;
                // 如果使用回城券 创建 返回传送门
                if (GameDateManager.Instance.isBackTicket)
                {
                    GameDateManager.Instance.isBackTicket = false;
                    ResourceHelper.Instance.LoadAssetBundle("Scene_BackDoor", ab =>
                    {
                        if (ab != null)
                        {
                            GameObject bdObj = (GameObject)Instantiate(ab.LoadAsset("Scene_BackDoor"));
                            bdObj.SetActive(true);
                            //bdObj.transform.SetParent(this.transform);
                            bdObj.transform.localPosition = createPos + Vector3.forward * 2f;
                            bdObj.transform.localRotation = createRotation;
                        }
                    });
                }
            }
            // 需要移动到地图切换器入口处
            else
            {
                SceneEventMapSwitchLogic swiObj = null;
                while (swiObj == null)
                {
                    yield return 0;
                    swiObj = SceneCmptManager.Instance.GetMapSwitchCmptByIndex(GameDateManager.Instance.CreateMapSwitchPoint);
                    
                    if (swiObj != null)
                    {
                        swiObj.SetTeleportClose();
                        Transform liveTran = swiObj.transform.Find("createPoint");
                        createPos = liveTran.position;
                        createRotation = liveTran.rotation;
                        break;
                    }
                }
            }
            GameDateManager.Instance.isBackDie = false;
            Vector3 pos = createPos + new Vector3(UnityEngine.Random.Range(-1.5f, 1.5f), 0, UnityEngine.Random.Range(-1.5f, 1.5f));
            CreateHero(mHeroVos[index], pos, createPos, 5, "PlayerBT", (role) =>
            {
                //role.gameObject.SetActive(false);
                role.transform.rotation = createRotation;
                NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                CheckWarp(nav, createPos);
                role.IsTeamLeader = false;
                role.playerUID = UserProxy.Instance.player.uid;
                role.SetPropertyFinal(null, EBattleProperty.NPOWER, role.mData.MP_Final);
                // 创建英雄携带的言灵
                CreateHeroYanLing(role, mHeroVos[index]);
                mPlayerRoles[index] = role;

                // 默认先控制第一个
                if (index == 0)
                {
                    ReplaceHero(index, false);
                }

                if (GameDateManager.Instance.IsBackDoor)
                {
                    // 播放创建落地动画
                    HeroPlayerController.Instance.m_Hero.PlayAnimation("return_entry_e");
                }
                // 返回据点传送阵
                else if (GameDateManager.Instance.CreateMapSwitchPoint == 0)
                {
                    if (GameDateManager.Instance.isBackTicket)
                    {
                        HeroPlayerController.Instance.m_Hero.PlayAnimation("return_back_e");
                    }
                }
            });
        }
    }

    public void CreatePlayers(int index, System.Action ac = null)
    {
        if (index >= 0 && index < mHeroVos.Count)
        {
            // 存在
            if (mPlayerRoles.ContainsKey(index))
            {
                if (ac != null)
                    ac();
                return;
            }
            // 创建
            Transform liveTran = GameObject.Find("AIManager/Area1/0").transform;
            Vector3 pos = liveTran.position + new Vector3(UnityEngine.Random.Range(-1.5f, 1.5f), 0, UnityEngine.Random.Range(-1.5f, 1.5f));
            CreateHero(mHeroVos[index], pos, liveTran.position, 5, "PlayerBT", (role) =>
            {
                role.gameObject.SetActive(false);
                role.transform.rotation = liveTran.rotation;
                NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                CheckWarp(nav, livePos);
                role.IsTeamLeader = false;
                role.playerUID = UserProxy.Instance.player.uid;
                // 创建英雄携带的言灵
                CreateHeroYanLing(role, mHeroVos[index]);

                mPlayerRoles[index] = role;

                // 默认先控制第一个
                if (index == 0)
                {
                    ReplaceHero(index, false);
                }

                if (ac != null)
                {
                    ac();
                }

            });
        }
        else
        {
            if (ac != null)
            {
                ac();
            }
        }
    }

    public void CreateFriendPlayers(string uid, System.Action ac = null)
    {
        UserProxy.Instance.UserOtherPlayerInfo(uid, (player) =>
        {
            // 创建
            Transform liveTran = GameObject.Find("AIManager/Area1/0").transform;
            Vector3 pos = liveTran.position + new Vector3(UnityEngine.Random.Range(-1.5f, 1.5f), 0, UnityEngine.Random.Range(-1.5f, 1.5f));
            GameHeroVo hVo = player.collectHero.GetHeroGameInfoByHeroUId(player.heroTeamConfig.CurTeam.heros[0]);
            CreateHero(hVo, pos, liveTran.position, 5, "PlayerBT", (role) =>
            {
                role.gameObject.SetActive(true);
                role.transform.rotation = liveTran.rotation;
                NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                CheckWarp(nav, livePos);
                role.IsTeamLeader = false;
                role.playerUID = uid;
                // 创建英雄携带的言灵
                CreateHeroYanLing(role, hVo);
                mFriendRoles.Add(mFriendRoles.Count, role);
                if (role.transform.Find("CMStateDrivenCamera") != null)
                {
                    GameObject cmObj = role.transform.Find("CMStateDrivenCamera").gameObject;
                    GameObject.Destroy(cmObj);
                }

            });
        });

        //        GameHeroVo heroVo = mMirrorHeroVos[index];
        //        Transform liveTran = GameObject.Find("AIManager/Area1/" + (index + 1)).transform;
        //        Vector3 pos = liveTran.position;

        //        CreateHero(heroVo, pos, liveTran.position, 5, "PlayerMirrorBT", (role) =>
        //        {
        //            role.transform.rotation = liveTran.rotation;
        //            NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
        //            nav.Warp(liveTran.position);
        //            role.IsTeamLeader = false;
        //            role.gameObject.name = "Mirror_" + heroVo.mo.prefabRes;

        //            // 创建英雄携带的言灵
        //            CreateHeroYanLing(role, heroVo);

        //            // 创建下一个言灵
        //            CreateMirrorPlayer(index + 1);
        //        }, true);
    }

    private Vector3 livePos = Vector3.zero;
    private System.Action<bool> sucAC = null;

    /// <summary>
    /// 下一位队长
    /// </summary>
    /// <returns>是否切换成功</returns>
    public void NextTeamLeader(Vector3 pos, System.Action<bool> ac)
    {
        if (IsInvoking("LateNextTeamLeader") == false)
        {
            livePos = pos;
            sucAC = ac;
            Invoke("LateNextTeamLeader", 2.0f);
        }
    }

    /// <summary>
    /// 延迟切换队长
    /// </summary>
    private void LateNextTeamLeader()
    {
        // 优先设置上次切换的角色
        if (mPlayerRoles.ContainsKey(lastPlayerIndex))
        {
            if (mPlayerRoles[lastPlayerIndex] != null)
            {
                mPlayerRoles[lastPlayerIndex].transform.position = livePos;
                //ADON新增控制玩家模块
                HeroPlayerController.Instance.SetPlayer(mPlayerRoles[lastPlayerIndex] as BaseHero, true);

                // 初始化三人头像
                if (BattleCanvas.Instance != null)
                {
                    BattleCanvas.Instance.UpdateHeroIcon(lastPlayerIndex, -1, mHeroVos);
                }

                // 成功回调
                if (sucAC != null)
                {
                    sucAC.Invoke(true);
                }
                return;
            }
        }

        // 查找还活着的角色，并设置控制权
        foreach (var item in mPlayerRoles)
        {
            if (item.Value != null)
            {
                curPlayerIndex = item.Key;
                lastPlayerIndex = item.Key;
                item.Value.transform.position = livePos;
                //ADON新增控制玩家模块
                HeroPlayerController.Instance.SetPlayer(item.Value as BaseHero, true);

                // 初始化三人头像
                if (BattleCanvas.Instance != null)
                {
                    BattleCanvas.Instance.UpdateHeroIcon(curPlayerIndex, -1, mHeroVos);
                }

                // 成功回调
                if (sucAC != null)
                {
                    sucAC.Invoke(true);
                }
                return;
            }
        }

        // 失败回调
        if (sucAC != null)
        {
            sucAC.Invoke(false);
        }
    }

    /// <summary>
    /// 替换英雄
    /// </summary>
    /// <param name="index"></param>
    public void ReplaceHero(int index, bool isSwitchRole = true)
    {
        // 检测是否有指定玩家
        GameDateManager.Instance.CheckHaveAppointPlayers(mHeroVos);
        Vector3 pos = Vector3.zero;

        // 切换钱角色不为空,则隐藏
        if (mPlayerRoles.ContainsKey(curPlayerIndex))
        {
            mPlayerRoles[curPlayerIndex].gameObject.SetActive(false);
            pos = mPlayerRoles[curPlayerIndex].transform.position;
        }

        lastPlayerIndex = curPlayerIndex;
        // 激活新的
        if (mPlayerRoles.ContainsKey(index))
        {
            curPlayerIndex = index;
            if (pos != Vector3.zero)
            {
                mPlayerRoles[index].transform.position = pos;
            }
            //ADON新增控制玩家模块
            HeroPlayerController.Instance.SetPlayer(mPlayerRoles[index] as BaseHero, true);
        }
        else
        {
            // 激活新的失败， 找一个存活的激活
            foreach (var item in mPlayerRoles)
            {
                if (item.Value != null)
                {
                    curPlayerIndex = item.Key;
                    if (pos != Vector3.zero)
                    {
                        mPlayerRoles[index].transform.position = pos;
                    }
                    //ADON新增控制玩家模块
                    HeroPlayerController.Instance.SetPlayer(item.Value as BaseHero, true);
                    break;
                }
            }
        }

        // 初始化三人头像
        if (BattleCanvas.Instance != null)
        {
            BattleCanvas.Instance.UpdateHeroIcon(curPlayerIndex, lastPlayerIndex, mHeroVos);
        }
    }

    ///// <summary>
    ///// 创建镜像玩家
    ///// </summary>
    ///// <param name="heroVo"></param>
    ///// <param name="behaviorTreeName"></param>
    //public void CreateMirrorPlayer(int index)
    //{
    //    if (index >= 0 && index < mMirrorHeroVos.Count)
    //    {
    //        GameHeroVo heroVo = mMirrorHeroVos[index];

    //        Transform liveTran = GameObject.Find("AIManager/Area1/" + (index + 1)).transform;
    //        Vector3 pos = liveTran.position;

    //        CreateHero(heroVo, pos, liveTran.position, 5, "PlayerMirrorBT", (role) =>
    //        {
    //            role.transform.rotation = liveTran.rotation;
    //            NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
    //            nav.Warp(liveTran.position);
    //            role.IsTeamLeader = false;
    //            role.gameObject.name = "Mirror_" + heroVo.mo.prefabRes;

    //            // 创建英雄携带的言灵
    //            CreateHeroYanLing(role, heroVo);

    //            // 创建下一个言灵
    //            CreateMirrorPlayer(index + 1);
    //        }, true);
    //    }
    //    else
    //    {
    //        Invoke("LateRunmMirrorBTS", 3);
    //    }
    //}

    /// <summary>
    /// 延迟运行
    /// </summary>
    private void LateRunmMirrorBTS()
    {
        for (int i = 0; i < mMirrorBTS.Count; i++)
        {
            mMirrorBTS[i].EnableBehavior();
        }
    }

    /// <summary>
    /// 创建英雄携带的言灵
    /// </summary>
    /// <param name="role"></param>
    /// <param name="heroVO"></param>
    public void CreateHeroYanLing(Role role, GameHeroVo heroVO)
    {
        //一个英雄 有3个言灵槽: left:1、middle:2、right:3
        for (int i = 1; i <= heroVO.yanling.Count; i++)
        {
            role.RefreshYanLing(i, heroVO.yanling[i]);
            if (heroVO.yanling[i].Mo() != null && heroVO.yanling[i].Mo().GetYanlingExt() != null)
            {
                string ylRes = heroVO.yanling[i].Mo().GetYanlingExt().res;
                mYanLingRess.Add(ylRes);
            }
        }
    }

    /// <summary>
    /// 言灵攻击
    /// </summary>
    /// <param name="yanLingUID"></param>
    /// <param name="target"></param>
    /// <param name="ac"></param>
    /// <param name="goTime"></param>
    /// <param name="stayTime"></param>
    /// <param name="backTime"></param>
    public void YanLanAttack(int yanLingUID, Role target, string skillAni, System.Action ac, float goTime = 0.5f, float stayTime = 0.25f, float backTime = 0.5f)
    {
        if (mCreateYanLings.ContainsKey(yanLingUID))
        {
            YanLingBattleInfo info = mCreateYanLings[yanLingUID];

            // 去攻击
            info.selfTransform.parent = null;
            info.selfTransform.DOScale(Vector3.one * 0.25f, goTime);
            Vector3 dir = target.transform.position - info.selfTransform.position;
            dir.Normalize();
            Tweener toTweener = info.selfTransform.DOMove(target.transform.position - dir, goTime);
            toTweener.OnComplete(() =>
            {
                // 往回返
                info.selfTransform.parent = info.parentTransform;
                info.selfTransform.DOScale(Vector3.one * 0.05f, backTime);
                Tweener backTweener = info.selfTransform.DOLocalMove(Vector3.zero, backTime);
                backTweener.SetDelay(stayTime);

                // 到达目的地的攻击回调
                if (ac != null)
                {
                    ac.Invoke();
                }
                // 播放动画
                info.dragonComponent.animation.GotoAndPlayByFrame(skillAni);
            });
        }
    }

    /// <summary>
    /// 创建英雄
    /// </summary>    
    /// <param name="date">怪物数据</param>
    /// <param name="_tran">Transform</param>
    public void CreateHero(GameHeroVo date, Vector3 pos, Vector3 _livePos, float radius, string btResName, Action<Role> ac, bool isMirror = false)
    {
        if (string.IsNullOrEmpty(date.mo.prefabRes))
        {
            return;
        }

        string resName = "Role_" + date.mo.prefabRes;
        if (mRoleRes.ContainsKey(resName))
        {
            mRoleRes[resName]++;
        }
        else
        {
            mRoleRes.Add(resName, 1);
        }

        ResourceHelper.Instance.LoadAssetBundle("Role_" + date.mo.prefabRes, (AssetBundle bundle) =>
          {
              if (bundle != null)
              {
                  GameObject roleObj = (GameObject)Instantiate(bundle.LoadAsset("Role_" + date.mo.prefabRes), transform, false);
                  roleObj.AddComponent<FixShader>();

                  roleObj.transform.position = pos;
                  BaseHero role = null;
                  if (date.mo.prefabRes == "202011")
                  {
                      role = roleObj.AddComponent<Hero002>();
                  }
                  else if (date.mo.prefabRes == "101005")
                  {
                      role = roleObj.AddComponent<Hero001>();
                  }
                  else if (date.mo.prefabRes == "101013")
                  {
                      role = roleObj.AddComponent<Hero003>();
                  }
                  else
                  {
                      role = roleObj.AddComponent<Hero001>();
                  }
                  //BaseHero role = roleObj.AddComponent<BaseHero>();
                  role.mLivePos = _livePos;
                  role.IsHero = true;
                  role.mRadius = radius;
                  role.roleType = RoleType.Hero;
                  NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                  CheckWarp(nav, _livePos);
                  if (isMirror)
                  {
                      role.gameObject.layer = LayerMask.NameToLayer("Enemy");
                      role.Init(new YLBattleUnit(date.mo, date), E_Camp.Red, isMirror);

                      //mMirrorPlayerRoles.Add(role);
                  }
                  else
                  {
                      role.gameObject.layer = LayerMask.NameToLayer("Player");
                      role.Init(new YLBattleUnit(date.mo, date), E_Camp.Blue, isMirror);
                  }

                  // 加载行为树资源
                  ResourceHelper.Instance.LoadAssetBundle(btResName, (btAB) =>
                  {
                      if (btAB != null)
                      {
                          ExternalBehaviorTree ebt = btAB.LoadAsset<ExternalBehaviorTree>(btResName);
                          if (ebt != null)
                          {
                              BehaviorTree bt = role.mBehaviorTree;
                              bt.RestartWhenComplete = true;
                              bt.StartWhenEnabled = false;
                              bt.ExternalBehavior = ebt;
                              bt.DisableBehavior();

                              //// 设置属性
                              //bt.SetVariableValue("moveSpeed", role.mData.MSP_Final);
                              //bt.SetVariableValue("viewDistance", role.mData.ORG_Final);
                              //bt.SetVariableValue("attackDistance", role.mData.ARG_Final);

                              if (isMirror)
                              {
                                  mMirrorBTS.Add(bt);
                              }

                              if (ac != null)
                              {
                                  ac(role);
                              }
                          }
                          else
                          {
                              Debug.LogWarning("解析行为树资源失败！" + btResName);
                          }
                      }
                      else
                      {
                          Debug.LogWarning("加载行为树资源失败！" + btResName);
                      }
                  });

                  //// 加入小地图
                  //BattleCanvas.Instance.mapCmpt.AddTarget(role.gameObject, YL_MiniMap.MiniType.Player);
              }
          });
    }

    /// <summary>
    /// 原地复活
    /// </summary>
    public void RebirthHero()
    {   
        RoleManager.Instance.CreatePlayers(0, () =>
        {
            Role role = RoleManager.Instance.GetPlayer(true);
            NavMeshAgent nav = role.GetComponent<NavMeshAgent>();
            nav.enabled = false;
            role.transform.position = diePos;
            nav.enabled = true;
            BattleCanvas.Instance.mapCmpt.AddTarget(role.gameObject, YL_MiniMap.MiniType.Player);
        });
    }

    public void RebirthGoCreatePoint()
    {
        RoleManager.Instance.CreatePlayers(0, () =>
        {
            Role role = RoleManager.Instance.GetPlayer(true);
            NavMeshAgent nav = role.GetComponent<NavMeshAgent>();
            nav.enabled = false;
            role.transform.position = AIManager.Instance.GetPlayerCreatePoint().position;
            nav.enabled = true;
            BattleCanvas.Instance.mapCmpt.AddTarget(role.gameObject, YL_MiniMap.MiniType.Player);   
        });
    }
    /// <summary>
    /// 创建怪物
    /// </summary>    
    /// <param name="area">所属区域</param>
    /// <param name="date">怪物数据</param>
    /// <param name="_tran">Transform</param>
    public void CreateMonster(int area, sm_hero date, List<int> dropId, Vector3 pos, Vector3 _livePos, float radius, RoleType roleType, Action<Role> ac = null)
    {
        if (string.IsNullOrEmpty(date.prefabRes))
        {
            return;
        }

        string resName = "Role_" + date.prefabRes;
        if (mRoleRes.ContainsKey(resName))
        {
            mRoleRes[resName]++;
        }
        else
        {
            mRoleRes.Add(resName, 1);
        }

        ResourceHelper.Instance.LoadAssetBundle("Role_" + date.prefabRes, (AssetBundle bundle) =>
        {
            if (bundle != null)
            {
                mCurArea = area;

                GameObject roleObj = (GameObject)Instantiate(bundle.LoadAsset("Role_" + date.prefabRes), transform, false);
                roleObj.AddComponent<FixShader>();
                roleObj.transform.position = pos;


                Role role = AddMonsterScript(date, roleObj);//创建添加怪脚本
                role.Init(new YLBattleUnit(date), E_Camp.Red);
                role.mLiveArea = area;
                role.mLivePos = _livePos;
                role.dropId = dropId;
                role.IsHero = false;
                NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                CheckWarp(nav, _livePos);
                role.mRadius = radius;
                role.roleType = roleType;
                if (roleType == RoleType.Boss)
                {
                    this._bossLive = true;
                }

                if (mCreateMonsterRoles.ContainsKey(area))
                {
                    mCreateMonsterRoles[area].Add(role);
                }
                else
                {
                    List<Role> roles = new List<Role>();
                    roles.Add(role);

                    mCreateMonsterRoles.Add(area, roles);
                }

                // 加载行为树资源
                string behaviorTreeName = role.mData.mMonsterVo.ai_btree;
                ResourceHelper.Instance.LoadAssetBundle(behaviorTreeName, (btAB) =>
                {
                    if (btAB != null)
                    {
                        ExternalBehaviorTree ebt = btAB.LoadAsset<ExternalBehaviorTree>(behaviorTreeName);

                        if (ebt != null)
                        {
                            BehaviorTree bt = role.mBehaviorTree;
                            bt.RestartWhenComplete = true;
                            bt.StartWhenEnabled = true;
                            bt.ExternalBehavior = ebt;
                            if (ac != null)
                            {
                                ac(role);
                            }
                        }
                        else
                        {
                            Debug.LogWarning("解析行为树资源失败！" + behaviorTreeName);
                        }
                    }
                    else
                    {
                        Debug.LogWarning("加载行为树资源失败！" + behaviorTreeName);
                    }
                });
                // 网格优化分配
                if (GameObject.Find("GridMap") != null)
                {
                    MyGridMap gridMap = GameObject.Find("GridMap").GetComponent<MyGridMap>();
                    gridMap.AddOneObjToGrid(roleObj);
                }
            }
        });
    }

    /// <summary>
    /// 创建怪物
    /// </summary>    
    /// <param name="area">所属区域</param>
    /// <param name="date">怪物数据</param>
    /// <param name="_tran">Transform</param>
    public void CreateUnitBySpawner(int area, sm_hero date, List<int> dropId, Vector3 pos, Quaternion qua, float radius, RoleType roleType, Action<Role> ac = null)
    {
        if (string.IsNullOrEmpty(date.prefabRes))
        {
            return;
        }

        string resName = "Role_" + date.prefabRes;
        if (mRoleRes.ContainsKey(resName))
        {
            mRoleRes[resName]++;
        }
        else
        {
            mRoleRes.Add(resName, 1);
        }

        ResourceHelper.Instance.LoadAssetBundle("Role_" + date.prefabRes, (AssetBundle bundle) =>
        {
            if (bundle != null)
            {
                mCurArea = area;

                GameObject roleObj = (GameObject)Instantiate(bundle.LoadAsset("Role_" + date.prefabRes), transform, false);
                roleObj.AddComponent<FixShader>();
                float offsetX = UnityEngine.Random.Range(0, radius);
                float offsetZ = UnityEngine.Random.Range(0, radius);
                roleObj.transform.position = pos + new Vector3(offsetX, 0,offsetZ);
                roleObj.transform.rotation = qua;
                // 精英怪比普通怪大
                if (roleType == RoleType.Elite)
                {
                    roleObj.transform.localScale = Vector3.one * 1.25f;
                }
                // BOSS
                else if (roleType == RoleType.Boss)
                {
                    roleObj.transform.localScale = Vector3.one * 1.5f;
                }
                // 普通怪
                else
                {
                    roleObj.transform.localScale = Vector3.one;
                }
                roleObj.SetActive(true);

                Role role = AddMonsterScript(date, roleObj);//创建添加怪脚本


                role.Init(new YLBattleUnit(date), E_Camp.Red);
                role.mLiveArea = area;
                role.mLivePos = roleObj.transform.position;
                role.IsHero = false;
                role.dropId = dropId;
                NavMeshAgent nav = role.gameObject.GetComponent<NavMeshAgent>();
                CheckWarp(nav, roleObj.transform.position);
                role.mRadius = radius;
                role.roleType = roleType;
                if (roleType == RoleType.Boss)
                {
                    this._bossLive = true;
                }

                if (mCreateMonsterRoles.ContainsKey(area))
                {
                    mCreateMonsterRoles[area].Add(role);
                }
                else
                {
                    List<Role> roles = new List<Role>();
                    roles.Add(role);

                    mCreateMonsterRoles.Add(area, roles);
                }

                // 加载行为树资源
                string behaviorTreeName = role.mData.mMonsterVo.ai_btree;
                sm_gate gateMo = sm_gate.GetMoById(UserProxy.Instance.player.newMap.curMapId);
                if ((BattleDefine.EBattleSceneType)int.Parse(gateMo.battleType) == BattleDefine.EBattleSceneType.EBattleType_Defense)
                {
                    behaviorTreeName = "BT_Defense_301001";
                }
                
                ResourceHelper.Instance.LoadAssetBundle(behaviorTreeName, (btAB) =>
                {
                    if (btAB != null)
                    {
                        ExternalBehaviorTree ebt = btAB.LoadAsset<ExternalBehaviorTree>(behaviorTreeName);

                        if (ebt != null)
                        {
                            BehaviorTree bt = role.mBehaviorTree;
                            bt.RestartWhenComplete = true;
                            bt.StartWhenEnabled = true;
                            bt.ExternalBehavior = ebt;

                            //// 设置属性
                            //bt.SetVariableValue("moveSpeed", role.mData.MSP_Final);
                            //bt.SetVariableValue("viewDistance", role.mData.ORG_Final);
                            //bt.SetVariableValue("attackDistance", role.mData.ARG_Final);

                            if (ac != null)
                            {
                                ac(role);
                            }
                        }
                        else
                        {
                            Debug.LogWarning("解析行为树资源失败！" + behaviorTreeName);
                        }
                    }
                    else
                    {
                        Debug.LogWarning("加载行为树资源失败！" + behaviorTreeName);
                    }
                });

                //// 加入小地图
                if (BattleCanvas.Instance != null && BattleCanvas.Instance.mapCmpt)
                {
                    BattleCanvas.Instance.mapCmpt.AddTarget(role.gameObject, YL_MiniMap.MiniType.Monster);
                }
                // 网格优化分配
                if (GameObject.Find("GridMap") != null)
                {
                    MyGridMap gridMap = GameObject.Find("GridMap").GetComponent<MyGridMap>();
                    gridMap.AddOneObjToGrid(roleObj);
                }
            }
        });
    }
    /// <summary>
    /// 添加怪物脚本
    /// </summary>
    /// <param name="date"></param>
    /// <param name="role"></param>
    /// <param name="roleObj"></param>
    Role AddMonsterScript(sm_hero date, GameObject roleObj)
    {
        Role role = new Role();
        if (date.prefabRes == "301001")
        {
            role = roleObj.AddComponent<Mob01_WarriorAdon>();
        }
        else if (date.prefabRes == "601001")
        {
            role = roleObj.AddComponent<Mob02_ShooterAdon>();
        }
        else if (date.prefabRes == "401001")
        {
            role = roleObj.AddComponent<Boss01_WarriorAdon>();
        }
        else if (date.prefabRes == "701001")
        {
            role = roleObj.AddComponent<Mob03_WarriorAdon>();
        }
        else if (date.prefabRes == "1001001")
        {
            role = roleObj.AddComponent<Boss02_WarriorAdon>();
            role.GetComponent<Boss02_WarriorAdon>().m_CurForm = 1;
        }
        else if (date.prefabRes == "1001002")
        {
            role = roleObj.AddComponent<Boss02_WarriorAdon>();
            role.GetComponent<Boss02_WarriorAdon>().m_CurForm = 2;
        }
        else if (date.prefabRes == "1001003")
        {
            role = roleObj.AddComponent<Boss02_WarriorAdon>();
            role.GetComponent<Boss02_WarriorAdon>().m_CurForm = 3;
        }
        else if (date.prefabRes == "1001004")
        {
            role = roleObj.AddComponent<Boss02_WarriorAdon>();
            role.GetComponent<Boss02_WarriorAdon>().m_CurForm = 4;
        }
        else if (date.prefabRes == "2001001")
        {
            role = roleObj.AddComponent<Warrior_2001001_Boss>();
        }
        else if (date.prefabRes == "2101001")
        {
            role = roleObj.AddComponent<Shooter_2101001>();
        }
        else if (date.prefabRes == "2201001")
        {
            role = roleObj.AddComponent<Shooter_2201001>();
        }
        else if (date.prefabRes == "2301001")
        {
            role = roleObj.AddComponent<Shooter_2301001>();
        }
        else if (date.prefabRes == "2401001")
        {
            role = roleObj.AddComponent<Shooter_2401001>();
        }
        else if (date.prefabRes == "2501001")
        {
            role = roleObj.AddComponent<Shooter_2501001>();
        }
        else if (date.prefabRes == "2601001")
        {
            role = roleObj.AddComponent<Shooter_2601001>();
        }
        else if (date.prefabRes == "2701001")
        {
            role = roleObj.AddComponent<Shooter_2701001>();
        }
        else if (date.prefabRes == "701101" || date.prefabRes == "701201" || date.prefabRes == "701301" || date.prefabRes == "701401")//俯冲战机(元素)
        {
            role = roleObj.AddComponent<Mob03_WarriorAdon_Elements>();
        }
        else if (date.prefabRes == "1101101" || date.prefabRes == "1101201" || date.prefabRes == "1101301" || date.prefabRes == "1101401")//大眼怪(元素)
        {
            role = roleObj.AddComponent<Mob04_WarriorAdon>();
        }
        else if (date.prefabRes == "1201001" || date.prefabRes == "1201101" || date.prefabRes == "1201201" || date.prefabRes == "1201301" || date.prefabRes == "1201401")//野蛮先行官
        {
            role = roleObj.AddComponent<Mob05_WarriorAdon>();
        }
        else if (date.prefabRes == "1301001" || date.prefabRes == "1301101" || date.prefabRes == "1301201" || date.prefabRes == "1301301" || date.prefabRes == "1301401")//自爆机甲
        {
            role = roleObj.AddComponent<Mob06_WarriorAdon>();
        }
        else
        {
            role = roleObj.AddComponent<BaseMonsterAdon>();
        }
        return role;
    }
    /// <summary>
    /// 移除一个角色
    /// </summary>
    /// <param name="role">角色</param>
    public void DeleteRole(Role role, float delayTime = 0)
    {
        int point = role.mLiveArea;
        diePos = role.transform.position;
        if (GameBattleManager.Instance().battleType == BattleDefine.EBattleSceneType.EBattleType_Arena && role.isMirror)
        {
        }
        else if (role.mData.mIsHero)
        {
            // 删除VO数据
            for (int i = 0; i < mHeroVos.Count; i++)
            {
                if (mHeroVos[i] != null && mHeroVos[i].typeId == role.mData.mHeroVo.typeId)
                {
                    mHeroVos[i].isLocked = true;
                }
            }
            // 删除实例
            foreach (var item in mPlayerRoles)
            {
                if (item.Value == role)
                {
                    mPlayerRoles[item.Key] = null;
                    mPlayerRoles.Remove(item.Key);
                    break;
                }
            }

            Destroy(role.gameObject, delayTime);
        }
        else
        {
            // 非无尽塔 守护模式下 进行掉落
            sm_gate gateMo = sm_gate.GetMoById(UserProxy.Instance.player.newMap.curMapId);
            if ((BattleDefine.EBattleSceneType)int.Parse(gateMo.battleType) != BattleDefine.EBattleSceneType.EBattleType_Endless &&
                (BattleDefine.EBattleSceneType) int.Parse(gateMo.battleType) != BattleDefine.EBattleSceneType.EBattleType_Defense)
            {
                // 上报
                TaskProxy.Instance.ReportKillMonsterEvent(role.mData.TID, 1, (b, taskCardVo, newCardVo) =>
                {
                    if (b == false || taskCardVo == null)
                    {
                        return;
                    }
                });
                string heroId = UserProxy.Instance.player.CurrentBattleteam.CurTeamLeaderUID;
                ItemProxy.Instance.killMosterAddData(heroId, role.mData.TID, (expnum) =>
                {
                    EventComponent eventCmpt = GameEntry.GetComponent<EventComponent>();
                    eventCmpt.FireNow(this, new GetExpEvent(expnum));
                });
                ResourceHelper.Instance.LoadAssetBundle("shiqu_nengliang", (ab) =>
                {
                    if (ab != null)
                    {
                        GameObject eff = (GameObject)Instantiate(ab.LoadAsset("shiqu_nengliang"));
                        eff.transform.localPosition = diePos;
                        CmptAutoDestory des = eff.AddComponent<CmptAutoDestory>();
                        des.LiveTime = 2.0f;
                        eff.transform.DOMove(diePos + Vector3.up * 3.5f, 0.5f).OnComplete(() =>
                        {
                            DropItemFollow follow = eff.AddComponent<DropItemFollow>();
                            follow.target = HeroPlayerController.Instance.m_Hero.gameObject;
                        });

                    }
                });
                // 如果dropId 有值 则是被孵化器修改 则按照孵化器的掉落ID掉落
                if (role.dropId == null)
                {
                    if (DropManager.Instance != null)
                    {
                        DropManager.Instance.DropItems((int)(role.mData.mMonsterVo.dropId), diePos + new Vector3(UnityEngine.Random.Range(-0.5f, 0.5f), 0, UnityEngine.Random.Range(-0.5f, 0.5f)));
                    }
                }
                else
                {
                    foreach (var id in role.dropId)
                    {
                        if (DropManager.Instance != null)
                        {
                            DropManager.Instance.DropItems(id, diePos + new Vector3(UnityEngine.Random.Range(-0.5f, 0.5f), 0, UnityEngine.Random.Range(-0.5f, 0.5f)));
                        }
                    }
                }
            }
            

            if (role.roleType == RoleType.Boss)
            {
                this._bossLive = false;
            }
            // ----------- 孵化器 同步 列表刷新 S -----------------------
            EventComponent eventCmpt = GameEntry.GetComponent<EventComponent>();
            eventCmpt.FireNow(this, new BattleEventRemoveUnit(role));
            // ----------- 孵化器 同步 列表刷新 E -----------------------
            DestoryRole(role, delayTime);

            // BOSS被击杀
            if (role.roleType == RoleType.Boss)
            {
                if (gateMo.battleType == BattleDefine.EBattleSceneType.EBattleType_Boss.ToString() ||
                    gateMo.battleType == BattleDefine.EBattleSceneType.EBattleType_Duplicate.ToString() ||
                    // 0城镇 1据点 2非据点 3Boss点 4 其他
                    gateMo.mapType == 4)
                {
                    SpawnerSystem.Instance.CloseSystem();
                    // 其他小怪处于死亡状态
                    AllMonsterDeath(point);

                    // 点击传送门才结束
                    ResourceHelper.Instance.LoadAssetBundle("sucai_chuansongmen", (ab) =>
                     {
                         if (ab != null)
                         {
                             GameObject obj = (GameObject)Instantiate(ab.LoadAsset("sucai_chuansongmen"), diePos + Vector3.up, Quaternion.identity);
                             chuanSongMen = obj.GetComponent<ChuanSongMen>();
                             chuanSongMen.clickAC = ChuanSongMenClick;
                             chuanSongMen.enterAC = ChuanSongMenEnter;
                         }
                     });
                }
                EventComponent ec = GameEntry.GetComponent<EventComponent>();
                ec.FireNow(this, new NoviceEventBossDie());
            }
            else
            {
                if ((BattleDefine.EBattleSceneType)int.Parse(gateMo.battleType) == BattleDefine.EBattleSceneType.EBattleType_Endless ||
                    (BattleDefine.EBattleSceneType)int.Parse(gateMo.battleType) == BattleDefine.EBattleSceneType.EBattleType_Defense)
                {

                    if (SpawnerSystem.Instance.IsCloseAllSpawner() &&
                        SpawnerSystem.Instance.IsLastSpawner() &&
                        mCreateMonsterRoles.Count <= 0)
                    {
                        EventComponent ec = GameEntry.GetComponent<EventComponent>();
                        ec.FireNow(this, new BattleEventEndlessUpdateSpawner());
                    }
                }
                else if (SpawnerSystem.Instance.GetBattleType() != BattleDefine.EBattleSceneType.EBattleType_Boss)
                {
                    if (SpawnerSystem.Instance.IsCloseAllSpawner() &&
                        SpawnerSystem.Instance.IsLastSpawner() &&
                        mCreateMonsterRoles.Count <= 1)
                    {
                        // 点击传送门才结束
                        ResourceHelper.Instance.LoadAssetBundle("sucai_chuansongmen", (ab) =>
                        {
                            if (ab != null)
                            {
                                GameObject obj = (GameObject)Instantiate(ab.LoadAsset("sucai_chuansongmen"), diePos + Vector3.up, Quaternion.identity);
                                chuanSongMen = obj.GetComponent<ChuanSongMen>();
                                chuanSongMen.clickAC = ChuanSongMenClick;
                                chuanSongMen.enterAC = ChuanSongMenEnter;
                            }
                        });
                    }
                }
            }
            //if (mCreateMonsterRoles[point].Count <= 0)
            //{
            //    AIManager.Instance.CreateNextPointMonster(Vector3.zero);
            //}
        }
    }

    public void DestoryRole(Role role, float delayTime = 0)
    {
        int point = role.mLiveArea;
        Vector3 diePos = role.transform.position;
        if (mCreateMonsterRoles.ContainsKey(point))
        {
            mCreateMonsterRoles[point].Remove(role);
            Destroy(role.gameObject, delayTime);
            if(mCreateMonsterRoles[point].Count == 0)
            {
                mCreateMonsterRoles.Remove(point);
            }
        }
    }


    private void ChuanSongMenClick(int type)
    {
        UI_CueDialog.Instance().Open("是否离开战场?", "", E_DialogType.TwoBntton, () =>
           {
               // 游戏胜利 向服务器发送数据 接受奖励信息
               this.GameWin();
           });
    }

    private void ChuanSongMenEnter(int type, GameObject obj)
    {
        if (obj.layer == LayerMask.NameToLayer("Player"))
        {
            UI_CueDialog.Instance().Open("是否离开战场?", "", E_DialogType.TwoBntton, () =>
            {
                // 游戏胜利 向服务器发送数据 接受奖励信息
                this.GameWin();
            });
        }
    }

    /// <summary>
    /// 当前刷怪点的所有怪物死亡
    /// </summary>
    /// <param name="point"></param>
    private void AllMonsterDeath(int point)
    {
        if (mCreateMonsterRoles.ContainsKey(point))
        {
            for (int i = 0; i < mCreateMonsterRoles[point].Count; i++)
            {
                //*//mCreateMonsterRoles[point][i].roleState = new RoleState_Death(mCreateMonsterRoles[point][i], false);
            }
        }
    }

    public void GameWin()
    {
        ProcedureComponent procedure = GameObject.Find("YLGameFramework").transform.Find("Procedure").gameObject.GetComponent<ProcedureComponent>();
        if (procedure.CurrentProcedure != null && (procedure.CurrentProcedure.GetType().ToString() == "GameFrameworkYLSJ.ProcedureNoviceGuideEnd" ||
            procedure.CurrentProcedure.GetType().ToString() == "GameFrameworkYLSJ.ProcedureNoviceGuideArousal" ||
            procedure.CurrentProcedure.GetType().ToString() == "GameFrameworkYLSJ.ProcedureNoviceGuideBoss"))
        {
            return;
        }

        if (chuanSongMen != null)
        {
            chuanSongMen.gameObject.SetActive(false);
        }

        // 结束
        EventComponent e = GameEntry.GetComponent<EventComponent>();
        e.FireNow(this, new BattleEventAppraise());
    }

    public void Update()
    {
        //UpdateMonsterActiveStatus();
        OnUpdateRoles();
    }

    float updateTime = 0;
    /// <summary>
    /// 更新怪物的激活状态
    /// </summary>
    private void UpdateMonsterActiveStatus()
    {
        updateTime += Time.deltaTime;
        if (updateTime < 1.0f)
        {
            return;
        }
        else
        {
            updateTime = 0;
        }

        Role ctrlRole = GetPlayer();
        if (ctrlRole == null)
        {
            return;
        }

        foreach (var item in mCreateMonsterRoles)
        {
            foreach (var targetRole in item.Value)
            {
                if (targetRole != null)
                {
                    float dis = Vector3.Distance(ctrlRole.transform.position, targetRole.transform.position);
                    if (dis >= 20)
                    {
                        if (targetRole.mAnimator.isActiveAndEnabled)
                        {
                            targetRole.mAnimator.enabled = false;
                            targetRole.mNavMeshAgent.isStopped = true;
                            targetRole.mBehaviorTree.DisableBehavior(true);
                        }
                    }
                    else
                    {
                        if (targetRole.mAnimator.isActiveAndEnabled == false)
                        {
                            targetRole.mAnimator.enabled = true;
                            targetRole.mNavMeshAgent.isStopped = false;
                            targetRole.mBehaviorTree.EnableBehavior();
                        }
                    }
                }
            }
        }
    }

    private void OnUpdateRoles()
    {
        Role cdRole = null;
        foreach (var item in mPlayerRoles)
        {
            if (item.Value != null && item.Value.gameObject.activeSelf)
            {
                cdRole = item.Value;

                break;
            }
        }

        if (cdRole == null)
        {
            return;
        }

        HeroGameVo_Yanling yanlingVOU = cdRole.mData.mHeroVo.yanling[1];
        HeroGameVo_Yanling yanlingVOC = cdRole.mData.mHeroVo.yanling[2];
        HeroGameVo_Yanling yanlingVOB = cdRole.mData.mHeroVo.yanling[3];
        if (yanlingVOU.typeId != 0 && yanlingVOU.cd_now > 0)
        {
            yanlingVOU.cd_now -= Time.deltaTime;
        }
        if (yanlingVOC.typeId != 0 && yanlingVOC.cd_now > 0)
        {
            yanlingVOC.cd_now -= Time.deltaTime;
        }
        if (yanlingVOB.typeId != 0 && yanlingVOB.cd_now > 0)
        {
            yanlingVOB.cd_now -= Time.deltaTime;
        }

        // 刷新能量SP
        _refreshNowTime += Time.deltaTime;
        if (_refreshNowTime > _refreshTime)
        {
            _refreshNowTime -= _refreshTime;
        }
        else
        {
            return;
        }

        if (yanlingVOU.typeId != 0)
        {
            yanlingVOU.sp_now = Math.Min(yanlingVOU.Mo().GetYanlingExt().sp_max, yanlingVOU.sp_now + yanlingVOU.Mo().GetYanlingExt().sp_cure);
        }

        if (yanlingVOC.typeId != 0)
        {
            yanlingVOC.sp_now = Math.Min(yanlingVOC.Mo().GetYanlingExt().sp_max, yanlingVOC.sp_now + yanlingVOC.Mo().GetYanlingExt().sp_cure);
        }

        if (yanlingVOB.typeId != 0)
        {
            yanlingVOB.sp_now = Math.Min(yanlingVOB.Mo().GetYanlingExt().sp_max, yanlingVOB.sp_now + yanlingVOB.Mo().GetYanlingExt().sp_cure);
        }
    }

    /// <summary>
    /// 挑战结果
    /// </summary>
    /// <param name="win"></param>
    public void ChallengeResult(bool win)
    {
        PanelHelper.Instance.ShowPanel("UI_ChallengeResultWindow", null, win);
        PanelHelper.Instance.ClosePanel("BattleCanvas");
    }

    /// <summary>
    /// 检测有效位置并设置
    /// </summary>
    /// <param name="nav"></param>
    /// <param name="pos"></param>
    private void CheckWarp(NavMeshAgent nav, Vector3 pos, float dis = 5)
    {
        NavMeshHit hit;
        bool has = NavMesh.SamplePosition(pos, out hit, dis, NavMesh.AllAreas);
        if (has)
        {
            nav.Warp(hit.position);
        }
        //else
        //{
        //    nav.Warp(hit.position);
        //}
    }

    /// <summary>
    /// 清除角色资源
    /// </summary>
    public void ClearRoleRes()
    {
        // 卸载角色资源
        foreach (var item in mRoleRes)
        {
            ResourceHelper.Instance.UnloadAssetBundle(item.Key);
        }
        mRoleRes.Clear();

        // 卸载言灵资源
        for (int i = 0; i < mYanLingRess.Count; i++)
        {
            ResourceHelper.Instance.UnloadAssetBundle(mYanLingRess[i]);
        }
        mYanLingRess.Clear();

        // 删除角色GameObject
        foreach (var item in mPlayerRoles)
        {
            Destroy(item.Value);
        }
        mPlayerRoles.Clear();

        // 删除怪物GameObject
        foreach (var item in mCreateMonsterRoles)
        {
            for (int i = item.Value.Count - 1; i >= 0; i--)
            {
                Destroy(item.Value[i]);
            }
        }
        mCreateMonsterRoles.Clear();

        // 清空RoleManager残余(正常不需要,有几率有残余)
        for (int i = transform.childCount - 1; i >= 0; i--)
        {
            Destroy(transform.GetChild(i).gameObject);
        }

        lastPlayerIndex = -1;
        curPlayerIndex = 0;
    }
}

/// <summary>
/// 阵营
/// </summary>
public enum E_Camp
{
    /// <summary>
    /// 无
    /// </summary>
    None = 0,
    /// <summary>
    /// 红队(敌方)
    /// </summary>
    Red = 1,
    /// <summary>
    /// 蓝队(友方)
    /// </summary>
    Blue = 2,
}

/// <summary>
/// 言灵的战斗信息
/// </summary>
public struct YanLingBattleInfo
{
    public Transform parentTransform;
    public Transform selfTransform;
    public HeroGameVo_Yanling yanLingVO;
    public DragonBones.UnityArmatureComponent dragonComponent;
    public Role ownRole;
}