ylsj/Assets/Scripts/Core/Client/UI/UI_TaskTracking.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System;
using System.Linq;
using UnityGameFramework.Runtime;
using UnityEngine.AI;
/// <summary>
/// 任务追踪组件
/// </summary>
public class UI_TaskTracking : MonoBehaviour
{
    public static bool NavMeshMoving = false;
    public GameObject rootObj = null;
    private GameObject infoObj = null;

    private static int curIndex = 0;
    private static UI_TaskTracking taskTracking = null;

    private GameObject btnChangGui = null;
    private GameObject btnTanSuo = null;

    private GameObject btnOut = null;
    private GameObject btnIn = null;

    /// <summary>
    /// 任务追踪信息
    /// </summary>
    private List<GameObject> taskObjs = new List<GameObject>();

    /// <summary>
    /// 是否初始化
    /// </summary>
    private bool bInit = false;

    /// <summary>
    /// 更新的任务卡
    /// </summary>
    private static TaskCardVo updateTaskCardVo = null;
    private static TaskCardVo curTaskCardVo = null;

    // 目标路径
    private static NavMeshPath targetNavMeshPath = new NavMeshPath();
    private static int targetPathIndex = 0;
    private static List<Vector3> targetPathPos = new List<Vector3>();
    private static List<GameObject> targetPathObj = new List<GameObject>();
    private static int curTaskType = 1;

    /// <summary>
    /// 任务目标GameObject
    /// </summary>
    private static GameObject taskTargetObj = null;
    private GameObject targetBtnObj = null;

    private static LineRenderer lineRenderer = null;
    private static Vector3 targetPos = Vector3.zero;
    private static bool showLine = false;

    public static UI_TaskTracking Ins
    {
        get
        {
            return taskTracking;
        }
    }

    /// <summary>
    /// 创建
    /// </summary>
    /// <param name="parentTran">父Transform</param>
    public static void Create(Transform parentTran)
    {
        ResourceHelper.Instance.LoadAssetBundle("UI_TaskTracking", (ab) =>
        {
            if (ab != null)
            {
                GameObject uiObj = (GameObject)Instantiate(ab.LoadAsset("UI_TaskTracking"), parentTran);
                taskTracking = uiObj.AddComponent<UI_TaskTracking>();
                taskTracking.Init();
            }
        });
    }

    /// <summary>
    /// 显示状态
    /// </summary>
    /// <param name="show"></param>
    public static void ShowState(bool show)
    {
        if (taskTracking != null)
        {
            taskTracking.rootObj.SetActive(show);
        }
    }

    /// <summary>
    /// 更新任务信息
    /// </summary>
    public static void UpdateTaskInfo(TaskCardVo taskCardVo = null)
    {
        updateTaskCardVo = taskCardVo;

        if (taskTracking != null && taskTracking.gameObject != null)
        {
            taskTracking.UpdateInfo();
        }
        else if (GameObject.Find("InFunctionScene"))
        {
            List<TaskCardVo> cardList = UserProxy.Instance.player.collectTaskCard.GetActivingCards();
            for (int i = 0; i < cardList.Count; i++)
            {
                if (cardList[i].state == Enum_TaskCardStateType.finish && cardList[i].mo.isAutoSettle == 1)
                {
                    TaskProxy.Instance.TaskCard_getReward(int.Parse(cardList[i].uid), () =>
                    {
                        // 队列显示奖励弹窗
                        PopupEffectQueueHelper.Instance.ShowEffect(ePopupEffectType.GetItemEffect, cardList[i].mo.RealRewards());
                    });
                    break;
                }
            }
        }
    }


    /// <summary>
    /// 初始化
    /// </summary>
    private void Init()
    {
        bInit = true;
        rootObj = transform.Find("Panel").gameObject;
        infoObj = transform.Find("Panel/TaskInfos").gameObject;
        rootObj.transform.localPosition = new Vector3(0, 240, 0);   

        taskObjs.Clear();
        for (int i = 0; i < 4; i++)
        {
            Transform tran = transform.Find("Panel/TaskInfos/" + i);
            taskObjs.Add(tran.gameObject);
        }

        btnChangGui = transform.Find("Panel/TaskInfos/ButtonChangGui").gameObject;
        EventTriggerListener.Get(btnChangGui).onClick = ChangGui_Click;

        btnTanSuo = transform.Find("Panel/TaskInfos/ButtonTanSuo").gameObject;
        EventTriggerListener.Get(btnTanSuo).onClick = TanSuo_Click;

        btnOut = transform.Find("Panel/BtnOut").gameObject;
        EventTriggerListener.Get(btnOut).onClick = (btnObj) =>
        {
            btnOut.SetActive(false);
            btnIn.SetActive(true);
            infoObj.SetActive(true);
        };

        btnIn = transform.Find("Panel/BtnIn").gameObject;
        EventTriggerListener.Get(btnIn).onClick = (btnObj) =>
        {
            btnOut.SetActive(true);
            btnIn.SetActive(false);
            infoObj.SetActive(false);
        };
    }

    /// <summary>
    /// 激活
    /// </summary>
    private void OnEnable()
    {
        Invoke("UpdateInfo", 0.1f);
    }

