125 战斗 战斗UI

yyl

2025-10-21 3bd7f56906e31e8fe0072108c9d4652707b51de8

 Main/System/Task/TaskManager.cs

@@ -5,1809 +5,91 @@
using LitJson;
using System.Text.RegularExpressions;
using System.Text;
using vnxbqy.UI;
using UnityEngine.Events;
//任务信息的存储

/** 任务结构 */
public class MissionDetailDates
public class TaskDetailDates
{
    public DateTime Time;//记录时间
    public int ID;//任务ID
    public string Name;//任务名称
    public int Type;//任务类型
    public int NPC_ID;//起始NPCID
    public int LV;//可接等级
    public int ColorLV;//任务难度
    public string Desclist;//任务详情
    public string RewardList;//奖励信息
    public List<TsakLight> LightList;//任务灯信息
    public string InforList;//任务完成条件
    public int MissionState;//任务状态0未接，1进行中，2可提交，3已完成,6特殊卡级
    public int descIndex;//任务描述索引
    public int TaskGroup;   // 任务组，0-主线
    public int TaskID;      // 当前任务ID，可能为0，表示该分组暂时没有任务
    public int CurValue;      // 当前进度值
    public int State;      // 任务状态 1-进行中 2-可领取
}


public class MissionDict//任务字典信息
public enum TaskTypenum//任务类型分类
{
    public int MissionId;//任务ID 

    public int DictKeyLen;//任务字典中的某个Key

    public string DictKey;//key的长度

    public int DictValue;//该key对应的值

    MainlineTaskType = 0,//主线
    SideQuestsType = 1,//支线

}
public class RunTaskAwardRecord
{
    public int Num;
    public int AwardState;
}

public struct TsakLight
{
    public int NpcId;
    public int StateLight;
}


public class TaskManager : GameSystemManager<TaskManager>
{

    /** 任务总清单 */
    public static bool _globalbool = false;
    public Dictionary<int, MissionDetailDates> allMissionDict = new Dictionary<int, MissionDetailDates>();//任务初始化接收字典
    public Dictionary<int, MissionDetailDates> MainTaskDic = new Dictionary<int, MissionDetailDates>();//主线任务字典
    public Dictionary<int, MissionDetailDates> SideQuestsDic = new Dictionary<int, MissionDetailDates>();//支线任务字典
    public Dictionary<int, MissionDetailDates> BountyDic = new Dictionary<int, MissionDetailDates>();//赏金任务
    public Dictionary<int, MissionDetailDates> FairyAuDic = new Dictionary<int, MissionDetailDates>();//仙盟任务
    public int FairyAuTaskCount_Day { get; private set; }
    public int FairyAuTaskCount_Round { get; private set; }
    public Dictionary<int, MissionDetailDates> SpecialTask = new Dictionary<int, MissionDetailDates>();//特殊任务类型
    public Dictionary<int, Dictionary<string, string>> _DicTaskInformation = new Dictionary<int, Dictionary<string, string>>();//任务字典的信息
    public Dictionary<int, Dictionary<string, int>> ReplaceDic = new Dictionary<int, Dictionary<string, int>>();//key值替换字典
    public Dictionary<int, RunTaskAwardRecord> AwardRecordDic = new Dictionary<int, RunTaskAwardRecord>();//跑环奖励记录
    public Dictionary<int, int> NPCShowDic = new Dictionary<int, int>();//关于NPC的显隐问题

    Dictionary<int, int> m_ShowNpcCache = new Dictionary<int, int>();

    public delegate void OnTaskToAdd(int MissionID, int MissionState, int DiscriptionIndex);
    public static event OnTaskToAdd Event_TaskToAdd;//任务添加
    public delegate void OnTaskRefreshes(int _taskId);
    public static event OnTaskRefreshes Event_TaskRefreshes;//任务的刷新
    public delegate void OnBounty();//赏金任务的添加
    public static event OnBounty Event_nBounty;
    public delegate void OnFairyAuTask();//仙盟任务的添加和刷新
    public static event OnFairyAuTask Event_FairyAuTask;

    public delegate void OnTaskInformation(int _id, Dictionary<int, Dictionary<string, string>> _Dic);
    public static event OnTaskInformation Event_TaskInformation;//任务字典信息

    public delegate void OnTaskToDelete(int _taskID);
    public static event OnTaskToDelete Event_TaskToDelete;//任务的删除

    public delegate void OnBountyRewards(int Number, int AwardState);//获取赏金奖励
    public static event OnBountyRewards Event_BountyRewards;
    public int BountyRewardsNumber = 0;//获取赏金内容的奖励值

    public delegate void OnFairyAuReward(int Number, int AwardState);//仙盟奖励
    public static event OnFairyAuReward Event_FairyAuReward;
    public int OnFairyAuNumber = 0;//获取仙盟的奖励值

    public string _conversation = null;//对话内容、
    public int _TaskNow = 0;//获取当前任务ID
    public string _DefaultDialogContent = null;//默认对话内容

    public delegate void OnMainlineTask(int MissionID, int MissionState);//主线任务任务状态变更和刷新
    public static event OnMainlineTask Event_MainlineTask;

    public delegate void OnTaskResponse(int _nowNPCid, int _nPCLamp, Dictionary<int, int> _dic = null);//NPCNPC灯状态，可接取任务（NPCID，任务灯状态）
    public static event OnTaskResponse Event_TaskResponse;

    public static event Action tryGetTaskAwardEvent;//这个是客户端只要尝试去领奖就会触发，不管最后的领奖结果。

    public static event Action<int> CardLevelChange;//关于任务卡机状态的转变

    public static event Action<int> SideQuestChangeEvent;//支线任务状态改变

    public static event Action<int> MainCardLevelChange;//主线任务卡级状态改变

    public static event Action<int> CompletionOfTaskEvent;//任务完成回调

    public event Action<int> talkNpcIdUpdate;

    public event Action<int> taskDescriptionRefresh;

    public static event Action TaskCoinTaskEvent;//赏金任务信息字典变更
    public static event Action FairyTaskEvent;//仙盟任务信息字典变更

    public int NPCid = 0;//获取NPCID（打开任务面板时）、

    public bool BountyMotionBool = false;//控制赏金任务是否自动移动
    public bool FairyAuBool = false;//控制仙盟任务是否自动移动
    public int currentMission { get; private set; }
    public int currentMissionState { get; private set; }

    public int GetNowTaskID { get; set; }//获取当前选中条的任务ID

    private bool isServerPrepare = false;//控制是否自动进行自动任务
    private int retainTaskID = 0;
    private float BossDelayTimeint = 0;
    public Vector3 UIeffectFabaoVec = new Vector3();//法宝NPC消失时获取的坐标
    //----关于前期无操作自动执行主线
    public int TaskAutoLv = 0;
    public int TaskAutoTime = 0;

    public bool TaskOverBool = false;
    private int Times = 0;
    private int NeedWaitTime = 4;

    public int clientGuardDugeonTask { get; private set; }

    List<int[]> priorityTaskChains = new List<int[]>();

    List<int> allowAutoTaskMapIds = new List<int>();

    private float mainTaskAutoWaitTime = 0f;
    public readonly TaskWait taskWait = new TaskWait();

    public List<int> npcImages = new List<int>();
    public List<int> playerJobImages = new List<int>();

    //跳转到任务，0为置顶
    public event Action OnJumpTask;
    private int m_JumpTaskID = 0;
    public int jumpTaskID { 
        get { return m_JumpTaskID; } 
        set { 
            m_JumpTaskID = value; 
            OnJumpTask?.Invoke();
        } 
    }

    //任务组：任务信息；只有任务包没有删除包，可以认为一个任务组只有一个任务
    //public Dictionary<int, TaskDetailDates> allMissionDict = new Dictionary<int, TaskDetailDates>();
    //主线任务，暂且只处理主线任务
    public TaskDetailDates mainTask = new TaskDetailDates();
    public event Action OnTaskUpdate;
    public event Action OnTaskClick;
    public override void Init()
    {
        // StageLoad.Instance.onStageLoadFinish += onStageLoadFinish;
        // NPCInteractProcessor.s_NpcInteractEvent += NpcInterac;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;

        string BossDelayTime = FuncConfigConfig.Get("BossDelayTime").Numerical1;
        BossDelayTimeint = float.Parse(BossDelayTime);
        var Task_Auto = FuncConfigConfig.Get("TaskAuto");
        TaskAutoLv = int.Parse(Task_Auto.Numerical1);
        TaskAutoTime = int.Parse(Task_Auto.Numerical2);
        mainTaskAutoWaitTime = int.Parse(Task_Auto.Numerical3) / 1000f;
        var mapIds = ConfigParse.GetMultipleStr<int>(Task_Auto.Numerical4);
        if (mapIds != null && mapIds.Length > 0)
        {
            allowAutoTaskMapIds.AddRange(mapIds);
        }

        FairyAuTaskCount_Day = int.Parse(FuncConfigConfig.Get("RunTaskCnt").Numerical1.Split('|')[1].Split('_')[1]);
        FairyAuTaskCount_Round = int.Parse(FuncConfigConfig.Get("RunTaskCnt").Numerical2.Split('|')[1].Split('_')[1]);

        var cliengGuardConfig = FuncConfigConfig.Get("ClientGuardDungeon");
        clientGuardDugeonTask = int.Parse(cliengGuardConfig.Numerical5);

        var funcConfig = FuncConfigConfig.Get("AutoSelectTaskChain");
        var taskChainArray = LitJson.JsonMapper.ToObject<int[][]>(funcConfig.Numerical1);
        if (taskChainArray != null)
        {
            for (int i = 0; i < taskChainArray.Length; i++)
            {
                priorityTaskChains.Add(taskChainArray[i]);
            }
        }
        var config = FuncConfigConfig.Get("NPCTalk");
        npcImages = JsonMapper.ToObject<List<int>>(config.Numerical1);
        playerJobImages = JsonMapper.ToObject<List<int>>(config.Numerical2);
    }

    public override void Release()
    {
        // StageLoad.Instance.onStageLoadFinish -= onStageLoadFinish;
        // NPCInteractProcessor.s_NpcInteractEvent -= NpcInterac;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
    }

    public void OnBeforePlayerDataInitialize()
    {
        allMissionDict.Clear();
        MainTaskDic.Clear();
        SideQuestsDic.Clear();
        BountyDic.Clear();
        FairyAuDic.Clear();
        SpecialTask.Clear();
        _DicTaskInformation.Clear();
        ReplaceDic.Clear();
        AwardRecordDic.Clear();
        NPCShowDic.Clear();
        m_ShowNpcCache.Clear();
        _conversation = null;
        _DefaultDialogContent = null;
        _TaskNow = 0;
        BountyRewardsNumber = 0;
        NPCid = 0;
        retainTaskID = 0;
        currentMission = 0;
        _globalbool = false;
        BountyMotionBool = false;
        FairyAuBool = false;
        isServerPrepare = false;
    }

    public void OnPlayerLoginOk()
    {
        GlobalTimeEvent.Instance.secondEvent -= secondEvent;
        GlobalTimeEvent.Instance.secondEvent += secondEvent;
        TaskAllocation.Instance.TaskTime = TimeUtility.ServerNow;
        isServerPrepare = true;
        TaskOverBool = false;
    }

    // private void onStageLoadFinish()//地图切换时调用
    // {
    //     var inDungeon = IsDungeon();
    //     if (!inDungeon && retainTaskID != 0)
    //     {
    //         if (ReplaceDic.ContainsKey(retainTaskID))
    //         {
    //             AutomaticTripToTask(retainTaskID);
    //             //int missionState = SideQuestState(retainTaskID);
    //             //TaskTerminationToHangUp(retainTaskID, missionState);
    //             retainTaskID = 0;
    //         }
    //     }
    // }
    List<int> ListMissionID = new List<int>();
    public void RefreshMissionState(int MissionID, int MissionState, int DiscriptionIndex)//1.任务ID,2任务状态，3，任务描述Index(接收任务)
    {
        // TODO YYL
        // try
        // {
        //     if (isServerPrepare && MissionState != 3 && MissionID != 2000 && MissionID != 3000)
        //     {
        //         TaskupToDate = MissionID;
        //     }
        //     var pytaskM = PyTaskConfig.Get(MissionID);
        //     if (pytaskM == null)
        //     {
        //         return;
        //     }
        //     if ((pytaskM.type == (int)TaskTypenum.MainlineTaskType || pytaskM.type == (int)TaskTypenum.MainlineTaskTyp2) && MissionState != 0 && MissionState != 3)
        //     {
        //         currentMission = MissionID;
        //         currentMissionState = MissionState;
        //     }
        //     //仙盟任务完成
        //     if ((pytaskM.type == 12 || pytaskM.type == 14) && TaskAllocation.Instance.FairyAuAllNumber() >= FairyAuTaskCount_Day)
        //     {
        //         Event_FairyAuTask();
        //         return;
        //     }


        //     if (allMissionDict.ContainsKey(MissionID))
        //     {
        //         int missionState = allMissionDict[MissionID].MissionState;
        //         var lastDescriptionIndex = allMissionDict[MissionID].descIndex;

        //         if (allMissionDict[MissionID].MissionState != MissionState && MissionState == 3 && isServerPrepare)
        //         {
        //             TaskOverBool = true;
        //             taskWait.Push(TaskWaitType.TaskComplete);
        //             if (CompletionOfTaskEvent != null)
        //             {
        //                 CompletionOfTaskEvent(MissionID);
        //             }
        //         }
        //         TaskChanges(MissionID, MissionState, DiscriptionIndex);//任务的状态修改

        //         if (missionState == 0 && (MissionState == 1 || MissionState == 2))
        //         {
        //             if (Event_TaskToAdd != null)//任务添加（用于存储于身上的未接取任务的特殊处理）
        //             {
        //                 Event_TaskToAdd(MissionID, MissionState, DiscriptionIndex);
        //             }
        //         }
        //         else
        //         {
        //             if (Event_TaskRefreshes != null)//刷新任务
        //             {
        //                 Event_TaskRefreshes(MissionID);
        //             }
        //         }

        //         if (lastDescriptionIndex != DiscriptionIndex)
        //         {
        //             if (taskDescriptionRefresh != null)
        //             {
        //                 taskDescriptionRefresh(MissionID);
        //             }
        //         }

        //     }
        //     else
        //     {
        //         AddMission(MissionID, MissionState, DiscriptionIndex);//任务的添加
        //         if (taskDescriptionRefresh != null)
        //         {
        //             taskDescriptionRefresh(MissionID);
        //         }
        //         if (Event_TaskToAdd != null)
        //         {
        //             Event_TaskToAdd(MissionID, MissionState, DiscriptionIndex);
        //         }
        //     }
        //     TaskClassification(MissionID, MissionState);//任务分类
        //     IsShowNpC(1);//是否显示NPC
        //     IsShowNpC(MissionID);//是否显示NPC
        //     if (isServerPrepare)
        //     {
        //         AutotaskingPrecedence(isServerPrepare, MissionID);//是否执行自动任务
        //     }
        //     TaskTerminationToHangUp(MissionID, MissionState);//结束赏金和仙盟任务前往挂机
        //     if (Event_TaskResponse != null)//发送任务灯信息
        //     {
        //         if (allMissionDict[MissionID].LightList.Equals(default(TsakLight)))
        //         {
        //             return;
        //         }
        //         for (int i = 0; i < allMissionDict[MissionID].LightList.Count; i++)
        //         {
        //             Event_TaskResponse(allMissionDict[MissionID].LightList[i].NpcId, allMissionDict[MissionID].LightList[i].StateLight);
        //         }

        //     }
        // }
        // catch (Exception ex)
        // {
        //     Debug.Log(ex.StackTrace);
        // }

        mainTask = new TaskDetailDates();
    }