    /// <summary>
    /// 更新信息
    /// </summary>
    private void UpdateInfo()
    {
        if (bInit == false)
        {
            return;
        }

        // 1:主线
        List<TaskCardVo> cardList1 = UserProxy.Instance.player.collectTaskCard.GetActivingCards().GetSubTypes(1);
        if (cardList1.Count > 0)
        {
            SetTaskInfo(taskObjs[0], cardList1[0], 1);
        }
        else
        {
            SetTaskInfo(taskObjs[0], null, 1);
        }

        // 2：日程(日常)
        List<TaskCardVo> cardList2 = UserProxy.Instance.player.collectTaskCard.GetActivingCards().GetSubTypes(2);
        if (cardList2.Count > 0)
        {
            for (int i = 0; i < cardList2.Count; i++)
            {
                // 追踪
                int val = 0;
                bool have = UserProxy.Instance.player.PrivateState.taskCardTracing.TryGetValue(2, out val);
                // 正在追踪
                if (have && val.ToString() == cardList2[i].uid)
                {
                    SetTaskInfo(taskObjs[1], cardList2[i], 2);
                }
                //else
                //{
                //    if (cardList2[i].state != Enum_TaskCardStateType.drawed && cardList2[i].state != Enum_TaskCardStateType.notopen)
                //    {
                //        SetTaskInfo(taskObjs[1], cardList2[i], 2);
                //    }
                //}
            }
        }
        else
        {
            SetTaskInfo(taskObjs[1], null, 2);
        }

        // 3:圣哲(学院)
        List<TaskCardVo> cardList3 = UserProxy.Instance.player.collectTaskCard.GetActivingCards().GetSubTypes(3);
        if (cardList3.Count > 0)
        {
            for (int i = 0; i < cardList3.Count; i++)
            {
                // 追踪
                int val = 0;
                bool have = UserProxy.Instance.player.PrivateState.taskCardTracing.TryGetValue(3, out val);
                // 正在追踪
                if (have && val.ToString() == cardList3[i].uid)
                {
                    SetTaskInfo(taskObjs[2], cardList3[i], 3);
                }
                //else
                //{
                //    if (cardList3[i].state != Enum_TaskCardStateType.drawed && cardList3[i].state != Enum_TaskCardStateType.notopen)
                //    {
                //        SetTaskInfo(taskObjs[2], cardList3[i], 3);
                //        break;
                //    }
                //}
            }
        }
        else
        {
            SetTaskInfo(taskObjs[2], null, 3);
        }

        // 4:商店(悬赏)  
        List<TaskCardVo> cardList4 = UserProxy.Instance.player.collectTaskCard.GetActivingCards().GetSubTypes(4);
        if (cardList4.Count > 0)
        {
            for (int i = 0; i < cardList4.Count; i++)
            {
                // 追踪
                int val = 0;
                bool have = UserProxy.Instance.player.PrivateState.taskCardTracing.TryGetValue(4, out val);
                // 正在追踪
                if (have && val.ToString() == cardList4[i].uid)
                {
                    SetTaskInfo(taskObjs[3], cardList4[i], 4);
                }
                //else
                //{
                //    if (cardList4[i].state != Enum_TaskCardStateType.drawed && cardList4[i].state != Enum_TaskCardStateType.notopen)
                //    {
                //        SetTaskInfo(taskObjs[3], cardList4[i], 4);
                //    }
                //}
            }
        }
        else
        {
            SetTaskInfo(taskObjs[3], null, 4);
        }
    }

    /// <summary>
    /// 设置任务信息
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="cardVo"></param>
    private void SetTaskInfo(GameObject taskObj, TaskCardVo cardVo, int type)
    {
        curTaskCardVo = cardVo;
        Text taskType = taskObj.transform.Find("Task/Type").GetComponent<Text>();
        Text taskName = taskObj.transform.Find("Task/Name").GetComponent<Text>();
        Text taskStep = taskObj.transform.Find("Task/Step").GetComponent<Text>();
        GameObject btnObj = taskObj.transform.Find("Task/btnGet").gameObject;
        GameObject btnGoto = taskObj.transform.Find("Task/btnGo").gameObject;
        btnObj.SetActive(false);
        btnGoto.SetActive(false);

        switch (type)
        {
            case 1:
                taskType.text = "【主线】";
                break;
            case 2:
                taskType.text = "【日常】";
                break;
            case 3:
                taskType.text = "【学院】";
                break;
            case 4:
                taskType.text = "【悬赏】";
                break;
        }

        if (cardVo == null)
        {
            taskName.text = "";
            taskStep.color = Color.white;
            taskStep.text = "暂无任务";
            return;
        }

        taskName.text = cardVo.nMo.name;

        // 领取按钮
        if (cardVo.state == Enum_TaskCardStateType.finish)
        {
            // 自动领取奖励
            if (cardVo.mo.isAutoSettle == 1)
            {
                GetPrize(cardVo);
                return;
            }
            else
            {
                btnObj.SetActive(true);
                EventTriggerListener.Get(btnObj).onClick = (obj) =>
               {
                   GetPrize(cardVo);
               };
            }
        }

        // 步骤
        List<Ins_TaskStepVo> curSteps = cardVo.GetOrderedSteps();
        if (curSteps.Count > 0)
        {
            SetStepInfo(taskObj, curSteps[0]);
        }
        else
        {
            return;
        }

        // 任务类型按钮
        GameObject btnTaskObj = taskObj.transform.Find("Task").gameObject;
        btnTaskObj.transform.Find("Selete").gameObject.SetActive(false);

        // 更新相同类型
        if (curTaskType == type)
        {
            targetBtnObj = btnTaskObj;
            targetBtnObj.transform.Find("Selete").gameObject.SetActive(true);

            // 箭头
            taskTargetObj = GetTaskTargetObj(curSteps[0]);

            if (BattleCanvas.Instance.mapCmpt != null)
            {
                BattleCanvas.Instance.mapCmpt.AddNpcArrowTarget(taskTargetObj, () => { });
            }
            else
            {
                InvokeRepeating("LateSetNpcArrow", 2.0f, 1.0f);
            }
        }

        EventTriggerListener.Get(btnTaskObj).onClick = (uiObj) =>
        {
            CancelInvoke("LateSetNpcArrow");

            curTaskType = type;

            // 选中框
            if (targetBtnObj != null)
            {
                targetBtnObj.transform.Find("Selete").gameObject.SetActive(false);
            }
            targetBtnObj = uiObj;
            targetBtnObj.transform.Find("Selete").gameObject.SetActive(true);

            // 移除旧箭头
            if (taskTargetObj)
            {
                BattleCanvas.Instance.mapCmpt.RemoveNpcArrowTarget(taskTargetObj);
            }
            // 设置新箭头
            taskTargetObj = GetTaskTargetObj(curSteps[0]);
            if (taskTargetObj)
            {
                BattleCanvas.Instance.mapCmpt.AddNpcArrowTarget(taskTargetObj, () => { });
            }
        };
    }

    /// <summary>
    /// 延迟设置箭头
    /// </summary>
    private void LateSetNpcArrow()
    {
        if (BattleCanvas.Instance.mapCmpt && taskTargetObj)
        {
            CancelInvoke("LateSetNpcArrow");
            BattleCanvas.Instance.mapCmpt.AddNpcArrowTarget(taskTargetObj, () => { });
        }
    }

    /// <summary>
    /// 设置步骤信息
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="stepVo"></param>
    private void SetStepInfo(GameObject obj, Ins_TaskStepVo stepVo)
    {
        // 任务目标
        Text taskInfo = obj.transform.Find("Task/Step").GetComponent<Text>();
        taskInfo.text = stepVo.ProgressInfo();

        // 前往按钮(游戏中不前往)
        GameObject btnGoto = obj.transform.Find("Task/btnGo").gameObject;
        if (stepVo.isFinish())
        {
            taskInfo.color = Color.green;
            btnGoto.SetActive(false);
        }
        else
        {
            taskInfo.color = Color.white;

            if (stepVo.Goto.GotoType == Enum_GotoType.unknown)
            {
                btnGoto.SetActive(false);

                return;
            }

            if (stepVo.Goto.GotoType != Enum_GotoType.unknown)
            {
                if (stepVo.isFinish())
                {
                    btnGoto.SetActive(false);
                }
                else
                {
                    btnGoto.SetActive(false);
                    btnGoto.SetActive(true);
                    EventTriggerListener.Get(btnGoto).onClick = (btnObj) =>
                    {
                        // 前往
                        Goto(stepVo);
                    };
                }
            }
            else
            {
                btnGoto.SetActive(false);
            }
        }
    }

    /// <summary>
    /// 获取奖励
    /// </summary>
    /// <param name="curTaskCardVo"></param>
    private void GetPrize(TaskCardVo curTaskCardVo)
    {
        TaskProxy.Instance.TaskCard_getReward(int.Parse(curTaskCardVo.uid), () =>
        {
            // 队列显示奖励弹窗
            PopupEffectQueueHelper.Instance.ShowEffect(ePopupEffectType.GetItemEffect, curTaskCardVo.mo.RealRewards());

            UpdateInfo();
        });
    }

    private void ChangGui_Click(GameObject go)
    {
        PanelHelper.Instance.ShowPanel("UI_TaskWindow");
    }

    private void TanSuo_Click(GameObject go)
    {
        PanelHelper.Instance.ShowPanel("UI_TaskWindow");
    }