    // public ImpactRankModel.RankAwardItem GetRunTaskRward()//添加任务奖励
    // {
    //     var runTaskAward = FuncConfigConfig.Get("RunTaskAward");
    //     ImpactRankModel.RankAwardItem _award = new ImpactRankModel.RankAwardItem();
    //     var _jsonData = LitJson.JsonMapper.ToObject(runTaskAward.Numerical3);
    //     var jsonData2 = LitJson.JsonMapper.ToObject(runTaskAward.Numerical4);
    //     foreach (string key in _jsonData.Keys)
    //     {
    //         var _job = int.Parse(key);
    //         var _itemArray = LitJson.JsonMapper.ToObject<int[][]>(_jsonData[key].ToJson());
    //         for (int j = 0; j < _itemArray.Length; j++)
    //         {
    //             _award.Add(_job, new Item(_itemArray[j][0], _itemArray[j][1]));
    //         }
    //     }
    //     foreach (string key in jsonData2.Keys)
    //     {
    //         var _job = int.Parse(key);
    //         _award.Add(_job, new Item(2301, 0));

    //     }

    //     return _award;
    // }

    public int GetLatestMainTaskId()
    public void UpdateTask(HB110_tagMCTaskInfo netPack)
    {
        var taskId = 0;
        //主线任务的顺序由任务列表的顺序决定 TaskListConfig.GetMissionIndex
        //这里是bug，但是因为只有一个主线任务，所以暂时不影响
        foreach (var id in MainTaskDic.Keys)
        for (int i = 0; i < netPack.TaskList.Length; i++)
        {
            if (id > taskId)
            if (netPack.TaskList[i].TaskGroup == 0)
            {
                taskId = id;
            }
        }
        return taskId;
    }

    public bool TryGetTaskData(int _taskId, out MissionDetailDates taskData)
    {
        return allMissionDict.TryGetValue(_taskId, out taskData);
    }

    void DefaultDialogue()//关于打开默认对话界面
    {
        // if (NewBieCenter.Instance.inGuiding || ModelCenter.Instance.GetModel<TreasureModel>().newGotShowing)
        // {
        //     return;
        // }
        // bool IsOpenMain = UIManager.Instance.IsOpened<MainWin>();
        // if (!UIManager.Instance.IsOpened<DefaultDialogueBoxWin>() && IsOpenMain)
        // {
        //     UIManager.Instance.OpenWindow<DefaultDialogueBoxWin>();
        //     UIManager.Instance.CloseWindow<MainInterfaceWin>();
        // }
        // else
        // {
        //     if (talkNpcIdUpdate != null)
        //     {
        //         talkNpcIdUpdate(NPCid);
        //     }
        // }
    }
    private void OnEventTalkEvent(int taskID)//NPC对话后的弹框
    {
        //if (UIManager.Instance.ExitAnyFullScreenOrMaskWin())
        //{
        //    return;
        //}
        //bug: 功能开启引导时，未收到服务端的封包快速对话会导致功能开启引导被打断，如果只是判断inGuiding又导致无法继续任务
        //解决方案：1. 对话时判断有引导且必须界面在打开状态；2. 功能引导飞入的时候如果中断则取消引导
        
        // -------------------------TODO YYL-----------------------------------
        // if ((NewBieCenter.Instance.inGuiding && UIManager.Instance.IsOpened<NewBieWin>()) || ModelCenter.Instance.GetModel<TreasureModel>().newGotShowing
        //     || UIManager.Instance.IsOpened<TreasureChapterWin>())
        // {
        //     return;
        // }

        // bool IsOpenMain = UIManager.Instance.IsOpened<MainInterfaceWin>();

        // var state = 0;
        // if (TryGetCustomTaskState(taskID, out state))
        // {
        //     var config = StoryMissionsConfig.GetConfig(taskID, state);
        //     if (config != null && NPCid == config.NpcID)
        //     {
        //         if (!UIManager.Instance.IsOpened<DialogueDuidanceWin>() && IsOpenMain
        //              && !UIManager.Instance.ExistAnyFullScreenOrMaskWin())
        //         {
        //             UIManager.Instance.CloseWindow<MainInterfaceWin>();
        //             DialogueDuidanceWin.storyMissionId = config.id;
        //             DialogueDuidanceWin.taskId = taskID;
        //             UIManager.Instance.OpenWindow<DialogueDuidanceWin>();
        //         }
        //         return;
        //     }
        // }
        // if (!UIManager.Instance.IsOpened<TaskBoxBGMWin>() && IsOpenMain)
        // {
        //     UIManager.Instance.CloseWindow<MainInterfaceWin>();
        //     UIManager.Instance.OpenWindow<TaskBoxBGMWin>();
        //     return;
        // }
        // if (BountyDic.ContainsKey(_TaskNow) || FairyAuDic.ContainsKey(_TaskNow))
        // {
        //     if (!ModelCenter.Instance.GetModel<TeamModel>().teamPrepare.isPreparing)
        //     {
        //         RequestGetTaskAward("OK", _TaskNow);
        //     }
        // }
    }


    private void BountySelfMotion()
    {
        int blank = PackManager.Instance.GetEmptyGridCount(PackType.Item);
        if (blank < 1)//"请先清理背包再领取奖励
        {
            return;
        }

    }

    public bool TryGetCustomTaskState(int taskId, out int state)
    {
        state = 0;
        if (ReplaceDic.ContainsKey(taskId))
        {
            var keyValue = ReplaceDic[taskId];
            if (keyValue.ContainsKey("state"))
            {
                state = keyValue["state"];
                return true;
            }
        }
        return false;
    }

    void AddMission(int MissionID, int MissionState, int DiscriptionIndex)//添加任务
    {
        //  TODO YYL

        // var config = PyTaskConfig.Get(MissionID);
        // if (config == null)
        // {
        //     Debug.LogError(MissionID + "表格中不存在此任务ID");
        //     return;
        // }

        // if (allMissionDict == null)
        //     allMissionDict = new Dictionary<int, MissionDetailDates>();
        // MissionDetailDates vDetailData = new MissionDetailDates();
        // vDetailData.Time = DateTime.Now;
        // vDetailData.ID = int.Parse(config.id);
        // vDetailData.Name = config.name;
        // vDetailData.Type = config.type;
        // vDetailData.NPC_ID = config.npcId;
        // vDetailData.LV = config.lv;
        // vDetailData.ColorLV = config.colorLV;

        // vDetailData.RewardList = RewardInformation(config.rewardList, DiscriptionIndex);//奖励信息
        // if (ReplaceDic.ContainsKey(MissionID))
        // {
        //     Dictionary<string, int> _dic = ReplaceDic[MissionID];
        //     if (_dic.ContainsKey("visit_npc_id") || _dic.ContainsKey("kill_npc_id"))
        //     {
        //         vDetailData.LightList = CharactersReplace(config.lightList, DiscriptionIndex, int.Parse(config.id));
        //     }
        //     else
        //     {
        //         vDetailData.LightList = StrSegmentation(config.lightList, DiscriptionIndex);//任务信息灯
        //     }
        //     if (MissionState == 3)
        //     {
        //         for (int i = 0; i < vDetailData.LightList.Count; i++)
        //         {
        //             TsakLight TsakLight = new TsakLight();
        //             TsakLight.NpcId = vDetailData.LightList[i].NpcId;
        //             TsakLight.StateLight = -1;
        //             vDetailData.LightList[i] = TsakLight;
        //         }
        //     }
        // }
        // else
        // {
        //     vDetailData.LightList = StrSegmentation(config.lightList, DiscriptionIndex);//任务信息灯
        //     if (MissionState == 3)
        //     {
        //         for (int i = 0; i < vDetailData.LightList.Count; i++)
        //         {
        //             TsakLight TsakLight = new TsakLight();
        //             TsakLight.NpcId = vDetailData.LightList[i].NpcId;
        //             TsakLight.StateLight = -1;
        //             vDetailData.LightList[i] = TsakLight;
        //         }
        //     }
        // }
        // vDetailData.Desclist = TaskDetails(config.descList, DiscriptionIndex);//任务详情
        // vDetailData.InforList = StrInforList(config.infoList, DiscriptionIndex);//任务完成条件


        // vDetailData.MissionState = MissionState;
        // vDetailData.descIndex = DiscriptionIndex;

        // var canSwitchSelectTask = true;
        // if (GetNowTaskID != 0 && !IsMainTaskType(vDetailData.Type))
        // {
        //     MissionDetailDates taskData;
        //     if (TryGetTaskData(GetNowTaskID, out taskData)
        //         && IsMainTaskType(taskData.Type)
        //         && taskData.MissionState != 3)
        //     {
        //         canSwitchSelectTask = false;
        //     }
        // }

        // if (isServerPrepare && PriorityTaskChainContains(MissionID))
        // {
        //     canSwitchSelectTask = true;
        // }

        // if (canSwitchSelectTask)
        // {
        //     GetNowTaskID = MissionID;
        // }

        // allMissionDict.Add(MissionID, vDetailData);//添加任务
    }