    /// <summary>
    /// 前往功能
    /// </summary>
    /// <param name="stepVo">参数</param>
    public static void Goto(Ins_TaskStepVo stepVo)
    {
        Enum_GotoType gotoType = stepVo.Goto.GotoType;
        List<string> pars = stepVo.Goto.Params;
        if (stepVo.mo().guideid != 0 && !stepVo.isFinish() && gotoType != Enum_GotoType.new_npc)
        {
            sm_guide_module npcInfo = sm_guide_module.GetMoById(stepVo.mo().guideid);
            PanelHelper.Instance.ShowPanel("YL_FunctionGuide", (panel) =>
            {
            }, stepVo.mo().guideid);
        }
        switch (gotoType)
        {
            //// 去关卡采集
            //case Enum_GotoType.gate_for_item:
            //    {
            //        // 暂时只取第一个
            //        if (pars.Count > 0)
            //        {
            //            var itemid = pars[0];
            //            var itemMo = sm_item_base.GetMoById(itemid);
            //            if (itemMo != null)
            //            {
            //                List<sm_gate> gateList = itemMo.channel.Split(',').ToList().ConvertAll<sm_gate>(gateid => sm_gate.GetMoById(int.Parse(gateid)));
            //                if (gateList.Count > 0)
            //                {
            //                    int wordID = gateList[0].BelongedZoneMo.BelongToMainlandID;
            //                    int zoneID = gateList[0].BelongZoneId();
            //                    int gateID = gateList[0].gateId;

            //                    GameDateManager.Instance.gotoGate = true;
            //                    GameDateManager.Instance.LandID = wordID;
            //                    GameDateManager.Instance.ZoneID = zoneID;
            //                    GameDateManager.Instance.GateID = gateID;
            //                    GameDateManager.Instance.GateDifficulty = 0;

            //                    UI_BaseMainWindow.Instance().onClicked_FunMenu(1002);
            //                    PanelHelper.Instance.CloseAllPanel("UI_BaseMainWindow");
            //                }

            //            }
            //        }
            //    }
            //    break;
            //// 去通过关卡
            //case Enum_GotoType.gate_select:
            //    {
            //        // 关卡参数
            //        if (pars.Count >= 3)
            //        {
            //            int wordID = pars[0];
            //            int zoneID = pars[1];
            //            int gateID = pars[2];

            //            GameDateManager.Instance.gotoGate = true;
            //            GameDateManager.Instance.LandID = wordID;
            //            GameDateManager.Instance.ZoneID = zoneID;
            //            GameDateManager.Instance.GateID = gateID;
            //            GameDateManager.Instance.GateDifficulty = 0;

            //            UI_BaseMainWindow.Instance().onClicked_FunMenu(1002);
            //            PanelHelper.Instance.ClosePanel("UI_BaseMainWindow");
            //        }
            //    }
            //    break;
            //// 去任务卡背包
            //case Enum_GotoType.taskCardBag:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_PacketWindow", null, 5);
            //    }
            //    break;
            //// 去杀怪
            //case Enum_GotoType.gate_for_monster:
            //    {
            //        // 暂时只取第一个
            //        if (pars.Count > 0)
            //        {
            //            List<sm_gate> gates = sm_gate.FingGatesByMonster(pars[0]);
            //            if (gates.Count > 0)
            //            {
            //                int wordID = gates[0].BelongedZoneMo.BelongToMainlandID;
            //                int zoneID = gates[0].BelongZoneId();
            //                int gateID = gates[0].gateId;

            //                GameDateManager.Instance.gotoGate = true;
            //                GameDateManager.Instance.LandID = wordID;
            //                GameDateManager.Instance.ZoneID = zoneID;
            //                GameDateManager.Instance.GateID = gateID;
            //                GameDateManager.Instance.GateDifficulty = 0;

            //                UI_BaseMainWindow.Instance().onClicked_FunMenu(1002);
            //                PanelHelper.Instance.ClosePanel("UI_BaseMainWindow");
            //            }
            //        }
            //    }
            //    break;
            //// 去关卡访问NPC
            //case Enum_GotoType.gate_for_npc:
            //    {
            //        // 暂时只取第一个
            //        if (pars.Count > 0)
            //        {
            //            int npcId = int.Parse( pars[2]);
            //            sm_npc npc = sm_npc.GetMoById(npcId);
            //            sm_build buildInfo = sm_build.GetMoById(npc.buildId);

            //            if (buildInfo.sceneRes != "")
            //            {
            //                Entrance_WorldMap.mainUIBuilder.SelectBuilder(npc.buildId, () =>
            //                {
            //                    // LevelManager.Instance().LoadLevel(E_Level.Battle, buildInfo.sceneRes, buildInfo.id);
            //                    LevelManager.Instance().LoadLevel(buildInfo.sceneRes, "", buildInfo.id, 0);
            //                });
            //            }
            //            else
            //            {
            //                PanelHelper.Instance.ShowPanel("UI_BuildDialogWindow", panel =>
            //                {
            //                }, buildInfo.id.ToString());
            //            }
            //        }
            //    }
            //    break;

            ///// <summary>
            ///// 英雄技能界面, 参数:herouid
            ///// </summary>
            //case Enum_GotoType.heroSkill:
            //    {
            //        if (pars.Count > 0)
            //        {
            //            int heroTID = pars[0];
            //            GameHeroVo heroVO = UserProxy.Instance.player.collectHero.GetHeroGameInfoByModelID(heroTID.ToString());
            //            if (heroVO != null)
            //            {
            //                PanelHelper.Instance.ShowPanel("YL_SkillInfoWindow", null, heroVO);
            //            }
            //        }
            //    }
            //    break;

            ///// <summary>
            ///// 英雄属性界面, 参数:herouid
            ///// </summary>
            //case Enum_GotoType.heroProperty:
            //    {

            //        ///不得已而为之,如果进过战斗,那么这里创建的角色会影响heroscene场景里的相机.我先删除,回头再寻求更好的解决
            //        GameObject rolemanage = GameObject.Find("RoleManager");
            //        if (rolemanage != null)
            //        {
            //            CleanContent(rolemanage);
            //        }

            //        LevelManager.Instance().LoadLevel("HeroScene", "UI_NewHeroTeamWindow", null, 3, E_Level.HeroInfo);
            //    }
            //    break;

            ///// <summary>
            ///// 英雄武器装备界面,参数:herouid
            ///// </summary>
            //case Enum_GotoType.heroWeapon:
            //    {
            //        GameObject rolemanage = GameObject.Find("RoleManager");
            //        if (rolemanage != null)
            //        {
            //            CleanContent(rolemanage);
            //        }
            //        LevelManager.Instance().LoadLevel("HeroScene", "UI_NewHeroTeamWindow", "0,2", 3, E_Level.HeroInfo);
            //    }
            //    break;

            ///// <summary>
            ///// 英雄言灵装备界面,参数:herouid
            ///// </summary>
            //case Enum_GotoType.heroYanling:
            //    {
            //        GameObject rolemanage = GameObject.Find("RoleManager");
            //        if (rolemanage != null)
            //        {
            //            CleanContent(rolemanage);
            //        }

            //        LevelManager.Instance().LoadLevel("HeroScene", "UI_NewHeroTeamWindow", "0,1", 3, E_Level.HeroInfo);
            //    }
            //    break;

            ///// <summary>
            ///// 跳转唤灵师界面
            ///// </summary>
            //case Enum_GotoType.heroList:
            //    {
            //        GameObject rolemanage = GameObject.Find("RoleManager");
            //        if (rolemanage != null)
            //        {
            //            CleanContent(rolemanage);
            //        }

            //        LevelManager.Instance().LoadLevel("HeroScene", "UI_NewHeroTeamWindow", null, 3, E_Level.HeroInfo);
            //    }
            //    break;

            ///// <summary>
            ///// 跳转任务卡商店, 参数:无
            ///// </summary>
            //case Enum_GotoType.taskCardShop:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_TaskCardShopWindow");
            //    }
            //    break;

            ///// <summary>
            ///// 跳转邮件界面, 参数:无
            ///// </summary>
            //case Enum_GotoType.mail:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_MailWindow");
            //    }
            //    break;
            ///// <summary>
            ///// 跳转言灵列表界面, 参数: 无
            ///// </summary>
            //case Enum_GotoType.yanlingList:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_YanLingBagWindow");
            //    }
            //    break;
            ///// <summary>
            ///// 跳转圣哲学院界面, 参数: 无
            ///// </summary>
            //case Enum_GotoType.school:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_TaskWindow", null, 3);
            //    }
            //    break;

            ///// <summary>
            ///// 跳转无尽塔界面, 参数: 无
            ///// </summary>
            //case Enum_GotoType.endlesstower:
            //    {
            //        if (UserProxy.Instance.player.baseInfo.level >= stepVo.mo().minlv)
            //        {
            //            PanelHelper.Instance.ShowPanel("UI_EndlessTowerWindow");
            //        }
            //        else
            //        {
            //            PanelHelper.Instance.ShowPanel("UI_BaseMainWindow");
            //            UI_CueDialog.Instance().Open("玩家等级需达到" + stepVo.mo().minlv + "级!");
            //        }
            //    }
            //    break;
            ///// <summary>
            ///// 跳转材料副本, 参数: gateid
            ///// </summary>
            ///// <summary>
            ///// 跳转神庙抽奖, 参数: 无
            ///// </summary>
            //case Enum_GotoType.temple:
            //    {
            //        PanelHelper.Instance.ShowPanel("UI_TempleWindow");
            //    }
            //    break;
            ///// <summary>
            /////世界BOSS前往,  参数: gateid
            ///// </summary>
            //case Enum_GotoType.worldboss:
            //    {
            //        // 暂时只取第一个
            //        if (pars.Count > 0)
            //        {
            //            int gateID = pars[0];
            //            if (gateID == 506002)
            //            {
            //                GameDateManager.Instance.WordBossID = 2;
            //            }
            //            else
            //            {
            //                GameDateManager.Instance.WordBossID = 1;
            //            }
            //            GameDateManager.Instance.GateID = gateID;
            //            GameDateManager.Instance.GateVO = new UIVO_Gate.SelectGateVo((UIVO_Gate.EGateDiffculty)GameDateManager.Instance.GateDifficulty);
            //            GameDateManager.Instance.GateVO.gateId = gateID;

            //            RoleManager.Instance.ClearRoleRes();
            //            EventComponent eventCmpt = GameEntry.GetComponent<EventComponent>();
            //            SceneCmptManager.Instance.Reset();
            //            eventCmpt.FireNow(taskTracking, new MainEventGoBattle(GameDateManager.Instance.GateID, GameDateManager.Instance.GateDifficulty));
            //        }
            //    }
            //    break;
            //// 去通过关卡
            //case Enum_GotoType.gate_main_any:
            //    {
            //        GameDateManager.Instance.gotoGate = false;
            //        UI_BaseMainWindow.Instance().onClicked_FunMenu(1002);
            //        PanelHelper.Instance.ClosePanel("UI_BaseMainWindow");
            //    }
            //    break;
            case Enum_GotoType.materialCarbon:
                {
                    // 暂时只取第一个
                    if (pars.Count > 0)
                    {
                        int zoneId = int.Parse(pars[0]);
                        int mapId = int.Parse(pars[1]);
                        int fubenId = int.Parse(pars[2]);
                        Role ctrlRole = RoleManager.Instance.GetPlayer();

                        List<GameObject> mapLists = SceneCmptManager.Instance.GetAllMapSwitchCmpt();
                        foreach (var map in mapLists)
                        {
                            SceneEventMapSwitch sceneEventMap = map.GetComponent<SceneEventMapSwitch>();

                            // 后两位是楼层,前往不需要楼层
                            if (sceneEventMap.NextMapId == (fubenId / 100))
                            {
                                CalculatePathPos(ctrlRole.transform.position, sceneEventMap.transform.position);
                                break;
                            }
                        }

                    }
                }
                break;

            // 去关卡访问NPC
            case Enum_GotoType.new_npc:
                {
                    // 暂时只取第一个
                    if (pars.Count >= 3)
                    {
                        int zoneId = int.Parse(pars[0]);
                        int mapId = int.Parse(pars[1]);
                        int npcId = int.Parse(pars[2]);


                        Role ctrlRole = RoleManager.Instance.GetPlayer();
                        GameObject obj = GameObject.Find("SceneObj/npcList/Npc_" + npcId);
                        // 当前地图存在所找NPC
                        if (obj)
                        {
                            obj.SetActive(false);
                            obj.SetActive(true);

                            CalculatePathPos(ctrlRole.transform.position, obj.transform.position);
                        }
                        // 不存在,直接去传送
                        else
                        {
                            ToChuanSong(mapId);
                        }
                    }
                }
                break;
            case Enum_GotoType.new_monster:
                {
                    // 暂时只取第一个
                    if (pars.Count >= 3)
                    {
                        int zoneId = int.Parse(pars[0]);
                        int mapId = int.Parse(pars[1]);
                        string spawnerName = pars[2];
                        Role ctrlRole = RoleManager.Instance.GetPlayer();

                        // 不在同一张地图,去传送
                        if (UserProxy.Instance.player.newMap.curMapId != mapId)
                        {
                            ToChuanSong(mapId);
                        }
                        else
                        {
                            // 去找怪物孵化点
                            GameObject obj = GameObject.Find("Spawners/" + spawnerName);
                            if (obj && obj.transform.GetChild(0))
                            {
                                CalculatePathPos(ctrlRole.transform.position, obj.transform.GetChild(0).transform.position);
                            }
                            // 孵化点不存在,去传送
                            else
                            {
                                ToChuanSong(mapId);
                            }
                        }
                    }
                }
                break;
            case Enum_GotoType.new_main:
                {
                    PanelHelper.Instance.ShowPanel("UI_BaseMainWindow");
                }
                break;
        }
    }

    /// <summary>
    /// 前往传送
    /// </summary>
    /// <param name="targetMapid"></param>
    private static void ToChuanSong(int targetMapid)
    {
        Role ctrlRole = RoleManager.Instance.GetPlayer();

        float chuanSongDis = 0;
        float nextMapDis = 0;

        // 传送阵坐标
        Vector3 chuanSongPos = NpcManager.Instance.GetAllNpc()[1011].gameObject.transform.position;
        chuanSongDis = Vector3.Distance(ctrlRole.transform.position, chuanSongPos);

        // 下一章地图传送点坐标
        Vector3 nextMapPos = Vector3.zero;
        List<GameObject> mapLists = SceneCmptManager.Instance.GetAllMapSwitchCmpt();
        foreach (var map in mapLists)
        {
            SceneEventMapSwitch sceneEventMap = map.GetComponent<SceneEventMapSwitch>();

            if (sceneEventMap.NextMapId == targetMapid)
            {
                nextMapPos = sceneEventMap.transform.position;
                nextMapDis = Vector3.Distance(ctrlRole.transform.position, nextMapPos);
                break;
            }
        }

        // 有下一章地图信息,且地图已解锁
        if (UserProxy.Instance.player.newMap.unlockedFootholds.ContainsKey(targetMapid) && UserProxy.Instance.player.newMap.unlockedFootholds[targetMapid].transmissionIsOk)
        {
            // 下一章地图的距离有效,切人物离得近,直接通过地图传送点过去
            if (nextMapDis >= 0.01f && nextMapDis < chuanSongDis)
            {
                CalculatePathPos(ctrlRole.transform.position, nextMapPos);
            }
            else
            {
                CalculatePathPos(ctrlRole.transform.position, chuanSongPos);
            }
        }
        // 去地图切换点
        else
        {
            // 下一章地图的距离有效,直接通过地图传送点过去
            if (nextMapDis >= 0.01f)
            {
                CalculatePathPos(ctrlRole.transform.position, nextMapPos);
            }
            else
            {
                CalculatePathPos(ctrlRole.transform.position, chuanSongPos);
            }
        }
    }