    public bool PriorityTaskChainContains(int taskId)
    {
        for (int i = 0; i < priorityTaskChains.Count; i++)
        {
            if (taskId >= priorityTaskChains[i][0]
                && taskId <= priorityTaskChains[i][1])
            {
                return true;
            }
        }
        return false;
    }

    public bool IsMainTaskType(int type)
    {
        return type == (int)TaskTypenum.MainlineTaskType || type == (int)TaskTypenum.MainlineTaskTyp2;
    }

    public enum TaskTypenum//任务类型分类
    {
        MainlineTaskType = 0,//主线
        MainlineTaskTyp2 = 1,
        SideQuestsType2 = 2,//支线
        SideQuestsType3 = 3,//支线任务（本源法宝支线）
        SideQuestsType4 = 4,
        SideQuestsType5 = 5,
        BountyMissionsType6 = 6,//赏金任务
        BountyMissionsType7 = 7,
        BountyMissionsType8 = 8,
        FairyAuMissionType11 = 11,//仙盟任务
        FairyAuMissionType12 = 12,
        SpecialTaskType13 = 13,//特殊任务类型(用于赏金)
        SpecialTaskType14 = 14,//特殊任务类型(用于仙盟)
        AchievementTask = 15,//成就任务（暂未开出专属字典）
        SpecialTaskType16 = 16,//特殊任务类型(用于法宝)
        SideQuestsType17 = 17,//支线17-21新增
        SideQuestsType18 = 18,
        SideQuestsType19 = 19,
        SideQuestsType20 = 20,//(后端特殊处理，暂定不让使用)
        SideQuestsType21 = 21,
        //后续IL开发添加预设
        default1,
        default2,
        default3,
        default4,
        default5,
        default6,
        default7,
        default8,
        default9,
        default10,
    }

    void TaskClassification(int _taskID, int MissionState)//任务分类(主线任务,支线任务)
    {
        if (!allMissionDict.ContainsKey(_taskID))
        {
            return;
        }
        TaskTypenum type = (TaskTypenum)allMissionDict[_taskID].Type;
        switch (type)
        {
            case TaskTypenum.MainlineTaskType:
            case TaskTypenum.MainlineTaskTyp2:
                {
                    if (_taskID != 1)//主线任务（添加与更新）
                    {
                        if (MainTaskDic.ContainsKey(_taskID))
                        {
                            MainTaskDic[_taskID] = allMissionDict[_taskID];
                        }
                        else
                        {
                            MainTaskDic.Add(_taskID, allMissionDict[_taskID]);
                        }
                        if (Event_MainlineTask != null)
                        {
                            Event_MainlineTask(_taskID, MissionState);
                        }
                    }

                }
                mainTask.TaskGroup = netPack.TaskList[i].TaskGroup;
                mainTask.TaskID = (int)netPack.TaskList[i].TaskID;
                mainTask.CurValue = (int)netPack.TaskList[i].CurValue;
                mainTask.State = netPack.TaskList[i].State;
                break;
            case TaskTypenum.SideQuestsType2:
            case TaskTypenum.SideQuestsType3:
            case TaskTypenum.SideQuestsType4:
            case TaskTypenum.SideQuestsType5:
            case TaskTypenum.SideQuestsType17:
            case TaskTypenum.SideQuestsType18:
            case TaskTypenum.SideQuestsType19:
            case TaskTypenum.SideQuestsType20:
            case TaskTypenum.SideQuestsType21:
                {
                    if (SideQuestsDic.ContainsKey(_taskID))
                    {
                        SideQuestsDic[_taskID] = allMissionDict[_taskID];
                    }
                    else
                    {
                        SideQuestsDic.Add(_taskID, allMissionDict[_taskID]);
                    }
                    if (SideQuestChangeEvent != null)
                    {
                        SideQuestChangeEvent(_taskID);
                    }
                }
                break;
            case TaskTypenum.BountyMissionsType6:
            case TaskTypenum.BountyMissionsType7:
            case TaskTypenum.BountyMissionsType8:
                {

                    if (BountyDic.ContainsKey(_taskID))
                        BountyDic[_taskID] = allMissionDict[_taskID];
                    else
                        BountyDic.Add(_taskID, allMissionDict[_taskID]);
                    if (Event_nBounty != null)
                        Event_nBounty();
                }

                break;
            case TaskTypenum.FairyAuMissionType11:
            case TaskTypenum.FairyAuMissionType12:
                {
                    if (FairyAuDic.ContainsKey(_taskID))
                        FairyAuDic[_taskID] = allMissionDict[_taskID];
                    else
                        FairyAuDic.Add(_taskID, allMissionDict[_taskID]);
                    if (Event_FairyAuTask != null && MissionState != 3)
                        Event_FairyAuTask();
                }
                break;
            case TaskTypenum.SpecialTaskType13:
            case TaskTypenum.SpecialTaskType14:
            case TaskTypenum.SpecialTaskType16:

                {
                    if (SpecialTask.ContainsKey(_taskID))
                        SpecialTask[_taskID] = allMissionDict[_taskID];
                    else
                        SpecialTask.Add(_taskID, allMissionDict[_taskID]);
                }
                break;
            default:
                break;
        }


    }

    void TaskTypeDeletion(int _taskID)//任务类型的删除
    {

        if (MainTaskDic.ContainsKey(_taskID))//主线
        {
            MainTaskDic.Remove(_taskID);
        }
        else if (SideQuestsDic.ContainsKey(_taskID))//支线
        {
            SideQuestsDic.Remove(_taskID);
        }
        else if (BountyDic.ContainsKey(_taskID))//赏金
        {
            BountyDic.Remove(_taskID);
            if (Event_nBounty != null)
                Event_nBounty();

        }
        else if (SpecialTask.ContainsKey(_taskID))//特殊任务
        {
            SpecialTask.Remove(_taskID);
        }
        else if (FairyAuDic.ContainsKey(_taskID))
        {
            FairyAuDic.Remove(_taskID);
            if (Event_FairyAuTask != null)
                Event_FairyAuTask();
        }


    }
    string TaskDetails(string _string, int _index)////Json解析
    {
        JsonData _Json = JsonMapper.ToObject(_string);
        if (_Json.Count == 1)
        {
            string _TaskDetails = _Json["0"].ToString().Replace("\"", "");
            return _TaskDetails;
        }
        else
        {
            string _TaskDetails = _Json[_index.ToString()].ToString().Replace("\"", "");
            return _TaskDetails;
        }

    }


    List<TsakLight> CharactersReplace(string _string, int _index, int Id)
    {

        JsonData _Json = JsonMapper.ToObject(_string);
        List<TsakLight> TsakLightList = new List<TsakLight>();
        TsakLightList.Clear();
        TsakLight taskLight = new TsakLight();
        foreach (var key in _Json.Keys)
        {
            if (int.Parse(key) == _index)
            {
                JsonData _Json1 = _Json[key];
                if (_Json1.Count != 0)
                {
                    foreach (var _key in _Json1.Keys)
                    {
                        string Str = _key.ToString();
                        Match match = Regex.Match(Str, pattern);
                        if (ReplaceDic.ContainsKey(Id))
                        {
                            Dictionary<string, int> _dic = ReplaceDic[Id];
                            if (_dic.ContainsKey(match.Groups[1].Value))
                            {
                                taskLight.NpcId = _dic[match.Groups[1].Value];
                                taskLight.StateLight = int.Parse(_Json1[_key].ToString());
                                TsakLightList.Add(taskLight);
                            }
                        }
                    }
                }
                return TsakLightList;

            }
        }

        return TsakLightList;
    }

    string StrInforList(string _string, int _index)
    {
        JsonData _Json = JsonMapper.ToObject(_string);
        foreach (var key in _Json.Keys)
        {
            if (int.Parse(key) == _index)
            {
                JsonData _Json1 = _Json[key];
                if (_Json1.Count != 0)
                {
                    foreach (var _key in _Json1.Keys)
                    {
                        return _Json1[_key].ToString();
                    }
                }
            }
        }

        return string.Empty;
    }

    List<TsakLight> StrSegmentation(string _string, int _index)
    {
        int val;
        JsonData _Json = JsonMapper.ToObject(_string);
        List<TsakLight> TsakLightList = new List<TsakLight>();
        TsakLightList.Clear();

        foreach (var key in _Json.Keys)
        {
            if (int.Parse(key) == _index)
            {
                JsonData _Json1 = _Json[key];
                if (_Json1.Count != 0)
                {
                    foreach (var _key in _Json1.Keys)
                    {
                        if (int.TryParse(_key, out val))
                        {
                            TsakLight taskLight = new TsakLight();
                            taskLight.NpcId = int.Parse(_key);
                            taskLight.StateLight = int.Parse(_Json1[_key].ToString());
                            TsakLightList.Add(taskLight);
                        }
                    }
                }
                return TsakLightList;
            }
        }

        return TsakLightList;
    }