    // 计算路径点
    public static void CalculatePathPos(Vector3 curPos, Vector3 _targetPos)
    {
        if (lineRenderer == null)
        {
            Role ctrlRole = RoleManager.Instance.GetPlayer();
            lineRenderer = ctrlRole.transform.Find("Line").GetComponent<LineRenderer>();
        }

        targetPos = _targetPos;
        NavMeshMoving = false;
        if (showLine)
        {
            lineRenderer.positionCount = 0;
            lineRenderer.enabled = false;
            showLine = false;
        }
        else
        {
            lineRenderer.positionCount = 0;
            lineRenderer.enabled = true;
            showLine = true;
        }

        ////创建路径
        //NavMesh.CalculatePath(curPos, targetPos, NavMesh.AllAreas, targetNavMeshPath);
        ////改变路径中每个点的位置，为了不贴边缘走，这样很怪。
        //for (int i = 1; i < targetNavMeshPath.corners.Length - 2; i++)
        //{
        //    bool result = NavMesh.FindClosestEdge(targetNavMeshPath.corners[i], out hit, NavMesh.AllAreas);
        //    if (result)
        //    {
        //        targetNavMeshPath.corners[i] = hit.position + hit.normal * dis;
        //        targetPathPos.Add(targetNavMeshPath.corners[i]);
        //        if (targetPathObj.Count >= targetPathPos.Count)
        //        {
        //            targetPathObj[targetPathPos.Count -1].transform.position = targetNavMeshPath.corners[i];
        //        }
        //        else
        //        {
        //            GameObject obj = (GameObject)Instantiate(footObj, targetNavMeshPath.corners[i],Quaternion.identity);
        //            obj.SetActive(true);
        //            targetPathObj.Add(obj);
        //        }
        //    }
        //}
        //targetPathPos.Add(targetPos);
        //if (targetPathObj.Count >= targetPathPos.Count)
        //{
        //    targetPathObj[targetPathPos.Count - 1].transform.position = targetPos;
        //}
        //else
        //{
        //    GameObject obj = (GameObject)Instantiate(footObj, targetPos, Quaternion.identity);
        //    obj.SetActive(true);
        //    targetPathObj.Add(obj);
        //}
        //NavMeshMoving = true;
    }

    /// <summary>
    /// 获取任务目标GameObject
    /// </summary>
    /// <param name="stepVo">参数</param>
    public static GameObject GetTaskTargetObj(Ins_TaskStepVo stepVo)
    {
        if (stepVo == null)
        {
            return null;
        }

        Enum_GotoType gotoType = stepVo.Goto.GotoType;
        List<string> pars = stepVo.Goto.Params;

        switch (gotoType)
        {
            case Enum_GotoType.materialCarbon:
                {
                    // 暂时只取第一个
                    if (pars.Count > 0)
                    {
                        int zoneId = int.Parse(pars[0]);
                        int mapId = int.Parse(pars[1]);
                        int fubenId = int.Parse(pars[2]);
                        Role ctrlRole = RoleManager.Instance.GetPlayer();

                        List<GameObject> mapLists = SceneCmptManager.Instance.GetAllMapSwitchCmpt();
                        foreach (var map in mapLists)
                        {
                            SceneEventMapSwitch sceneEventMap = map.GetComponent<SceneEventMapSwitch>();

                            // 后两位是楼层,前往不需要楼层
                            if (sceneEventMap.NextMapId == (fubenId / 100))
                            {
                                return sceneEventMap.gameObject;
                            }
                        }

                    }
                }
                break;

            // 去关卡访问NPC
            case Enum_GotoType.new_npc:
                {
                    // 暂时只取第一个
                    if (pars.Count >= 3)
                    {
                        int mapId = int.Parse(pars[0]);
                        int zoneId = int.Parse(pars[1]);
                        int npcId = int.Parse(pars[2]);

                        GameObject obj = GameObject.Find("SceneObj/npcList/Npc_" + npcId);
                        if (obj)
                        {
                            return obj;
                        }
                        else
                        {
                            LogHelper.Log("查找NPC失败:" + npcId);

                            int mapid = sm_npc.GetMoById(npcId).scene_node;

                            // 去传送点
                            if (UserProxy.Instance.player.newMap.unlockedFootholds.ContainsKey(mapid) && UserProxy.Instance.player.newMap.unlockedFootholds[mapid].transmissionIsOk)
                            {
                                // 去找传送阵
                                if (UserProxy.Instance.player.newMap.curMapId != zoneId)
                                {
                                    if (NpcManager.Instance.GetAllNpc().ContainsKey(1011))
                                    {
                                        GameObject npcObj = NpcManager.Instance.GetAllNpc()[1011].gameObject;
                                        return npcObj;
                                    }
                                }
                            }
                            // 去地图切换点
                            else
                            {
                                List<GameObject> mapLists = SceneCmptManager.Instance.GetAllMapSwitchCmpt();
                                foreach (var map in mapLists)
                                {
                                    SceneEventMapSwitch sceneEventMap = map.GetComponent<SceneEventMapSwitch>();
                                    if (sceneEventMap.NextMapId == mapid)
                                    {
                                        return sceneEventMap.gameObject;
                                    }
                                }
                            }
                        }
                    }
                }
                break;
            case Enum_GotoType.new_monster:
                {
                    // 暂时只取第一个
                    if (pars.Count >= 3)
                    {
                        int mapId = int.Parse(pars[0]);
                        int zoneId = int.Parse(pars[1]);
                        string spawnerName = pars[2];

                        // 去找传送阵
                        if (UserProxy.Instance.player.newMap.curMapId != zoneId)
                        {
                            GameObject npcObj = NpcManager.Instance.GetAllNpc()[1011].gameObject;
                            return npcObj;
                        }
                        // 找怪物
                        else
                        {
                            GameObject obj = GameObject.Find("Spawners/" + spawnerName).transform.GetChild(0).gameObject;
                            return obj;
                        }
                    }
                }
                break;
        }

        return null;
    }