    string RewardInformation(string _string, int _index)//奖励信息
    {

        string _occupation = ("J" + PlayerDatas.Instance.baseData.Job).ToString();
        JsonData _Json = JsonMapper.ToObject(_string);
        foreach (var key in _Json.Keys)
        {
            if (int.Parse(key) == _index)
            {
                JsonData _Json1 = _Json[key];
                if (_Json1.Count != 0)
                {
                    foreach (var _key in _Json1.Keys)
                    {
                        if (_key == _occupation)
                            return _Json1[_key].ToString();
                        else if (_key == "-")
                            return _Json1[_key].ToString();
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        return null;
    }


    void TaskChanges(int MissionID, int MissionState, int DiscriptionIndex)//存在的任务的修改
    {
        //  TODO YYL
        // var pytaskM = PyTaskConfig.Get(MissionID);
        // if (pytaskM == null)
        //     return;
        // allMissionDict[MissionID].Time = DateTime.Now;
        // allMissionDict[MissionID].MissionState = MissionState;
        // allMissionDict[MissionID].descIndex = DiscriptionIndex;
        // allMissionDict[MissionID].RewardList = RewardInformation(pytaskM.rewardList, DiscriptionIndex);//奖励信息
        // allMissionDict[MissionID].Desclist = TaskDetails(pytaskM.descList, DiscriptionIndex);//任务详情
        // allMissionDict[MissionID].InforList = StrInforList(pytaskM.infoList, DiscriptionIndex);//任务完成条件


        // if (MissionState == 3)
        // {
        //     if (allMissionDict[MissionID].LightList.Equals(default(TsakLight)))
        //     {
        //         return;
        //     }
        //     for (int i = 0; i < allMissionDict[MissionID].LightList.Count; i++)
        //     {
        //         TsakLight TsakLight = new TsakLight();
        //         TsakLight.NpcId = allMissionDict[MissionID].LightList[i].NpcId;
        //         TsakLight.StateLight = -1;
        //         allMissionDict[MissionID].LightList[i] = TsakLight;
        //     }
        //     return;
        // }
        // else
        // {
        //     if (ReplaceDic.ContainsKey(MissionID))
        //     {
        //         Dictionary<string, int> _dic = ReplaceDic[MissionID];
        //         if (_dic.ContainsKey("visit_npc_id") || _dic.ContainsKey("kill_npc_id"))
        //         {
        //             allMissionDict[MissionID].LightList = CharactersReplace(pytaskM.lightList, DiscriptionIndex, allMissionDict[MissionID].ID);
        //         }
        //         else
        //         {
        //             allMissionDict[MissionID].LightList = StrSegmentation(pytaskM.lightList, DiscriptionIndex);//任务信息灯
        //         }
        //     }
        //     else
        //     {
        //         allMissionDict[MissionID].LightList = StrSegmentation(pytaskM.lightList, DiscriptionIndex);//任务信息灯
        //     }
        // }
    }

    public void Task0820(H0820_tagMissionDict info)//0820信息字典
    {
        // TODO YYL
        // Dictionary<string, int> dic = null;
        // ReplaceDic.TryGetValue((int)info.MissionID, out dic);
        // if (dic == null)
        // {
        //     dic = new Dictionary<string, int>();
        //     StorageNPCDic(info.MissionID, info.DictKey, (int)info.DictValue);
        //     dic.Add(info.DictKey, (int)info.DictValue);
        //     ReplaceDic.Add((int)info.MissionID, dic);
        // }
        // else
        // {
        //     if (dic.ContainsKey(info.DictKey))
        //     {
        //         StorageNPCDic(info.MissionID, info.DictKey, (int)info.DictValue);
        //         dic[info.DictKey] = (int)info.DictValue;
        //         if (info.DictKey == "around_allcount")
        //         {
        //             if (TaskCoinTaskEvent != null)
        //             {
        //                 TaskCoinTaskEvent();
        //             }
        //         }
        //         if (info.DictKey == "around_count_family")
        //         {
        //             if (FairyTaskEvent != null)
        //             {
        //                 FairyTaskEvent();
        //             }
        //         }
        //     }
        //     else
        //     {
        //         StorageNPCDic(info.MissionID, info.DictKey, (int)info.DictValue);
        //         dic.Add(info.DictKey, (int)info.DictValue);
        //     }
        // }
        OnTaskUpdate?.Invoke();

    }

    public void RequestGetTaskAward(string _answer, int taskId = 0)
    public void ClickTask()
    {
        // TODO YYL
        // if (taskId == clientGuardDugeonTask)
        // {
        //     ClientGuardDungeon.RequestEnter();
        //     return;
        // }
        // var sendInfo = new C0802_tagCNPCAnswer();
        // sendInfo.Answer = _answer;
        // sendInfo.AnswerLen = (byte)_answer.Length;
        // GameNetSystem.Instance.SendInfo(sendInfo);

        // if (tryGetTaskAwardEvent != null)
        // {
        //     tryGetTaskAwardEvent();
        // }
        OnTaskClick?.Invoke();
    }

    public void TaskRefreshes(int _MissionId, int _DictKeyLen, string _DictKey, int _DictValue)//任务数据的刷新（任务字典信息）
    // 任务状态 1-进行中 2-可领取
    public int GetMainTaskState()
    {

        if (!_DicTaskInformation.ContainsKey(_MissionId))
        {
            Dictionary<string, string> _dic = new Dictionary<string, string>();
            if (_dic.ContainsKey(_DictKey))
            {
                _dic[_DictKey] = _DictValue.ToString();
            }
            else
            {
                _dic.Add(_DictKey, _DictValue.ToString());
            }
            _DicTaskInformation.Add(_MissionId, _dic);
            string kaji = "kaji";
            if (_DicTaskInformation.ContainsKey(_MissionId) && _DicTaskInformation[_MissionId].ContainsKey(kaji))
            {
                if (MainTaskDic.ContainsKey(_MissionId) && MainCardLevelChange != null && _DictValue == 0)
                {

                    if (IsGetOnBool)
                    {
                        GetNowTaskID = _MissionId;
                    }
                    MainCardLevelChange(_MissionId);

                }
            }
        }
        else
        {
            if (_DicTaskInformation[_MissionId].ContainsKey(_DictKey))
            {
                _DicTaskInformation[_MissionId][_DictKey] = _DictValue.ToString();
                if (_DictKey == "kaji" && (_DictValue == 0 || _DictValue == 1))//kaji:0为主线卡级变更，kaji:1为魔族卡级变更
                {
                    if (CardLevelChange != null)
                    {
                        CardLevelChange(_MissionId);
                    }
                    if (MainTaskDic.ContainsKey(_MissionId))
                    {
                        if (IsGetOnBool)
                        {
                            GetNowTaskID = _MissionId;
                        }
                        if (MainCardLevelChange != null)
                        {
                            MainCardLevelChange(_MissionId);
                        }
                    }
                }
            }
            else
            {
                _DicTaskInformation[_MissionId].Add(_DictKey, _DictValue.ToString());
            }
        }


        if (Event_TaskInformation != null)
            Event_TaskInformation(_MissionId, _DicTaskInformation);
    }
    public void DelMission(int _taskID)//真实任务删除
    {
        if (allMissionDict.ContainsKey(_taskID))
        {
            allMissionDict.Remove(_taskID);
            if (_DicTaskInformation.ContainsKey(_taskID))
            {
                _DicTaskInformation.Remove(_taskID);
            }
        }
        TaskTypeDeletion(_taskID);
        if (Event_TaskToDelete != null)
        {
            Event_TaskToDelete(_taskID);
        }
    }
    bool _bool = false;
    string _conversationA = null;
    public void EventTalk(H0801_tagEventTalk info)//访问任务是否可提交
    {
        NPCid = (int)info.NPCID;
        if (info.Msg == null || info.Msg[0].MsgLen == 0)
        {
            _conversation = _conversationA;
        }
        else
        {
            if (_conversationA != info.Msg[0].Msg)
            {
                _conversation = info.Msg[0].Msg;
                _conversationA = _conversation;
            }
        }

        if (_bool)
        {
            if ((int)info.MissionID != 0)
            {
                _TaskNow = (int)info.MissionID;
                OnEventTalkEvent((int)info.MissionID);
                _bool = false;
                return;
            }
        }

        for (int i = 0; i < info.Answer.Length; i++)
        {
            string[] str = info.Answer[i].Msg.Split('_');
            int var;
            if (str.Length > 1)
            {
                for (int j = 0; j < info.Answer.Length; j++)
                {
                    string[] stX = info.Answer[j].Msg.Split('_');
                    if (stX.Length > 1)
                    {
                        string strXX = stX[stX.Length - 1];
                        if (int.TryParse(strXX, out var))
                        {
                            if (int.Parse(strXX) == GetNowTaskID)
                            {
                                RequestGetTaskAward(strXX);
                                _bool = true;
                                return;
                            }
                        }
                    }
                }
                string str1 = str[str.Length - 1];
                RequestGetTaskAward(str1);
                _bool = true;
                return;
            }
            else
            {
                _bool = false;
                if ((int)info.NPCID != 32504001)
                {
                    DefaultDialogue();
                }
                return;
            }
        }
        return mainTask.State;
    }

    public string pattern = @"\{(.+)\}";

    public int StatusLightQuery(int _NpcID)//状态灯查询
    //还需完成多少个任务
    public int GetNeedFinishTaskCount(int taskID)
    {
        int Light = -1;
        foreach (int key in allMissionDict.Keys)
        {
            if (allMissionDict[key].LightList.Equals(default(TsakLight)))
            {
                continue;
            }
            for (int i = 0; i < allMissionDict[key].LightList.Count; i++)
            {
                if (_NpcID == allMissionDict[key].LightList[i].NpcId)
                {
                    if (allMissionDict[key].LightList[i].StateLight > Light)
                    {
                        Light = allMissionDict[key].LightList[i].StateLight;
                    }
                }
            }
        }

        return Light;
        var taskConfig = TaskConfig.Get(taskID);
        return taskConfig.Index - TaskConfig.Get(mainTask.TaskID).Index + 1;
    }

    public void DailyFairyTaskMove()//日常仙盟任务
    public int GetMainTaskType()
    {
        // TODO YYL
        // if (SpecialTask.Count != 0)
        // {
        //     foreach (int key in SpecialTask.Keys)
        //     {
        //         if (SpecialTask[key].Type == 14 && SpecialTask[key].MissionState != 3)//未接任务
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(key));
        //             return;
        //         }
        //     }
        // }
        // if (FairyAuDic.Count != 0)
        // {
        //     foreach (int key in FairyAuDic.Keys)
        //     {
        //         if (FairyAuDic[key].MissionState != 0 && FairyAuDic[key].MissionState != 3)
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(key));
        //             return;
        //         }
        //     }
        // }
    }
    public void DailyBountyMove()//日常赏金任务
    {
        // if (SpecialTask.Count != 0)
        // {
        //     foreach (int key in SpecialTask.Keys)
        //     {
        //         if (SpecialTask[key].Type == 13 && SpecialTask[key].MissionState != 3)//未接任务
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(key));
        //             return;
        //         }
        //     }
        // }
        // if (BountyDic.Count != 0)
        // {
        //     foreach (int key in BountyDic.Keys)
        //     {
        //         if (BountyDic[key].MissionState != 0 && BountyDic[key].MissionState != 3)
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(key));
        //             return;
        //         }
        //     }
        // }
    }


    private void AutotaskingPrecedence(bool automaticityBool, int missionID)//关于是否执行自动任务和自动任务的优先级
    {
        if (automaticityBool)
        {
            var inDungeon = IsDungeon();

            if (inDungeon)//判断是否再副本中对任务ID进行储存
            {
                retainTaskID = Autotasking(missionID);
            }
            else
            {
                retainTaskID = 0;
                if (Autotasking(missionID) != 0)
                {
                    AutomaticTripToTask(Autotasking(missionID));
                }
            }
        }
    }

    private int Autotasking(int taskID)
    {
        foreach (var value in MainTaskDic.Values)
        {
            if (value.MissionState != 0 && value.MissionState != 3)
            {
                if (allMissionDict.ContainsKey(taskID) && (allMissionDict[taskID].Time - value.Time).TotalSeconds <= 1)
                {
                    if (ReplaceDic.ContainsKey(value.ID))
                    {
                        Dictionary<string, int> _dic = ReplaceDic[value.ID];
                        if (_dic.ContainsKey("continue") && _dic["continue"] == 1)
                        {
                            return value.ID;
                        }
                    }
                }
            }
        }
        if (ReplaceDic.ContainsKey(taskID))
        {
            Dictionary<string, int> _dic = ReplaceDic[taskID];
            if (_dic.ContainsKey("continue") && _dic["continue"] == 1)
            {
                return taskID;
            }
        }
        return 0;
    }


    public void AutomaticTripToTask(int _taskID)//任务自动前往（任务添加）
    {
        // TODO YYL
        // try
        // {
        //     if (!allowAutoTaskMapIds.Contains(PlayerDatas.Instance.baseData.MapID))
        //     {
        //         return;
        //     }

        //     var _hero = PlayerDatas.Instance.hero;
        //     if (_hero != null)
        //     {
        //         if (MapArea.IsInMapArea(_hero.CurMapArea, MapArea.E_Type.Boss))
        //         {
        //             return;
        //         }
        //     }

        //     if (MainTaskDic.ContainsKey(_taskID))//主线任务
        //     {
        //         if (MainTaskDic[_taskID].MissionState == 0 || MainTaskDic[_taskID].MissionState == 3)
        //             return;
        //         if (MainTaskDic.ContainsKey(_taskID))
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             if (PlayerDatas.Instance.baseData.LV != 1)
        //                 SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(_taskID));
        //             return;
        //         }
        //     }
        //     if (BountyDic.ContainsKey(_taskID))//赏金任务
        //     {
        //         if (BountyDic[_taskID].MissionState == 3 || BountyMotionBool)
        //         {
        //             return;
        //         }
        //         else
        //         {
        //             if (BountyDic.ContainsKey(_taskID))
        //             {
        //                 PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //                 SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(_taskID));
        //                 return;
        //             }
        //         }
        //     }
        //     else if (FairyAuDic.ContainsKey(_taskID))//仙盟任务
        //     {
        //         if (FairyAuDic[_taskID].MissionState == 3 || FairyAuBool)
        //         {
        //             return;
        //         }
        //         if (FairyAuDic.ContainsKey(_taskID))
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(_taskID));
        //             return;
        //         }
        //     }
        //     else if (SideQuestsDic.ContainsKey(_taskID))
        //     {
        //         if (SideQuestsDic[_taskID].MissionState == 0 || SideQuestsDic[_taskID].MissionState == 3)
        //         {
        //             return;
        //         }
        //         else
        //         {
        //             PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
        //             SnxxzGame.Instance.StartCoroutine(WaitForSkillFinished(_taskID));
        //             return;
        //         }
        //     }
        // }
        // catch (Exception ex)
        // {
        //     Debug.Log(ex);
        // }
    }

    public void RunTaskAwarInfo(HA708_tagMCRunTaskAwardInfo info)//通知跑环奖励记录
    {
        for (int i = 0; i < info.Cnt; i++)
        {
            if (!AwardRecordDic.ContainsKey(info.InfoList[i].Type))
            {
                RunTaskAwardRecord _RunTaskAwardRecord = new RunTaskAwardRecord();
                _RunTaskAwardRecord.Num = (int)info.InfoList[i].Num;
                _RunTaskAwardRecord.AwardState = info.InfoList[i].AwardState;
                AwardRecordDic.Add(info.InfoList[i].Type, _RunTaskAwardRecord);
            }
            else
            {
                AwardRecordDic[info.InfoList[i].Type].Num = (int)info.InfoList[i].Num;
                AwardRecordDic[info.InfoList[i].Type].AwardState = info.InfoList[i].AwardState;
            }
            if (info.InfoList[i].Type == (int)TaskTypenum.BountyMissionsType7)
            {
                BountyRewardsNumber = (int)info.InfoList[i].Num;
                if (Event_BountyRewards != null)
                    Event_BountyRewards((int)info.InfoList[i].Num, info.InfoList[i].AwardState);
            }
            else if (info.InfoList[i].Type == (int)TaskTypenum.FairyAuMissionType12)
            {
                OnFairyAuNumber = (int)info.InfoList[i].Num;
                if (Event_FairyAuReward != null)
                    Event_FairyAuReward((int)info.InfoList[i].Num, info.InfoList[i].AwardState);
            }
        }
    }

    // private IEnumerator WaitForSkillFinished(int _taskID)
    // {
    //     GA_Hero _hero = PlayerDatas.Instance.hero;

    //     if (_hero == null)
    //     {
    //         yield break;
    //     }
    //     while (_hero != null && _hero.SkillMgr.CurCastSkill != null &&
    //            _hero.SkillMgr.CurCastSkill.SkillCompelete == false)
    //     {
    //         yield return null;
    //     }

    //     yield return WaitingForSecondConst.WaitMS500;

    //     // 如果有守护, 则不拾取
    //     var equipIndex = EquipSet.ClientPlaceToServerPlace(new Int2(0, (int)RoleEquipType.Guard));
    //     var _itemModel = PackManager.Instance.GetItemByIndex(PackType.Equip, equipIndex);
    //     if (_itemModel == null || !GeneralDefine.GuardianPickUpID.Contains(_itemModel.itemId))
    //     {
    //         float _chkDistanceSqrt;
    //         DropItemManager.DropObject _obj = null;
    //         while (DropItemManager.HandupTryGetHeroItem(out _obj))
    //         {
    //             if (DropItemManager.StopMissionPickup)
    //             {
    //                 break;
    //             }
    //             if (MapTransferUtility.Instance.MapTransferDoType != MapTransferUtility.E_MapTransferDoType.None)
    //             {
    //                 break;
    //             }
    //             Vector3 _targetPosition = _obj.dropItem.transform.position;
    //             _chkDistanceSqrt = MathUtility.DistanceSqrtXZ(_hero.Pos, _targetPosition);
    //             if (_chkDistanceSqrt > 0.5f)
    //             {
    //                 if (_hero.State != E_ActorState.AutoRun)
    //                 {
    //                     _hero.MoveToPosition(_targetPosition);
    //                 }
    //             }

    //             yield return null;
    //         }
    //     }

    //     if (AdventureStage.Instance.IsInAdventureStage)
    //     {
    //         yield break;
    //     }

    //     if (NewBieCenter.Instance.inGuiding || ModelCenter.Instance.GetModel<TreasureModel>().newGotShowing
    //         || UIManager.Instance.IsOpened<TreasureChapterWin>())
    //     {
    //         yield break;
    //     }

    //     if (UIManager.Instance.IsOpened<TreasureBaseWin>())
    //     {
    //         yield break;
    //     }

    //     if (UIManager.Instance.IsOpened<MysteriousMissionWin>())
    //     {
    //         yield break;
    //     }

    //     if (CrossServerUtility.IsCrossServer())
    //     {
    //         yield break;
    //     }

    //     if (BossShowModel.Instance.BossShowing)
    //     {
    //         yield break;
    //     }

    //     if (BountyDic.ContainsKey(_taskID) || FairyAuDic.ContainsKey(_taskID))
    //     {
    //         yield return WaitingForSecondConst.WaitMS800;//缓冲一秒再进行
    //     }

    //     if (MainTaskDic.ContainsKey(_taskID))//主线等待表现
    //     {
    //         if (taskWait.wait)
    //         {
    //             yield return WaitingForSecondConst.GetWaitForSeconds(mainTaskAutoWaitTime);
    //         }
    //     }

    //     while(ClientSceneManager.Instance.isWaitPickup)
    //     {
    //         yield return null;
    //     }

    //     if (GA_Hero.s_MapSwitching)
    //     {
    //         yield break;
    //     }
    //     try
    //     {
    //         TaskMove(_taskID);
    //     }
    //     catch (Exception ex)
    //     {
    //         Debug.Log(ex);
    //     }

    // }


    public enum TaskStatus//任务状态
    {
        None = -5,//没有
        Normal = 0,//正常任务（绿）
        TreasureCardLevel = 1,//法宝卡级（红）
        CardLevel = 2,//等级卡级（红）
        Completed = 3,//立即完成任务
    }
    public TaskStatus GetTaskStatus(int taskID)
    {
        if (_DicTaskInformation.ContainsKey(taskID) && _DicTaskInformation[taskID].ContainsKey("kaji"))
        {
            var kaji = _DicTaskInformation[taskID]["kaji"];

            switch (int.Parse(kaji))
            {
                case 0:
                    return TaskStatus.Normal;
                case 1:
                    return TaskStatus.TreasureCardLevel;
                case 2:
                    return TaskStatus.CardLevel;
                case 3:
                    return TaskStatus.Completed;
                default:
                    return TaskStatus.None;
            }
        }
        else
        {
            return TaskStatus.None;
        }

    }
    private bool IsDungeon()//判断是否在副本中
    {
        return false;
        // if (ClientDungeonStageUtility.isClientDungeon)
        //     return true;
        // var mapId = PlayerDatas.Instance.baseData.MapID;
        // var mapConfig = MapConfig.Get(mapId);
        // return mapConfig != null && mapConfig.MapFBType != 0;
    }
    public bool IsGather(int npdId)//是否能采集NPC
    {
        // TODO YYL
        // var taskListConfig = TaskListConfig.Get(currentMission);
        // if (taskListConfig != null)
        // {
        //     int[] collectNPCList = taskListConfig.CollectNPC;
        //     var isTaskNPC = false;
        //     for (int i = 0; i < collectNPCList.Length; i++)
        //     {
        //         if (collectNPCList[i] == npdId)
        //         {
        //             isTaskNPC = true;
        //             break;
        //         }
        //     }
        //     if (isTaskNPC)
        //     {
        //         if ((collectNPCList.Length == 1 && collectNPCList[0] == 0) || GetTaskStatus(currentMission) != 0)
        //         {
        //             return false;

        //         }
        //     }
 
        // }
        return true;
    }

    public static bool IsOPenAutoResolve()//任务面板不开启自动挂机状态
    {
        bool _bool = true;
        // TODO YYL
        // if (UIManager.Instance.IsOpened<TaskBoxBGMWin>())
        // {
        //     _bool = false;
        // }
        // else if (UIManager.Instance.IsOpened<DefaultDialogueBoxWin>())
        // {
        //     _bool = false;
        // }
        // else if (UIManager.Instance.IsOpened<DialogueDuidanceWin>())
        // {
        //     _bool = false;
        // }
        return _bool;
    }

    private int BOUNTYTASK = 2009;//赏金任务
    private int FAIRYAUTASK = 3009;//仙盟任务
    private void TaskTerminationToHangUp(int taskID, int MissionState)//(完成任务后前往挂机地点)任务ID，任务状态
    {
        // TODO YYL
        // if (!isServerPrepare)
        // {
        //     return;
        // }
        // if ((taskID == BOUNTYTASK && MissionState == 1 && !BountyMotionBool && TaskAllocation.Instance.ForRingAllNumber() != 10)
        //     || (taskID == FAIRYAUTASK && MissionState == 1 && !FairyAuBool && TaskAllocation.Instance.FairyAuAllNumber() == 70))
        // {
        //     var mapModel = ModelCenter.Instance.GetModel<MapModel>();
        //     var point = mapModel.GetRecommendHangPoint();
        //     var config = MapEventPointConfig.Get(point);
        //     MapTransferUtility.Instance.MoveToNPC(config.NPCID);

        // }
    }
    public void CompletionOfTask(int TaskID)//任务完成
    {
        CA206_tagCMQuickFinishMission _CA206 = new CA206_tagCMQuickFinishMission();
        _CA206.MissionID = (uint)TaskID;
        _CA206.DoType = 0;
        GameNetSystem.Instance.SendInfo(_CA206);
    }

    public int SideQuestState(int TaskID)//关于查询任务的状态（-1没有此任务，0未接,1正在进行中，2可提交）
    {
        if (allMissionDict.ContainsKey(TaskID))
        {
            return allMissionDict[TaskID].MissionState;
        }
        else
        {
            return -1;
        }
    }

    public int GetQuestState(int _taskId)
    {
        if (allMissionDict.ContainsKey(_taskId))
        {
            return allMissionDict[_taskId].MissionState;
        }
        else
        {
            return -1;
        }
    }
    //--------主要用于记录任务列表选中条的智能性 （-_-||）
    public int TaskupToDate = 0;//获取最新任务ID
    public int GetOnTaskId = 0;
    public bool IsGetOnBool = false;
    private int NeedTime = 10;
    private DateTime dateTimeA;
    public void GetTaskGetOnNow(int TaskID, string DictKey)//记录下信息字典的ID
    {
        string key1Str = "on_kill_" + TaskID;
        string key2Str = "get_byid_" + TaskID;
        if (TaskID > 1 && (key1Str == DictKey || key2Str == DictKey))
        {
            GetOnTaskId = TaskID;
            dateTimeA = DateTime.Now;
        }

    }
    private void secondEvent()
    {
        TimeSpan timeS = DateTime.Now - dateTimeA;
        int timeSend = timeS.Seconds;
        if (timeSend >= NeedTime)
        {
            IsGetOnBool = true;
            GetOnTaskId = GetNowTaskID;//获取当前选中的ID 
        }
        else
        {
            IsGetOnBool = false;
        }

        if (TaskOverBool)
        {
            Times += 1;
            if (Times >= NeedTime)
            {
                TaskOverBool = false;
            }
        }
        else
        {
            if (Times != 0)
            {
                Times = 0;
            }
        }
    }


    public bool IsTaskMove()
    {
        bool IsBool = false;
        if (!UIManager.Instance.IsOpened<MainWin>())
        {
            return IsBool;
        }
        if (PlayerDatas.Instance.baseData.LV > TaskAutoLv)
        {
            return IsBool;
        }
        if (GetTaskStatus(currentMission) == TaskStatus.Normal)
        {
            IsBool = true;
        }
        return IsBool;
    }
    public void TaskMove(int _taskID)
    {
        //  TODO YYL
        // if (allMissionDict.ContainsKey(_taskID) && !NewBieCenter.Instance.inGuiding)
        // {
        //     string _strTest = allMissionDict[_taskID].InforList;
        //     string strTask = TaskAllocation.Instance.GetTaskInfo(TASKINFOConfig.Get(_strTest).show_writing, _taskID);
        //     HrefAnalysis.Inst.ExcuteHrefEvent(strTask, 0, true);
        //     DropItemManager.StopMissionPickup = false;
        //     TaskAllocation.Instance.TaskTime = TimeUtility.ServerNow;
        // }
    }

    public class TaskWait
    {
        public bool wait
        {
            get
            {
                foreach (var key in taskWaits.Keys)
                {
                    if ((Time.realtimeSinceStartup - taskWaits[key]) < 1f)
                    {
#if UNITY_EDITOR
                        Debug.LogFormat("<color=#00ffff>由于{0}开始任务等待</color>", GetTaskWaitTypeLabel(key));
#endif
                        return true;
                    }
                }
                return false;
            }
        }

        Dictionary<TaskWaitType, float> taskWaits = new Dictionary<TaskWaitType, float>();

        public void Push(TaskWaitType type)
        {
            taskWaits[type] = Time.realtimeSinceStartup;
        }

#if UNITY_EDITOR
        static string GetTaskWaitTypeLabel(TaskWaitType waitType)
        {
            switch (waitType)
            {
                case TaskWaitType.TaskComplete:
                    return "主界面任务完成表现";
                case TaskWaitType.LevelUp:
                    return "玩家升级表现";
                case TaskWaitType.TreasureProgress:
                    return "法宝进度更新";
                case TaskWaitType.BetterEquip:
                    return "获得更好装备";
                default:
                    return waitType.ToString();
            }
        }
#endif
    }

    public enum TaskWaitType
    {
        TaskComplete,
        LevelUp,
        TreasureProgress,
        BetterEquip,
        if (mainTask.TaskID == 0)
            return 0;
        var taskConfig = TaskConfig.Get(mainTask.TaskID);
        return taskConfig.TaskType;
    }
}