    /// <summary>
    /// 停止前往
    /// </summary>
    public static void StopGoTo()
    {
        if (NavMeshMoving)
        {
            NavMeshMoving = false;

            Role ctrlRole = RoleManager.Instance.GetPlayer();
            ctrlRole.mNavMeshAgent.isStopped = true;
            HeroPlayerController.Instance.SetAutoMoveDirection(Vector2.zero);
        }
    }

    float fTime = 0;

    private void Update()
    {
        if(showLine)
        {
            //fTime -= Time.deltaTime;
            //if (fTime > 0)
            //{
            //    return;
            //}
            //else
            //{
            //    fTime = 0.2f;
            //}

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

            //创建路径
            NavMesh.CalculatePath(ctrlRole.transform.position, targetPos, NavMesh.AllAreas, targetNavMeshPath);
            float dis = 999;
            if (targetNavMeshPath.corners.Length > 0 && targetNavMeshPath.corners.Length <= 2)
            {
                dis = Vector3.Distance(ctrlRole.transform.position, targetNavMeshPath.corners[targetNavMeshPath.corners.Length - 1]);
            }

            if (targetNavMeshPath.corners.Length <= 0 || dis < 1.5f)
            {
                lineRenderer.positionCount = 0;
                lineRenderer.enabled = false;
                NavMeshMoving = false;
                return;
            }

            Vector3[] _path = targetNavMeshPath.corners;
            //lineRenderer.positionCount = _path.Length;
            lineRenderer.SetVertexCount(_path.Length);
            for (int i = 0; i < _path.Length; i++)
            {
                Debug.Log(i + "= " + _path[i]);
                lineRenderer.SetPosition(i, _path[i]);
            }
        }



        if (NavMeshMoving)
        {
            Role ctrlRole = RoleManager.Instance.GetPlayer();
            if (ctrlRole == null)
            {
                NavMeshMoving = false;
                return;
            }

            if (targetPathIndex < targetPathPos.Count)
            {
                float dis = Vector3.Distance(ctrlRole.transform.position, targetPathPos[targetPathIndex]);
                if (dis <= 2.0f)
                {
                    targetPathObj[targetPathIndex].SetActive(false);
                    targetPathIndex++;
                }
                else
                {
                    if (ctrlRole.mNavMeshAgent.isStopped == true)
                    {
                        ctrlRole.mNavMeshAgent.isStopped = false;
                    }

                    if (ctrlRole.mNavMeshAgent.destination != targetPathPos[targetPathIndex])
                    {
                        ctrlRole.mNavMeshAgent.SetDestination(targetPathPos[targetPathIndex]);
                    }

                    Vector2 dir = new Vector2(ctrlRole.mNavMeshAgent.desiredVelocity.x, ctrlRole.mNavMeshAgent.desiredVelocity.z);
                    dir.Normalize();
                    HeroPlayerController.Instance.SetAutoMoveDirection(dir);
                }
            }
            else
            {
                NavMeshMoving = false;
                if (ctrlRole.mNavMeshAgent.isStopped == false)
                {
                    ctrlRole.mNavMeshAgent.isStopped = true;
                    HeroPlayerController.Instance.SetAutoMoveDirection(Vector2.zero);
                }
            }
        }
    }

    /// <summary>
    /// 删除容器内的物体
    /// </summary>
    /// <param name="Group"></param>
    private static void CleanContent(GameObject Group)
    {
        int childCount = Group.transform.childCount;
        if (childCount == 0)
        {
            return;
        }

        var children = new List<GameObject>();
        for (int i = 0; i < childCount; ++i)
        {
            var child = Group.transform.GetChild(i).gameObject;
            children.Add(child);
        }

        for (int i = 0; i < childCount; ++i)
        {
            var child = children[i];
#if UNITY_EDITOR
            UnityEngine.Object.DestroyImmediate(child);
#else
               UnityEngine. Object.Destroy(child);
#endif
        }
    }
}