JJBB/Assets/Project/Script/Player/Mission/MissionManager.cs



using UnityEngine;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using GCGame.Table;
using Games.Events;
using Games.LogicObj;
using Games.GlobeDefine;
using Module.Log;
using Games.UserCommonData;
using Games.DailyMissionData;
using Games.Item;
using GCGame;

namespace Games.Mission
{

    //对话类型
    public enum OptionDialogType
    {
        OneDragon = 1,  //一条龙进副本对话 
        NeedMission = 2,  //需要对应的任务在身上
        CopyScene = 3,  //副本杀怪任务
        OPenUI,
    }

    //任务类型
    public enum MISSIONTYPE
    {
        MISSION_INVALID = -1,
        MISSION_DAILY,
        MISSION_MAIN,
        MISSION_BRANCH,
        MISSION_INSEC, //师门
        MISSION_ONEDRONG, //一条龙
        MISSION_GUILDTRANSPORT,  //帮会货运任务
        MISSION_GUILDDRAGONWAR,   //帮会战龙堂任务
        MISSION_GUILDPAOSHANG,   //帮会跑商任务
        MISSION_GUILDWINE,    //帮会行酒令任务
        MISSION_TREASURE,  //藏宝图
        MISSION_CIRCLE,  //循环-每日
        MISSION_BATTLE,  //战场
        MISSION_GUIDE, //每日指引任务
        MISSION_WEEKCIRCLE,  //循环-每周
        MISSION_CROSSSERVERPOST,  //跨服押镖 护送美女
        MISSION_CROSSSERVERKILLMONSTER,  //跨服杀怪
        MISSION_NONE,
    }

    public enum BRANCHTYPE
    {
        EnchanceEquip = 0,  //强化界面
        GuidList = 1,  //帮派列表界面
        AdvanceMount = 2,  //坐骑进阶
        AdvanceWing = 3,  //翅膀进阶
        MarketList = 4,  //全部玩家的店铺
        MarketSelf = 5,  //个人店铺
        MainCopy = 6,  //主线副本
        AdvanceCopy = 7,  //进阶副本
        EquipCopy = 8,  //装备副本
        Activity = 9, //活动界面
        LiveSkill = 10,  //生活技能界面
        Chat = 11,  //聊天界面 
        DreamIsLand = 12,  //空间界面
        Team = 13,  //组队界面
    
        EnchanceEquipChange = 14, //强化转移界面
        EnchanceEquipCiTiaoXiLian = 15, //词条洗练界面 
        EnchanceEquipBaseXiLian = 16, //基础洗练界面

        PetXiLian = 17, //宠物洗练界面
        PetAttr = 18, //宠物属性功能界面
        TestingCopy = 19, //试炼副本
        GetItem = 20,     // 获得物品途径UI
        Guide = 21,     // 指引
        MoSaic = 22, //宝石镶嵌
    };


    // 任务逻辑类型
    public enum TableType
    {
        Table_Invalid = -1,
        Table_Story,          //剧情
        Table_KillMonster,    //杀怪
        Table_Delivery,   // 送信
        Table_CollectItem,   //收集物品
        Table_Enterarea,  // 探索区域
        Table_LootItem,   // 寻物
        Table_CopySceneMonster,   // 副本任务
        Table_LevelUp,  // 升级
        Table_OperationNum, // 操作次数
        Table_MissionInTime,  //限时任务

        Table_MissionAdvanceCopy = 12, //通关副本
        Table_MissionQuestion = 13, //主线任务答题
        Mission_Num,
    }

    public enum DailyMissionType
    {
        DailyMissionType_Invalid = -1,
        DailyMissionType_Master,          //门派
        DailyMissionType_KillMonster,    //杀怪
        DailyMissionType_CopyScene,     //副本
        DailyMissionType_Strength,   // 强化
        DailyMissionType_Pvp,  // 竞技
        DailyMissionType_GuildWar,   // 帮战
        DailyMissionType_Award,   // 抽奖
        DailyMissionType_Belle,   // 美人
        DailyMissionType_Fellow,   // 伙伴
        DailyMissionType_Num
    }

    public enum MissionState
    {
        Mission_None = 0,       // 无状态
        Mission_Accepted,   // 已接任务未完成
        Mission_Completed,  // 已完成未提交
        Mission_Failed,     // 任务失败
        Mission_NotAccept, //任务未接
    }

    public enum MISSION_QUALITY
    {
        MISSION_QUALITY_NONE = 0,
        MISSION_QUALITY_WHITE = 1,
        MISSION_QUALITY_GREEN = 2,
        MISSION_QUALITY_BLUE = 3,
        MISSION_QUALITY_PURPLE = 4,
        MISSION_QUALITY_ORANGE = 5,
    }

    /// <summary>
    /// 当前拥有的任务信息,需要服务器同步
    /// </summary>
    public class CurOwnMission
    {
        public const byte MAX_MISSION_PARAM_NUM = 8;

        public int m_nMissionID;   //任务ID

        public byte m_yStatus;      //任务状态 1表示进行中，2表示完成，3表示失败，4未接取(用于剧情未达到接取等级)
        public byte m_yFlags;       // 0x0000 |FollowChanged事件|ItemChanged事件|EnterZone事件|KillObject事件|
        public byte m_yQuality;    // 任务品质 白、绿、蓝、紫、橙
        public Int32 m_CompleteFlag; //多任务完成状态 根据类型对应下标位数值  代表任务完成状态【01010101】
        public Int32[] m_nParam;      //当前任务的参数

        public int m_CurMissionIndex = 0; //当前任务子任务的下标

        public CurOwnMission()
        {
            CleanUp();
        }

        public void CleanUp()
        {
            if (null == m_nParam)
            {
                m_nParam = new Int32[MAX_MISSION_PARAM_NUM];
            }
            m_nMissionID = -1;
            m_yStatus = 0;
            m_yFlags = 0;
            m_yQuality = 0;
            m_CompleteFlag = 0;
            //var height = m_CompleteFlag >> 16 & 256;
            //var low = m_CompleteFlag & 256;

            for (int i = 0; i < MAX_MISSION_PARAM_NUM; ++i)
            {
                m_nParam[i] = 0;
            }
        }

        public void SetStatus(byte status)
        {
            m_yStatus = status;
        }
    }

    /// <summary>
    /// 任务列表
    /// </summary>
    public class MissionList
    {
        public const byte MAX_CHAR_MISSION_NUM = 128;   //玩家可以接受的最大任务数量
        public const UInt16 MAX_CHAR_MISSION_FLAG_LEN = 128; //

        public byte m_Count = 0;

        public Dictionary<int, CurOwnMission> m_aMission;         //角色目前拥有的任务数据
        public UInt32[] m_aMissionHaveDoneFlags;   //角色的任务完成标志，支持最多(MAX_CHAR_MISSION_FLAG_LEN * 32)个任务

        public MissionList()
        {
            m_Count = 0;
            m_aMission = new Dictionary<int, CurOwnMission>();
            m_aMissionHaveDoneFlags = new UInt32[MAX_CHAR_MISSION_FLAG_LEN];
        }

        public bool IsMissionFull()
        {
            if (m_aMission.Count > MAX_CHAR_MISSION_NUM)
            {
                return true;
            }
            return false;
        }

        public void CleanUp()
        {
            m_aMission.Clear();
            for (int i = 0; i < MAX_CHAR_MISSION_FLAG_LEN; i++)
            {
                m_aMissionHaveDoneFlags[i] = 0;
            }
        }

    };

    public class MissionManager
    {
        public const string _MainTypeColor = "<color=#ecdd94>{0}</color>";
        public const string _BranchTypeColor = "<color=#72fe72>{0}</color>";
        public const string _CircleTypeColor = "<color=#37fcfc>{0}</color>";
        public const string _MissionInSecTypeColor = "<color=#bebdff>{0}</color>";
        public const string _GuildZLTangTypeColor = "<color=#f4adaa>{0}</color>";
        public const string _GuildHuoYunTypeColor = "<color=#d4b2f4>{0}</color>";
        public const string _GuildPaoShangeTypeColor = "<color=#ffa6fc>{0}</color>";
        public const string _OneDragonTypeColor = "<color=#fea6d0>{0}</color>";
        public const string _BattleAreaTypeColor = "<color=#95bfee>{0}</color>";
        public const string _GuildXingjiulingTypeColor = "<color=#95eeb8>{0}</color>";
        public const string _TreasureTypeColor = "<color=#afee95>{0}</color>";
        private const string _QuadText = "<color=#00000000>占位</color>";
        private MissionList m_MissionList;  //任务列表
        public MissionList MissionList
        {
            get
            {
                return m_MissionList;
            }
        }

        //记录当前卡级的主线任务ID
        private int m_CurStopMissionId = -1;
        public int CurStopMissionId
        {
            get { return m_CurStopMissionId; }
            set
            {
                m_CurStopMissionId = value;
            }
        }

        //忽略前序任务标记
        private int m_IgnoreMissionPreFlag;
        public int IgnoreMissionPreFlag
        {
            set { m_IgnoreMissionPreFlag = value; }
        }

        //是否完成一轮师门标记
        //public bool m_isFinalMissionInSec = false;
        //public bool m_IsMissionInSecOver = false;
        public int m_CurActionMissionId = -1;

        public MissionManager()
        {
            m_MissionList = new MissionList();
            m_IgnoreMissionPreFlag = 0;
        }

        /// <summary>
        /// 跟服务器实时同步当前任务的子任务完成状态
        /// </summary>
        /// <param name="missionId"></param>
        /// <param name="flag"></param>
        public void setMyCompleteFlag(int missionId, Int32 flag)
        {
            //同步当前任务子任务的完成情况
            m_MissionList.m_aMission[missionId].m_CompleteFlag = flag;

            //当前实时更新的CompleteFlag所得到的正在进行的子任务的Index与服务器初始化时下发的正在进行的子任务的Index进行比较
            //发生变化的时候证明当前子任务已经完成 需要执行下一个子任务或者提交
            if (getCurMissionIndex(missionId) > m_MissionList.m_aMission[missionId].m_CurMissionIndex)  //战龙堂的召唤怪物需要特殊处理
            {
                if(!SpecialMissionOpt(missionId))  //战龙堂任务特殊处理(寻路场景的问题)
                {
                    MissionPathFinder(missionId);
                }
                m_MissionList.m_aMission[missionId].m_CurMissionIndex = getCurMissionIndex(missionId);  //将初始化时候下发的Index跟当前正在进行的子任务Index进行同步、
            }


            //通过子任务控制的话这边就在同步子任务状态的时候刷新一次任务采集物(但是可能状态还没同步，蛋疼)
            Singleton<CollectItem>.Instance.InitMissionCollectItem();
        }

        public bool SpecialMissionOpt(int missionId)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if(missionBase == null)
            {
                return false;
            }
            if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR)
            {
                if ((MissionState)GameManager.gameManager.MissionManager.GetMissionState(missionId) == MissionState.Mission_Completed)
                {
                    GameManager.gameManager.MissionManager.MissionPathFinder(missionId, GameManager.gameManager.PlayerDataPool.GuildInfo.GuildGuid);
                }
                else
                {
                    if (GameManager.gameManager.PlayerDataPool.DragonWar_destanceGuildGuid != Games.GlobeDefine.GlobeVar.INVALID_GUID)
                    {
                        MissionPathFinder(missionId, GameManager.gameManager.PlayerDataPool.DragonWar_destanceGuildGuid);
                    }
                }

                return true;
            }
            return false;
        }

        /// <summary>
        /// 获取限时任务的服务器结束时间
        /// </summary>
        /// <param name="missionId"></param>
        /// <returns></returns>
        public int GetServerMissionOverTime(int missionId)
        {
            if (IsHaveMission(missionId) && GetMissionLogicType(missionId, TableType.Table_MissionInTime))
            {
                int leaveTime = m_MissionList.m_aMission[missionId].m_nParam[7] - (int)Time.realtimeSinceStartup;
                if (leaveTime > 0)
                    return leaveTime;
            }
            return 0;
        }

        /// <summary>
        /// 通过任务ID获取当前任务的轮次数
        /// </summary>
        /// <param name="missionId"></param>
        /// <returns></returns>
        public int GteMissionTurnCount(int missionId)
        {
            if (IsHaveMission(missionId))
            {
                return m_MissionList.m_aMission[missionId].m_nParam[6];
            }
            else
                return 0;
        }


        /// <summary>
        /// 客户端检查，是否可以接受任务
        /// </summary>
        /// <param name="nMissionID">任务ID</param>
        /// <returns>成功与否</returns>
        public bool CanAcceptMission(int nMissionID, bool isTip = false)
        {

            Tab_MissionBase misLine = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (misLine == null)
                return false;

            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(misLine.LimitID, 0);
            if (missionLimit != null)
            {

                if (Singleton<ObjManager>.GetInstance().MainPlayer 
                    && missionLimit.ClassNeed != -1
                    && ((1 << Singleton<ObjManager>.GetInstance().MainPlayer.Profession) & missionLimit.ClassNeed) == 0)
                {
                    return false;
                }
            }

            if(IsHaveThisTypeMission(nMissionID))
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                if(missionBase.MissionType != (int)MISSIONTYPE.MISSION_MAIN)
                {
                    return false;
                }
            }
            
            if(IsRingMissionCompleted(nMissionID, false))
            {
                return false;
            }

            // 0、任务是否已满
            if (m_MissionList.IsMissionFull())
            {
                return false;
            }

            // 1、检查玩家身上是否有任务
            if (true == IsHaveMission(nMissionID)
                && MissionState.Mission_Failed != (MissionState)GetMissionState(nMissionID))
            {
                return false;
            }

            Tab_MissionLimit misLimitLine = TableManager.GetMissionLimitByID(misLine.LimitID, 0);
            if (misLimitLine == null) // 无限制
            {
                return true;
            }

            // 2、任务限制等级
            if (!Singleton<ObjManager>.Instance.MainPlayer)
            {
                return false;
            }
            int nPlayerLevel = Singleton<ObjManager>.Instance.MainPlayer.BaseAttr.Level;
            if (misLimitLine.LowLevel > nPlayerLevel)
            {
                return false;
            }

            // 3、检查玩家是否完成任务
            if (misLimitLine.IsLoop != 1)
            {
                if (true == IsMissionHaveDone(nMissionID))
                {
                    return false;
                }
            }

            // 4、检查前续任务
            if (m_IgnoreMissionPreFlag != -1)
            {
                if (misLimitLine.PreMission > -1 && !IsMissionHaveDone(misLimitLine.PreMission))
                {
                    return false;
                }
            }

            if (misLimitLine.ItemNeed != -1)
            {
                int itemCount = GameManager.gameManager.PlayerDataPool.BackPack.GetItemCountByDataId(misLimitLine.ItemNeed);
                if (itemCount <= 0)
                {
                    return false;
                }
            }

            if (misLimitLine.InGuild == 1)
            {
                if (GameManager.gameManager.PlayerDataPool.IsHaveGuild() == false)
                {
                    return false;
                }
            }

            //护送类型任务处理
            if (misLine.MissionType == (int)MISSIONTYPE.MISSION_CROSSSERVERKILLMONSTER)
            {
                var activityBase = ActivityDataManager.Instance.GetActivityTabByServerType(ActivityDataManager.Activity_Type.CROSS_SER_ESCORT);
                if (activityBase == null)
                    return false;
                var missionLimitTimes = activityBase.ActityLimitTimes;
                if (ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.CROSS_SER_ESCORT) >= missionLimitTimes)
                {
                    return false;
                }
            }

            return true;
        }

        //获取宝图任务的ID
        public int GetTreasureMissionId()
        {
            foreach (KeyValuePair<int, CurOwnMission> kvp in m_MissionList.m_aMission)
            {
                if (kvp.Key < 0)
                    continue;
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(kvp.Key, 0);
                 if(missionBase != null)
                {
                    if(missionBase.MissionType == (int)MISSIONTYPE.MISSION_TREASURE)
                    {
                        return kvp.Key;
                    }
                }
            }

            return -1;
        }

        /// <summary>
        /// 通过任务ID获取当前任务需要完成的条件数量
        /// </summary>
        /// <param name="nMissionId"></param>
        /// <returns></returns>
        public int getCurMissionTypeCount(int nMissionId)
        {

            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionId, 0);
            if (missionBase == null)
                return 0;

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
            if (missionLogic == null)
                return 0;

            int m_MissionCount = 0;
            for (int index = 0; index < missionLogic.getLogicTypeCount(); index++)
            {
                int m_MissionType = missionLogic.GetLogicTypebyIndex(index);
                if (m_MissionType != -1)  //不为空
                {
                    m_MissionCount++;
                }
            }
            return m_MissionCount;
        }

        /// <summary>
        /// 通过任务ID获取当前任务正在进行子条件下标
        /// </summary>
        /// <param name="missionId"></param>
        /// <returns></returns>
        public int getCurMissionIndex(int missionId)
        {
            int m_CurMissionIndex = 0;  //置为Invalid
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if (missionBase == null)
                return m_CurMissionIndex;

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
            if (missionLogic == null)
                return m_CurMissionIndex;

            int m_CompleteFlag = 0;
            if (MissionList.m_aMission.ContainsKey(missionId))
            {
                m_CompleteFlag = m_MissionList.m_aMission[missionId].m_CompleteFlag;  //获取当前任务完成条件的情况
            }
            else
            {
                m_CompleteFlag = 0;
            }
            for (int index = 0; index < getCurMissionTypeCount(missionId); index++)
            {
                if (curMissionState(m_CompleteFlag, index) != 0)  //当前任务的子条件已经完成
                {
                    m_CurMissionIndex++;
                }
                else
                {
                    return m_CurMissionIndex;
                }
            }

            if (m_CurMissionIndex == getCurMissionTypeCount(missionId))
            {
                return --m_CurMissionIndex;  //超出界限  返回最后一个子任务
            }
            return m_CurMissionIndex;
        }

        /// <summary>
        /// 客户端添加任务
        /// </summary>
        /// <param name="nMissionID">任务ID</param>
        /// <returns>返回添加成功与否</returns>
        bool AddMission(int nMissionID, byte yQuality = 0)
        {
            if (nMissionID < 0)
            {
                return false;
            }

            if (m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                if (m_MissionList.m_aMission[nMissionID].m_yStatus != (int)MissionState.Mission_NotAccept) //任务不是未接取状态
                    return false;
            }

            Tab_MissionBase mission = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (mission == null)
                return false;
            if (mission.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG)
            {
                OneDragonAuto.isOneDragonAutoSearch = true;
                OneDragonAuto.isOneDragonAutoSearchStop = true;
            }
            if (mission.MissionType == (int)MISSIONTYPE.MISSION_CROSSSERVERPOST)
            {
                Singleton<SignPostManager>.Instance.CrossServerPost(nMissionID, false);
            }
            int _NeedDeleteMissionId = -1;
            //判断当前任务中是否有对应类型的指引任务 然后删除
            foreach (var info in m_MissionList.m_aMission)
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(info.Key, 0);
                if (missionBase != null && missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUIDE)
                {
                    Tab_MissionGuidBase guidBase = TableManager.GetMissionGuidBaseByID(info.Key, 0);
                    if (guidBase != null)
                    {
                        if (guidBase.MissionBaseType == mission.MissionType)
                        {
                            _NeedDeleteMissionId = info.Key;
                            break;
                        }
                    }
                }
            }

            if(_NeedDeleteMissionId != -1 && m_MissionList.m_aMission.ContainsKey(_NeedDeleteMissionId))
            {
                m_MissionList.m_aMission.Remove(_NeedDeleteMissionId);
            }

            CurOwnMission tempMission = new CurOwnMission();
            tempMission.CleanUp();
            tempMission.m_nMissionID = nMissionID;
            tempMission.m_yQuality = yQuality;
            if (m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                if (m_MissionList.m_aMission[nMissionID].m_yStatus == (int)MissionState.Mission_NotAccept) //任务是未接取状态 接取任务之后转换成接取状态
                    m_MissionList.m_aMission[nMissionID].m_yStatus = 1;
            }
            else
            {
                m_MissionList.m_aMission.Add(nMissionID, tempMission);
            }

            return true;
        }

        /// <summary>
        /// 客户端删除一个任务
        /// </summary>
        /// <param name="nMissionID"></param>
        /// <returns></returns>
        bool DelMission(int nMissionID)
        {
            if (nMissionID < 0)
            {
                return false;
            }

            bool bRet = m_MissionList.m_aMission.Remove(nMissionID);
            if(bRet)
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                if(missionBase!=null)
                {
                    if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDPAOSHANG)
                    {
                        GameManager.gameManager.AutoSearch.RoadSignManager.Stop(RoadSignManager.RoadType.Mission,nMissionID);
                        GameManager.gameManager.AutoSearch.RoadSignManager.Stop(RoadSignManager.RoadType.Gharry, 0);
                    }

                    if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDTRANSPORT)
                    {
                        SysShopController.DelNeed((int)SysShopController.ItemNeedSys.GuildTransport, -1, true);
                        GuildTransport._addedNum = 0;
                    }
                    if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_CROSSSERVERPOST)
                    {
                        Singleton<SignPostManager>.Instance.CrossServerPost(nMissionID, true);
                    }

                }
            }

            return bRet;
        }

        /// <summary>
        /// 完成任务，这里以后需要由服务器同步过来
        /// </summary>
        /// <param name="nMissionID"></param>
        /// <returns></returns>
        bool SetMissionHaveDone(int nMissionID)
        {
            int idIndex = (nMissionID >> 5);
            if (idIndex < MissionList.MAX_CHAR_MISSION_FLAG_LEN)
            {
                UInt32 uData = (UInt32)nMissionID & 0x0000001f;
                m_MissionList.m_aMissionHaveDoneFlags[idIndex] |= (UInt32)(0x00000001 << (Int32)uData);

                return true;
            }
            return false;
        }

        public bool IsMissionHaveDone(int nMissionID)
        {
            if (nMissionID < 0 || IsRingMissionAndCompleted(nMissionID))
            {
                return true;
            }

            int idIndex = (nMissionID >> 5);  //index为0开始 任务Index最大为31     31 >> 5 == 0;
            if (idIndex < MissionList.MAX_CHAR_MISSION_FLAG_LEN)
            {
                UInt32 uRet = (UInt32)(0x00000001 << ((Int32)nMissionID & 0x0000001F)) & m_MissionList.m_aMissionHaveDoneFlags[idIndex];
                return (uRet != 0);
            }

            return false;
        }

        public bool IsRingMissionAndCompleted(int missionId)
        {
            Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if (MissionBase == null)
            {
                return true;
            }

            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(MissionBase.LimitID, 0);
            if (missionLimit != null)
            {
                if (missionLimit.ClassNeed != -1
                    && ((1 << Singleton<ObjManager>.GetInstance().MainPlayer.Profession) & missionLimit.ClassNeed) == 0)
                {
                    return true;
                }
            }

            var _MissionNext = TableManager.GetMissionNextByID(MissionBase.NextMission, 0);
            if (_MissionNext != null)
            {
                var _NextMissionBaseId = _MissionNext.GetMissionIDbyIndex(0);
                //环任务完成之后不显示图标
                if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC && GameManager.gameManager.MissionManager.IsRingMissionCompleted(_NextMissionBaseId, false))
                {
                    return true;
                }

                if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_TREASURE && GameManager.gameManager.MissionManager.IsRingMissionCompleted(_NextMissionBaseId, false))
                {
                    return true;
                }

                if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG && GameManager.gameManager.MissionManager.IsRingMissionCompleted(_NextMissionBaseId, false))
                {
                    return true;
                }

                if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_CIRCLE && GameManager.gameManager.MissionManager.IsRingMissionCompleted(_NextMissionBaseId, false))
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsInsecMission(int missionId)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if(missionBase != null && missionBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC)
            {
                return true;
            }
            return false;
        }

        // 通过任务ID取该任务在任务表表的索引值， 无该任务时返回UINT_MAX
       // public int GetMissionIndexByID(int nMissionID) { return 1; }

        // 任务参数
        public void SetMissionParam(int nMissionID, int nParamIndex, int nValue)
        {
            if (!m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                return;
            }
            if (nParamIndex >= 0 && nParamIndex < CurOwnMission.MAX_MISSION_PARAM_NUM)
            {
                if (nParamIndex == 7)   //倒计时参数
                {
                    m_MissionList.m_aMission[nMissionID].m_nParam[nParamIndex] = nValue + (int)Time.realtimeSinceStartup;
                }
                else
                {
                    m_MissionList.m_aMission[nMissionID].m_nParam[nParamIndex] = nValue;
                }
            }
            NotifyMissionUI(nMissionID, "state");

            if(CrossServerCopyInfoCtr.Instance && CrossServerCopyInfoCtr.Instance._MissionId == nMissionID)
            {
                CrossServerCopyInfoCtr.Instance.RefreshMisisonParam();
            }
        }

        public int GetMissionParam(int nMissionID, int nParamIndex)
        {
            if (!m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                return -1;
            }

            if (nParamIndex >= 0 && nParamIndex < CurOwnMission.MAX_MISSION_PARAM_NUM)
            {
                return m_MissionList.m_aMission[nMissionID].m_nParam[nParamIndex];
            }
            return -1;
        }

        public string GetModifiedColorTitle(MISSIONTYPE type, string _Title)
        {
            switch(type)
            {
                case MISSIONTYPE.MISSION_MAIN:
                    return String.Format(_MainTypeColor, _Title);
                case MISSIONTYPE.MISSION_BRANCH:
                    return String.Format(_BranchTypeColor, _Title);
                case MISSIONTYPE.MISSION_INSEC:
                    return String.Format(_MissionInSecTypeColor, _Title);
                case MISSIONTYPE.MISSION_GUILDDRAGONWAR:
                    return String.Format(_MissionInSecTypeColor, _Title);
                case MISSIONTYPE.MISSION_ONEDRONG:
                    return String.Format(_OneDragonTypeColor, _Title);
                case MISSIONTYPE.MISSION_GUILDTRANSPORT:
                    return String.Format(_GuildHuoYunTypeColor, _Title);
                case MISSIONTYPE.MISSION_GUILDPAOSHANG:
                    return String.Format(_GuildPaoShangeTypeColor, _Title);
                case MISSIONTYPE.MISSION_GUILDWINE:
                    return String.Format(_GuildXingjiulingTypeColor, _Title);
                case MISSIONTYPE.MISSION_TREASURE:
                    return String.Format(_TreasureTypeColor, _Title);
                case MISSIONTYPE.MISSION_CIRCLE:
                    return String.Format(_CircleTypeColor, _Title);
                case MISSIONTYPE.MISSION_BATTLE:
                    return String.Format(_BattleAreaTypeColor, _Title);
                default:
                    return _Title;
            }
        }

        public string GetModifiedMissionTitle(int missionID)
        {
            string missionTitle = "";

            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionID, 0);
            if (missionBase == null)
                return missionTitle;

            if(missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUIDE)
            {
                Tab_MissionGuidBase guidMissionBase = TableManager.GetMissionGuidBaseByID(missionID, 0);
                if(guidMissionBase == null)
                {
                    return missionTitle;
                }
                return _QuadText + guidMissionBase.MissionName;
            }

            Tab_MissionDictionary MDLine = TableManager.GetMissionDictionaryByID(missionID, 0);
            if (MDLine == null)
            {
                return missionTitle;
            }

            MissionState misState = (MissionState)GetMissionState(missionID);
          

            if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR)
            {
                Tab_GuildOther guildOther = TableManager.GetGuildOtherByID(0, 0);
                if (guildOther != null)
                {
                    missionTitle = 
                    StrDictionary.GetClientDictionaryString("#{2990}", MDLine.MissionName, GameManager.gameManager.PlayerDataPool.DragonWar_DayRecvTimes + 1, guildOther.DayDragonWarCount);
                }
            }
            if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG || missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR)
            {
                Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(missionBase.LimitID, 0);
                if (missionLimit != null)
                {
                    missionTitle = StrDictionary.GetClientDictionaryString("#{2990}", MDLine.MissionName,
                        GetMissionTurnsCount(missionID), missionLimit.OneTurnCount);
                }
            }
            else
            {
                if (missionBase.NextMission != -1 && IsRingMission(missionID))  //显示环任务轮次
                {
                    Tab_MissionNext missionNext = TableManager.GetMissionNextByID(missionBase.NextMission, 0);
                    if(missionNext != null)
                    {
                        Tab_MissionBase nextMissionBase = TableManager.GetMissionBaseByID(missionNext.GetMissionIDbyIndex(0), 0);
                        Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(nextMissionBase.LimitID, 0);
                        if (missionLimit != null)
                        {
                            missionTitle = StrDictionary.GetClientDictionaryString("#{2990}", MDLine.MissionName, GetMissionTurnsCount(missionID), missionLimit.OneTurnCount);
                        }
                        else
                        {
                            missionTitle = MDLine.MissionName;
                        }
                    }
                }else
                {
                    missionTitle = MDLine.MissionName;
                }
            }
            missionTitle = GetModifiedColorTitle((MISSIONTYPE)missionBase.MissionType, missionTitle);
            if (misState == MissionState.Mission_Completed)
            {
                missionTitle += "\u00A0\u00A0\u00A0\u00A0<color=#5bd55bff>" + StrDictionary.GetClientDictionaryString("#{1621}") + "</color>";
            }
            return _QuadText + missionTitle;
        }

        public string GetModifiedMissionTarget(int missionID, int index, ref bool isCanRetchTarget)  //通过任务ID 任务下标 获取当前任务的参数
        {
            isCanRetchTarget = true;
            //判断等级需求
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionID, 0);
            if (missionBase == null)
            {
                return "";
            }
            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(missionBase.LimitID, 0);
            if (missionLimit == null)
            {
                return "";
            }
            int m_PlayerLevel = GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level;
            var level1 = int.Parse(TableManager.GetSystemParamByID(44, 0).StringValue);
            var level2 = int.Parse(TableManager.GetSystemParamByID(45, 0).StringValue);
            if (m_PlayerLevel < missionLimit.LowLevel)
            {
                if(m_PlayerLevel < level1)
                {
                    isCanRetchTarget = false;
                    return StrDictionary.GetClientDictionaryString("#{42501}", missionLimit.LowLevel);
                }
                else if(m_PlayerLevel >= level1 && m_PlayerLevel < level2)
                {
                    isCanRetchTarget = false;
                    return StrDictionary.GetClientDictionaryString("#{42515}", missionLimit.LowLevel);
                }
                else
                {
                    isCanRetchTarget = false;
                    return StrDictionary.GetClientDictionaryString("#{42516}", missionLimit.LowLevel);
                }
            }
            else if (MissionList.m_aMission[missionID].m_yStatus == (int)MissionState.Mission_NotAccept)
            {
                return StrDictionary.GetClientDictionaryString("#{42512}");
            }

                
            string missionTarget = "";
            Tab_MissionDictionary MDLine = TableManager.GetMissionDictionaryByID(missionID, 0);
            if (MDLine == null)
            {
                return missionTarget;
            }

            if (MDLine.GetFollowTextbyIndex(index) == "-1")  //为-1的时候没有任务
            {
                return missionTarget;
            }

            int nParam = GameManager.gameManager.MissionManager.GetMissionParam(missionID, index);
            missionTarget = string.Format(MDLine.GetFollowTextbyIndex(index), nParam);
            return missionTarget;
        }
        
        public int CanAcceptMissionTip(int nMissionID, bool isTip = false)
        {
            Tab_MissionBase misLine = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (misLine == null)
                return -1;

            //MissionLimit新增职业限制字段
            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(misLine.LimitID, 0);
            if (missionLimit != null)
            {
                if (missionLimit.ClassNeed != -1
                    && ((1 << Singleton<ObjManager>.GetInstance().MainPlayer.Profession) & missionLimit.ClassNeed) == 0)
                {
                    return -2;
                }
            }

            // 0、任务是否已满
            if (m_MissionList.IsMissionFull())
            {
                // 提示 任务已满
                if (isTip)
                { 
                    LogModule.ErrorLog("已存在的任务 : " + nMissionID);
                    GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1262}"));
                }
                return -3;
            }

            // 1、检查玩家身上是否有任务
            if (true == IsHaveMission(nMissionID)
                && MissionState.Mission_Failed != (MissionState)GetMissionState(nMissionID))
            {
                if (isTip)
                    GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1265}"));
                return -4;
            }

            Tab_MissionLimit misLimitLine = TableManager.GetMissionLimitByID(misLine.LimitID, 0);
            if (misLimitLine == null) // 无限制
            {
                return 0;
            }

            // 2、任务限制等级
            int nPlayerLevel = Singleton<ObjManager>.Instance.MainPlayer.BaseAttr.Level;
            if (misLimitLine.LowLevel > nPlayerLevel)
            {
                if (isTip)
                    GUIData.AddNotifyData(string.Format(StrDictionary.GetClientDictionaryString("#{1266}", misLimitLine.LowLevel)));
                return -5;
            }

            // 3、检查玩家是否完成任务
            if (misLimitLine.IsLoop != 1)
            {
                if (true == IsMissionHaveDone(nMissionID))
                {
                    if (isTip)
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1264}"));
                    // 提示 任务已完成
                    return -6;
                }
            }

            // 4、检查前续任务
            if (m_IgnoreMissionPreFlag == 0)
            {
                if (misLimitLine.PreMission > -1 && !IsMissionHaveDone(misLimitLine.PreMission))
                {
                    if (isTip)
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1267}"));
                    return -7;
                }
            }

            if (misLimitLine.ItemNeed != -1)
            {
                int itemCount = GameManager.gameManager.PlayerDataPool.BackPack.GetItemCountByDataId(misLimitLine.ItemNeed);
                if (itemCount <= 0)
                {
                    if (isTip)
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1269}"));
                    return -8;
                }
            }

            if (misLimitLine.TeamNeed > 0)
            {
                if (GameManager.gameManager.PlayerDataPool.IsHaveTeam())
                {
                    TeamMember member = GameManager.gameManager.PlayerDataPool.TeamInfo.GetTeamMemberByguiId(Singleton<ObjManager>.Instance.MainPlayer.GUID);
                    if (member == null)
                    {
                        if (isTip)
                            GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{1269}"));
                        return -9;
                    }
                    if (member.TeamJob == 1)
                    {
                        if (isTip)
                            GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{7013}"));
                        return -9;
                    }
                }
                else
                {
                    if (isTip)
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{7016}"));
                    return -9;
                }
            }
            int countMem = GameManager.gameManager.PlayerDataPool.TeamInfo.GetTeamMemberCount();
            if (GameManager.gameManager.PlayerDataPool.TeamInfo.GetTeamMemberCount() < misLimitLine.TeamNeedPeople)
            {
                if (isTip)
                    GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{7014}", misLimitLine.TeamNeedPeople));
                return -9;
            }

            //一条龙特殊处理一下
            if(misLine.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG)
            {
                for(int i=0;i< GameManager.gameManager.PlayerDataPool.TeamInfo.teamMember.Length;i++)
                {
                    TeamMember member = GameManager.gameManager.PlayerDataPool.TeamInfo.teamMember[i];
                    if(member!=null && member.IsValid() && member.Level < misLimitLine.LowLevel)
                    {
                        if (isTip)
                            GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{5166}", misLimitLine.LowLevel));
                        return -10;
                    }
                }
            }

            if (misLimitLine.InGuild == 1)
            {
                if (GameManager.gameManager.PlayerDataPool.IsHaveGuild() == false)
                {
                    if (isTip)
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{7015}"));
                    return -13;
                }
            }

            return 0;
        }

        public enum AcceptMissionType
        {
            MISSIONID = 0,  //任务Id
            MISSIONNEXT = 1,  //任务下个Id
        }

        // 接任务 给服务器发包
        public int AcceptMission(int nMissionID, AcceptMissionType type)
        {
            // 添加任务接取判断条件
            int result = CanAcceptMissionTip(nMissionID, true);
            if (result < 0)
                return result;

            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (missionBase == null)
                return 0;

            if (missionBase.ActiveID != -1)
            {
                var activeBase =  ActivityDataManager.Instance.GetActivityTabByServerType((ActivityDataManager.Activity_Type)missionBase.ActiveID);
                if (activeBase != null)
                {
                    int times = ActivityDataManager.Instance.GetActivityCompleteTimes(activeBase.ActivityServerType);
                    times = (times < 0 ? 0 : times);
                    //特殊处理一下战龙堂的
                    if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR && times>5)
                    {
                        Tab_StrDictionary pDictionary = TableManager.GetStrDictionaryByID(25199, 0);
                        if (pDictionary != null)
                        {
                            MessageBoxLogic.OpenOKCancelBox(pDictionary.StrDictionary, "", delegate ()
                            {
                                CG_ACCEPTMISSION askMission1 = (CG_ACCEPTMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_ACCEPTMISSION);
                                askMission1.SetMissionID(nMissionID);
                                askMission1.SetAcceptType((int)type);
                                askMission1.SendPacket();
                            }, null);
                            return 0;
                        }
                    }


                    if (times >= missionBase.ActiveTimes1)
                    {
                        Tab_StrDictionary pDictionary = TableManager.GetStrDictionaryByID(missionBase.Tips1, 0);
                        if (pDictionary != null)
                        {
                            MessageBoxLogic.OpenOKCancelBox(pDictionary.StrDictionary, "", delegate ()
                            {
                                CG_ACCEPTMISSION askMission1 = (CG_ACCEPTMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_ACCEPTMISSION);
                                askMission1.SetMissionID(nMissionID);
                                askMission1.SetAcceptType((int)type);
                                askMission1.SendPacket();
                            }, null);
                            return 0;
                        }
                    }
                }
            }

            // 给服务器发包
            CG_ACCEPTMISSION askMission = (CG_ACCEPTMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_ACCEPTMISSION);
            askMission.SetMissionID(nMissionID);
            askMission.SetAcceptType((int)type);
            askMission.SendPacket();

            return 0;
        }

        /// <summary>
        /// 获取当前任务对应类型的完成状态 通过位运算获取
        /// </summary>
        /// <param name="completeFlag"></param>w
        /// <param name="logicType"></param>
        /// <returns>1表示已经完成  0表示未完成</returns>
        public int curMissionState(Int32 completeFlag, int index)
        {
            return completeFlag & (1 << index);
        }

        //是否拥有此类型任务
        public bool IsHaveThisTypeMission(int _MisisonId)
        {
            Tab_MissionBase _MissionBase = TableManager.GetMissionBaseByID(_MisisonId, 0);
            if(_MissionBase == null)
            {
                return false;
            }
            MISSIONTYPE type = (MISSIONTYPE)_MissionBase.MissionType;

            //特殊处理(不主动下发需要手动接取的任务)
            if(type == MISSIONTYPE.MISSION_BRANCH)
            {
                if(_MisisonId == 753)
                    return false;
            }

            foreach (KeyValuePair<int, Games.Mission.CurOwnMission> oldPair in GameManager.gameManager.MissionManager.MissionList.m_aMission)
            {
                if (oldPair.Value != null)
                {
                    int missionId = oldPair.Value.m_nMissionID;
                    Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
                    if (missionBase == null)
                        continue;

                    if (missionBase.MissionType == (int)type)
                        return true;
                }

            }
            return false;
        }

        public int GetMissionInSecId()
        {
            foreach (KeyValuePair<int, Games.Mission.CurOwnMission> oldPair in GameManager.gameManager.MissionManager.MissionList.m_aMission)
            {
                if (oldPair.Value != null)
                {
                    int missionId = oldPair.Value.m_nMissionID;
                    Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
                    if (missionBase == null)
                        return -1;

                    if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC) //师门任务
                        return missionBase.Id;
                }
            }
            return -1;
        }

        //是否有一条龙任务在身
        public int isHaveOneDragon()
        {
            List<int> keys = new List<int>(GameManager.gameManager.MissionManager.MissionList.m_aMission.Keys);
            for(int i=0;i<keys.Count;i++)
            {
                Games.Mission.CurOwnMission oldPair = GameManager.gameManager.MissionManager.MissionList.m_aMission[keys[i]];
                int missionId = oldPair.m_nMissionID;
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
                if (missionBase == null)
                    continue;

                if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG && oldPair.m_yStatus == (int)Games.Mission.MissionState.Mission_Accepted) //一条龙任务
                    return missionBase.Id;
            }
            return -1;
        }

        public void GuildPaoShangeAutoMove()
        {
            if (GameManager.gameManager.AutoSearch != null)
                GameManager.gameManager.AutoSearch.RoadSignManager.RoadStateChange(Vector3.zero);
        }

        // 任务接取成功后 客户端处理
        public bool AddMissionToUser(int nMissionID, byte yQualityType)
        {
            Tab_MissionBase table = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (table == null)
                return false;

            if (IsHaveMission(nMissionID))
            {
                if(table.MissionType == (int)MISSIONTYPE.MISSION_INSEC)
                {
                    var missionDic = TableManager.GetMissionDictionaryByID(nMissionID, 0);
                    if(missionDic != null)
                        LogModule.ErrorLog("已经存在了任务 : " + nMissionID +  ", " + missionDic.MissionName);
                    MissionPathFinder(nMissionID);
                }
                return false;
            }

            if (false == AddMission(nMissionID, yQualityType))
            {
                return false;
            }

            //接取任务之后 打开任务面板
            if (MissionDialogAndLeftTabsLogic.Instance())
            {
                if((table.MissionType == (int)MISSIONTYPE.MISSION_MAIN
                    && !IsStopedMission(nMissionID))
                    || (table.MissionType != (int)MISSIONTYPE.MISSION_GUIDE && table.MissionType != (int)MISSIONTYPE.MISSION_BRANCH))
                    MissionDialogAndLeftTabsLogic.Instance().CurGoingMissionType = table.MissionType;

                if(table.MissionType == (int)MISSIONTYPE.MISSION_MAIN 
                    && IsStopedMission(nMissionID) && 
                    MissionDialogAndLeftTabsLogic.Instance().CurGoingMissionType == (int)MISSIONTYPE.MISSION_MAIN)
                {
                    MissionDialogAndLeftTabsLogic.Instance().CurGoingMissionType = -1;
                }
                MissionDialogAndLeftTabsLogic.Instance().ShowDefaultToggle();
            }

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(table.LogicID, 0);
            if (missionLogic == null)
                return false;

            // 通知客户端更新UI
            NotifyMissionUI(nMissionID, "add");
            // 通知日常任务界面
            //NotifyDailyMissionUI(nMissionID, "add");

            //师门任务
            if (table.MissionType == (int)MISSIONTYPE.MISSION_INSEC)
            {
                //打开任务对话窗口
                MissionInfoController.ShowMissionDialogUI(nMissionID, MissionInfoController.MissionUIType.TYPE_ACCETP);
                return true;
            }

            //宝图 若在副本中则记录任务ID
            if(table.MissionType == (int)MISSIONTYPE.MISSION_TREASURE)
            {
                //记录任务ID
                GameManager.gameManager.PlayerDataPool.AutoSearchMissionId = GameManager.gameManager.ActiveScene.IsCopyScene() ? nMissionID : -1;
            }

            //帮会货运任务直接打开界面 
            if (table.MissionType == (int)MISSIONTYPE.MISSION_GUILDTRANSPORT || nMissionID == Games.GlobeDefine.GlobeVar.TRANSPORT_MISSION)
            {
                GuildTransport.GuildTransportClick(table, Singleton<ObjManager>.Instance.MainPlayer.GUID);
            }

            if (table.MissionType == (int)MISSIONTYPE.MISSION_BRANCH
                || table.MissionType == (int)MISSIONTYPE.MISSION_DAILY
                || table.MissionType == (int)MISSIONTYPE.MISSION_GUIDE)
            {
                return true;
            }

            if (GuideLogic.Instance())
                GuideLogic.OnMissionAcceptStatic(nMissionID);
            else
            { 
                if(table.MissionType == (int)MISSIONTYPE.MISSION_CROSSSERVERPOST)
                {
                    return true;
                }
                MissionPathFinder(nMissionID);
            }

            if (table.MissionType == (int)MISSIONTYPE.MISSION_MAIN && GameManager.gameManager.RunningScene == 718)
            {
                GameManager.gameManager.PlayerDataPool.AutoSearchMissionId = nMissionID;
            }
            return true;
        }


        //任务完成事件
        public delegate void completeM(string name);
        public static event completeM m_completeMission;

        // 提交任务，给服务器发包
        public bool CompleteMission(int nMissionID)
        {

            Tab_MissionBase misLine = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (misLine == null)
                return false;

            // 2、检查玩家身上是否有任务
            if (false == IsHaveMission(nMissionID))
            {
                return false;
            }

            // 3、任务状态检查

            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (missionBase == null)
                return false;

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
            if (missionLogic == null)
                return false;

            //当前任务子任务个数
            int m_Count = GameManager.gameManager.MissionManager.getCurMissionTypeCount(nMissionID);

            //当前子任务进行的下标
            int m_Index = GameManager.gameManager.MissionManager.getCurMissionIndex(nMissionID);
            for(int index = 0; index < m_Count; index++)
            {
                if(missionLogic.GetLogicTypebyIndex(index) == (int)TableType.Table_MissionInTime)  //限时任务不能完成 不计算在子任务内
                {
                    m_Index++;
                    break;
                }
            }

            if (++m_Index != m_Count)  //最后一个完成的子任务的Index跟子任务数量对比
            {
                //对话提交任务
                return false;
            }

            bool isCommitItem = false;
            int m_LootItemId = -1;


            if (missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)) == (int)TableType.Table_LootItem) //提交物品
            {
                int logic_Id = missionLogic.GetLogicIDbyIndex(getCurMissionIndex(nMissionID));  //
                Tab_MissionLootItem m_LootItem = TableManager.GetMissionLootItemByID(logic_Id, 0);
                if (m_LootItem != null && (m_LootItem.SelectType == 1 || m_LootItem.SelectType == 2))  //需要主动提交物品
                {
                    isCommitItem = true;
                    m_LootItemId = missionLogic.GetLogicIDbyIndex(getCurMissionIndex(nMissionID));
                }
            }

            //帮会货运任务特殊处理
            if(missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDTRANSPORT &&(GuildTransport._addedNum >=5 && GuildTransport._addedNum<8))
            {
                MessageBoxLogic.OpenOKCancelBox(StrDictionary.GetClientDictionaryString("#{27031}"), null, delegate ()
                {
                    // 给服务器发包
                    CG_COMPLETEMISSION askMission = (CG_COMPLETEMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_COMPLETEMISSION);
                    askMission.SetMissionID(nMissionID);
                    askMission.SendPacket();
                });
                return true;
            }

            //需要提交物品  弹出选择框 列举需要的物品 点击提交
            if (isCommitItem)
            {
                //传递任务ID
                CommitItemInfoController.setMissionId(m_LootItemId, misLine.Id);
                //弹出选择窗口  在窗口内部进行初始化物品信息操作
                UIManager.ShowUI(UIInfo.CommitItemPanel);
            }
            else
            {
                // 给服务器发包
                CG_COMPLETEMISSION askMission = (CG_COMPLETEMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_COMPLETEMISSION);
                askMission.SetMissionID(nMissionID);
                askMission.SendPacket();
            }
            return true;
        }


        //关闭消息盒子
        public void CloseMessageBox()
        {
            UIManager.CloseUI(UIInfo.MessageBox);
        }

        // 任务提交成功后 客户端处理
        public bool CompleteMissionOver(int nMissionID)
        {
            // 要求取消任务完成Tips
            //GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{42517}"));
            //完成当前NPC任务后 根据下个NPCID找到对应的NPC，并刷新MissionBoard
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);

            // 客户端模拟包
            if (false == SetMissionHaveDone(nMissionID))
            {
                return false;
            }
            if (missionBase != null && !string.IsNullOrEmpty(missionBase.PreloadScene) &&
                missionBase.PreloadScene != "-1")
            {
                if (LoadAssetBundle.Instance != null)
                    LoadAssetBundle.Instance.StartPreloadScene(missionBase.PreloadScene, missionBase.PreloadMovie);
            }
            //是否需要添加指引任务
            AddGuidMissionToList();

            //探索区域用到的ID
            if (nMissionID == m_CurActionMissionId)
            {
                m_CurActionMissionId = -1;
            }

            var nextMissionID = -1;
            if(missionBase != null)
                nextMissionID = missionBase.NextMission;

            if (IsRingMission(nMissionID))
            {
                OptRingTurnsMission(nMissionID);

                if (false == DelMission(nMissionID))
                {
                    return false;
                }
                if (MissionDialogAndLeftTabsLogic.Instance())
                    MissionDialogAndLeftTabsLogic.Instance().CurGoingMissionType = -1;
                //删除任务之后需要再次刷新
                NotifyMissionUI(nMissionID, "complete");

                //完成任务  发送事件  判空操作 
                if (m_completeMission != null)
                {
                    m_completeMission("Complete Mission");
                }
                return true;
            }else
            {
                if (false == DelMission(nMissionID))
                {
                    return false;
                }

                // 通知客户端更新UI
                NotifyMissionUI(nMissionID, "complete");

                //完成任务  发送事件  判空操作 
                if (m_completeMission != null)
                {
                    m_completeMission("Complete Mission");
                }

                if (FunctionPreviewCtr.Instance)
                {
                    //这里面也处理了新手引导
                    FunctionPreviewCtr.Instance.OnMissionComplteOver(nMissionID, nextMissionID);
                }else
                {
                    //新手指引-处理弹出下一步任务
                    if (nextMissionID >= 0)  //0为初始任务
                    {
                        Tab_MissionNext missionNext = TableManager.GetMissionNextByID(nextMissionID, 0);
                        if (missionNext != null)
                        {
                            nextMissionID = missionNext.GetMissionIDbyIndex(0);
                            if (GuideLogic.Instance())
                                GuideLogic.OnMissionComplateStatic(nMissionID, missionNext.GetMissionIDbyIndex(0));
                            else
                                MissionPathFinder(nextMissionID);
                        }
                    }
                }
            }
            //循环任务
            if (missionBase != null && missionBase.MissionType == (int)MISSIONTYPE.MISSION_CIRCLE)
            {
                var missionRoundIdx = GameManager.gameManager.MissionManager.GteMissionTurnCount(nMissionID);
                Module.Log.LogModule.DebugLog("Circle Mission Round:" + missionRoundIdx);
            }

            return true;
        }
        
        public bool IsRingMission(int missionId)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if(missionBase == null)
            {
                return false;
            }

            Tab_MissionNext missionNext = TableManager.GetMissionNextByID(missionBase.NextMission, 0);
            if (missionNext == null)
            {
                return false;
            }

            Tab_MissionBase nextMissionBase = TableManager.GetMissionBaseByID(missionNext.GetMissionIDbyIndex(0), 0);
            if(nextMissionBase == null)
            {
                return false;
            }

            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(nextMissionBase.LimitID, 0);  //判断入口ID
            if (missionLimit == null)
            {
                return false;
            }

            if (missionLimit.CanCompleteTurns != -1)
            {
                return true;
            }

            return false;
        }

        //环任务处理
        public void OptRingTurnsMission(int nMissionID)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if(missionBase == null)
            {
                return; 
            }

            Tab_MissionNext missionNext = TableManager.GetMissionNextByID(missionBase.NextMission, 0);
            if(missionNext == null)
            {
                return;
            }

            var nextMissionBase = TableManager.GetMissionBaseByID(missionNext.GetMissionIDbyIndex(0), 0);

            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(nextMissionBase.LimitID, 0);
            if(missionLimit == null)
            {
                return;
            }

            //通过活动次数判断是否完成
            if(IsRingMissionCompleted(missionBase.NextMission))
            {
                return;
            }
            else
            {
                if (!IsCompleteOneTurnMission(nMissionID))  //不满一轮次数
                {
                    AcceptMission(missionNext.GetMissionIDbyIndex(0), AcceptMissionType.MISSIONNEXT);
                }
                else
                {
                    //提醒是否继续前往接取任务
                    //副本中 不显示
                    if (GameManager.gameManager.ActiveScene.IsCopyScene())
                    {
                        GameManager.gameManager.PlayerDataPool.AutoShowTurnOverEnsureMissionId = missionNext.GetMissionIDbyIndex(0);
                    }
                    else
                    {
                        if (missionBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC)
                        {
                            //师门需要区分一下接取任务的NPC
                            if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession == (int)CharacterDefine.PROFESSION.TIANJI
                                || GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession == (int)CharacterDefine.PROFESSION.LIUSHAN)
                            {
                                OpenEnsureBoxAndAcceptMission(GlobeVar.MISSIONINSECTIONENTER1);
                            }
                            else if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession == (int)CharacterDefine.PROFESSION.SHUSHAN
                                || GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession == (int)CharacterDefine.PROFESSION.XUANNV)
                            {
                                OpenEnsureBoxAndAcceptMission(GlobeVar.MISSIONINSECTIONENTER2);
                            }
                        }
                        else
                        {
                            OpenEnsureBoxAndAcceptMission(missionNext.GetMissionIDbyIndex(0));
                        }
                    }
                }
            }
        }

        private bool IsRingMissionCompleted(int _NextMissionId, bool isShowTips = true)
        {
            var missionNext = TableManager.GetMissionNextByID(_NextMissionId, 0);
            if(missionNext == null)
            {
                return false;
            }
            var nextMissionBase = TableManager.GetMissionBaseByID(missionNext.GetMissionIDbyIndex(0), 0);
            if(nextMissionBase ==   null)
            {
                return false;
            }
            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(nextMissionBase.LimitID, 0);
            if (missionLimit == null)
            {
                return false;
            }

            if (GetRingMissionCompletedCount(nextMissionBase.Id) >= missionLimit.OneTurnCount * missionLimit.CanCompleteTurns)
            {
                Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(missionNext.GetMissionIDbyIndex(0), 0);
                if (missionDic != null && isShowTips)
                {
                    //完成任务提示
                    MessageBoxLogic.OpenOKCancelBox(StrDictionary.GetClientDictionaryString("#{42513}", missionDic.MissionName), "", delegate ()
                    {
                        UIManager.CloseUI(UIInfo.MessageBox);
                        UIManager.ShowUI(UIInfo.Activity);
                    }, delegate ()
                    {
                        UIManager.CloseUI(UIInfo.MessageBox);
                    });
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetRingMissionCompletedCount(int missionId)
        {
            int _HasCompletedCount = 0;
            switch(missionId)
            {
                case GlobeVar.MISSIONINSECTIONSTANDARDENTERID:
                    {
                        _HasCompletedCount = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_MISSIONINSECTION);
                    }
                    break;
                case GlobeVar.TREASUREMISSIONENTERID:
                    {
                        _HasCompletedCount = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_TREASURE_TASK);
                    }
                    break;
                case GlobeVar.ONEDRAGONENTERID:
                    {
                        _HasCompletedCount = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_ONEDRAGON);
                    }
                    break;
                case GlobeVar.RINGMISSIONENTERID:
                    {
                        _HasCompletedCount = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_RINGMISSION);
                    }
                    break;
                case GlobeVar.WEEKRINGMISSIONENTERID:
                    {
                        _HasCompletedCount = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_WEEKRINGMISSION);
                    }
                    break;
            }
            return _HasCompletedCount < 0 ? 0 : _HasCompletedCount;
        }

        public void OpenEnsureBoxAndAcceptMission(int nextMissionId)
        {
            Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(nextMissionId, 0);
            if(missionDic == null)
            {
                return;
            }
            MessageBoxLogic.OpenOKCancelBox(StrDictionary.GetClientDictionaryString("#{42514}", missionDic.MissionName), "", delegate() {
                if(GameManager.gameManager.ActiveScene.IsCopyScene())
                {
                    GameManager.gameManager.PlayerDataPool.AutoSearchMissionId = nextMissionId;
                }
                else
                {
                    MissionPathFinder(nextMissionId);
                }
                UIManager.CloseUI(UIInfo.MessageBox);
            }, delegate() {
                UIManager.CloseUI(UIInfo.MessageBox);
            });
        }

        //获取任务是第几轮
        public int GetMissionTruns(int missionId)  
        {
            int param = GameManager.gameManager.MissionManager.GteMissionTurnCount(missionId);
            return param & 0XFF;
        }

        public bool IsCompleteOneTurnMission(int missionId)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if (missionBase == null)
            {
                return true;
            }

            Tab_MissionNext missionNext = TableManager.GetMissionNextByID(missionBase.NextMission, 0);
            if(missionNext == null)
            {
                return false;
            }

            Tab_MissionBase nextMissionBase = TableManager.GetMissionBaseByID(missionNext.GetMissionIDbyIndex(0), 0);
            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(nextMissionBase.LimitID, 0);
            if (MissionList == null)
            {
                return true;
            }

            return GetMissionTurnsCount(missionId) % missionLimit.OneTurnCount == 0 ? true : false;
        }

        //获取任务当前轮里面第几次
        public int GetMissionTurnsCount(int missionId)
        {
            int param = GameManager.gameManager.MissionManager.GteMissionTurnCount(missionId);
            return (param & 0XFF00) >> 8;
        }

        // 放弃任务
        public bool AbandonMission(int nMissionID)
        {
            // 检查玩家身上是否有任务
            if (false == IsHaveMission(nMissionID))
            {
                return false;
            }
            if (nMissionID == m_CurActionMissionId)
                m_CurActionMissionId = -1;  //重置

            // 给服务器发包
            CG_ABANDONMISSION askMission = (CG_ABANDONMISSION)PacketDistributed.CreatePacket(MessageID.PACKET_CG_ABANDONMISSION);
            askMission.SetMissionID(nMissionID);
            askMission.SendPacket();

            return true;
        }

        public bool AbandonMissionOver(int nMissionID)
        {
            // 直接删除任务
            bool bRet = DelMission(nMissionID);//删除任务
            if (!bRet)
            {
                return false;
            }

            // 通知客户端更新UI
            NotifyMissionUI(nMissionID, "Del");
            Games.Events.EventDispatcher.Instance.Dispatch(Events.EventId.DelMission, nMissionID);
            return true;
        }

        public bool IsHaveMissionNotFailedByType(int type)
        {
            foreach (var m_Mission in GameManager.gameManager.MissionManager.MissionList.m_aMission)
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(m_Mission.Value.m_nMissionID, 0);
                if (missionBase != null)
                {
                    if(missionBase.MissionType == type && MissionState.Mission_Failed != (MissionState)GetMissionState(m_Mission.Value.m_nMissionID))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public CurOwnMission GetMissionByType(MISSIONTYPE type)
        {
            List<int> keys = new List<int>(m_MissionList.m_aMission.Keys);
            for(int i=0;i<keys.Count;i++)
            {
                CurOwnMission mission = m_MissionList.m_aMission[keys[i]];
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(mission.m_nMissionID, 0);
                if (missionBase != null && missionBase.MissionType == (int)type)
                {
                    return mission;
                }
            }
            return null;
        }

        public bool IsHaveMission(int nMissionID)
        {
            if (nMissionID < 0)
            {
                return false;
            }

            if (m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                if (missionBase != null)
                {
                    if (m_MissionList.m_aMission[nMissionID].m_yStatus == (int)MissionState.Mission_NotAccept
                        && missionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN)
                        return false;
                    return true;
                }
            }   
            return false;
        }
        public bool SetMissionState(int nMissionID, byte nStatus)
        {
            bool isIgNore = false;
            if (MissionList.m_aMission.ContainsKey(nMissionID))
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                if (missionBase != null && missionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN)
                {
                    if (MissionList.m_aMission[nMissionID].m_yStatus == (int)MissionState.Mission_NotAccept)
                    {
                        if (nStatus == (int)MissionState.Mission_Accepted)
                        {
                            MissionList.m_aMission[nMissionID].m_yStatus = nStatus;
                            isIgNore = true;
                        }
                    }
                }
            }

            if (false == IsHaveMission(nMissionID))
            {
                return false;
            }
            if (nStatus == GetMissionState(nMissionID) && !isIgNore)
            {
                return false;
            }
            m_MissionList.m_aMission[nMissionID].SetStatus(nStatus);

            Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (MissionBase == null)
                return false;

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(MissionBase.LogicID, 0);
            if (missionLogic == null)
                return false;

            int m_Count = missionLogic.getLogicTypeCount();
            int m_LogicType = -1;
            int m_CurIndex = getCurMissionIndex(nMissionID);
            m_LogicType = missionLogic.GetLogicTypebyIndex(m_CurIndex);
            if (nStatus == (byte)MissionState.Mission_Completed
                && m_LogicType != (int)TableType.Table_Delivery)  //送信任务要判断是不是引导任务
            {
                Singleton<ObjManager>.GetInstance().MainPlayer.LeveAutoCombat();
                if (SysShopController.Instance() && SysShopController.Instance().gameObject.activeInHierarchy)
                {
                    UIManager.CloseUI(UIInfo.SysShop);
                }
                //若当前处于副本中，则记录任务ID在切换场景之后自动寻路 
                if (GameManager.gameManager.ActiveScene.IsCopyScene() && 
                    MissionBase.MissionType != (int)MISSIONTYPE.MISSION_TREASURE && MissionBase.MissionType != (int)MISSIONTYPE.MISSION_ONEDRONG
                    && GameManager.gameManager.RunningScene != 718)  //新手剧情副本不记录
                {
                    GameManager.gameManager.PlayerDataPool.AutoSearchMissionId = nMissionID;
                } else
                {
                    //判断当前任务是否需要寻找NPC提交
                    Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(nMissionID, 0);
                    if (missionDic == null)
                        return false;

                    if (missionDic.CompleteNpcDataID == -1) //不需要寻找NPC提交任务 直接隔空对话接受下一个任务
                    {
                        CompleteMission(nMissionID);
                        return true;
                    }
                    else
                    {
                        if (missionDic.CompleteNpcDataID > 0)
                        {
                            if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR)
                            {
                                if ((MissionState)GameManager.gameManager.MissionManager.GetMissionState(nMissionID) == MissionState.Mission_Completed)
                                {
                                    GameManager.gameManager.MissionManager.MissionPathFinder(nMissionID, GameManager.gameManager.PlayerDataPool.GuildInfo.GuildGuid);
                                }
                            }
                            else
                            {
                                if (GameManager.gameManager.ActiveScene.IsCopyScene() == false)
                                    MissionPathFinder(nMissionID);
                            }
                        }
                    }
                }
            }

            if (/*nMissionID != 0 && */nStatus == (byte)MissionState.Mission_Accepted)
            {
                //判断当前任务是否需要寻找NPC提交
                Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(nMissionID, 0);
                if (missionDic == null)
                    return false;

                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                if (MissionBase == null)
                {
                    return false;
                }

                if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_TREASURE)
                {
                    if (GameManager.gameManager.ActiveScene.IsCopyScene())
                    {
                        GameManager.gameManager.PlayerDataPool.AutoSearchMissionId = nMissionID;
                    }
                    else
                    {
                        MissionPathFinder(nMissionID);
                    }
                }
                else if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_CROSSSERVERPOST)
                {
                    UIManager.CloseUI(UIInfo.CrossServerPost);
                }
                else if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDDRAGONWAR)
                {
                    if (GameManager.gameManager.PlayerDataPool.DragonWar_destanceGuildGuid != Games.GlobeDefine.GlobeVar.INVALID_GUID)
                    {
                        GameManager.gameManager.MissionManager.MissionPathFinder(nMissionID, GameManager.gameManager.PlayerDataPool.DragonWar_destanceGuildGuid);
                    }
                }
                else if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC)
                {
                    if (missionDic.MissionDesc == null) //没有任务对话的时候自动寻路 有的话则在点击完对话后进行自动寻路
                    {
                        MissionPathFinder(nMissionID);
                    }
                }
                else if(MissionBase.MissionType == (int)MISSIONTYPE.MISSION_ONEDRONG)
                {
                    if(GameManager.gameManager.PlayerDataPool.TeamInfo.IsCaptain() /*&& GameManager.gameManager.ActiveScene.IsCopyScene() == false*/)
                    {
                        MissionPathFinder(nMissionID);
                    }
                }
                else if(MissionBase.MissionType == (int)MISSIONTYPE.MISSION_GUILDPAOSHANG)
                {
                    GuildPaoShangeAutoMove();
                }
                else
                {
                    if(missionBase.MissionType != (int)MISSIONTYPE.MISSION_BRANCH
                        && missionBase.MissionType != (int)MISSIONTYPE.MISSION_DAILY
                        && missionBase.MissionType != (int)MISSIONTYPE.MISSION_GUIDE
                        && missionBase.MissionType != (int)MISSIONTYPE.MISSION_CROSSSERVERKILLMONSTER)
                    {
                        if (GameManager.gameManager.ActiveScene.IsCopyScene() == false
                            /*&& !(nMissionID == 0 && nStatus == (byte)MissionState.Mission_Accepted)*/) //任务0接取状态不寻路
                            MissionPathFinder(nMissionID);
                    }
                 
                }
            }

            // 通知UI更新
            NotifyMissionUI(nMissionID, "state");

            Singleton<CollectItem>.Instance.InitMissionCollectItem();

            SceneMovieManager.Instance.MissionStateChange(nMissionID, nStatus);

            if(MissionBase.MissionType != (int)MISSIONTYPE.MISSION_BRANCH
                && MissionBase.MissionType != (int)MISSIONTYPE.MISSION_DAILY
                && MissionBase.MissionType != (int)MISSIONTYPE.MISSION_CROSSSERVERKILLMONSTER)
            {
                if (GuideLogic.Instance())
                {
                    if (GuideLogic._isShowCompleteMissionGuide)
                    {
                        GuideLogic.Instance().NextMissionID = nMissionID;
                        GuideLogic._isSyncMisisonStateWhenShowCompleteMissionGuide = true;
                    }
                    else
                        GuideLogic.Instance().OnMissionState(nMissionID);
                }
                else
                {
                    MissionPathFinder(nMissionID);
                }
            }
         
            GameManager.gameManager.mSceneObjManager.OnMissionStateChange(nMissionID);

            if(CrossServerCopyInfoCtr.Instance && CrossServerCopyInfoCtr.Instance._MissionId == nMissionID)
            {
                CrossServerCopyInfoCtr.Instance.RefreshMissionState();
            }
            return true;
        }

        //调用这个函数 那么直接是特殊任务的描述
        public bool IsStopedMission(int missionId)
        {
            if (missionId == 0)  //主线任务0自动下发 不用判断
            {
                return false;
            }

           var isNeedIncLevel = false;
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionId, 0);
            if (missionBase != null)
            {
                if (missionBase.MissionType != (int)MISSIONTYPE.MISSION_MAIN)
                {
                    return false;
                }
            }
            //卡级任务必须是主线任务 用于进行特殊的任务描述(只用判断等级) 和前续任务？
            Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(missionBase.LimitID, 0);
            if (missionLimit != null)
            {
                int m_PlayerLevel = GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level;
                if (m_PlayerLevel >= missionLimit.LowLevel)
                {
                    isNeedIncLevel = false;
                    return isNeedIncLevel;
                }
                else
                {
                    isNeedIncLevel = true;
                }
            }
            return isNeedIncLevel;

        }

        public byte GetMissionState(int nMissionID)
        {
            if (m_MissionList.m_aMission.ContainsKey(nMissionID))
            {
                return m_MissionList.m_aMission[nMissionID].m_yStatus;
            }else
            {
                return 0;
            }
        }

        public byte GetMissionQuality(int nMissionID)
        {
            if (true == IsHaveMission(nMissionID))
            {
                return m_MissionList.m_aMission[nMissionID].m_yQuality;
            }
            return (byte)MISSION_QUALITY.MISSION_QUALITY_NONE;
        }

        // 任务更新UI
        public void NotifyMissionUI(int nMissionID, string strOpt)
        {
            if (null != MissionDialogAndLeftTabsLogic.Instance())
            {
                MissionDialogAndLeftTabsLogic.Instance().UpDateMissionFollow(nMissionID, strOpt);
            }
        }

        public bool IsClientMission(int nMissionID)
        {
            Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (MissionBase == null)
            {
                return false;
            }

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(MissionBase.LogicID, 0);
            if (missionLogic == null)
                return false;

            int nType = missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID));
            if (nType == -1)
            {
                return false;
            }
            if (nType == (int)TableType.Table_Story || nType == (int)TableType.Table_CollectItem)
            {
                return true;
            }

            return false;
        }

        // 剧情任务 在客户端完成
        public bool SetStoryMissionState(int nMissionID, byte byState)
        {
            Tab_MissionBase misLine = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (misLine == null)
            {
                return false;
            }

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(misLine.LogicID, 0);
            if (missionLogic == null)
                return false;

            if (TableType.Table_Story == (TableType)missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)))
            {
                SetMissionParam(nMissionID, 0, 1);
                return SetMissionState(nMissionID, (byte)byState);
            }

            return false;
        }

        // 获取玩家身上的任务
        public List<int> GetAllMissionID()
        {
            List<int> nMissionIDList = new List<int>();
            List<int> _GuidMissionList = new List<int>();

            foreach (var kvp in m_MissionList.m_aMission)
            {
                if (kvp.Key < 0)
                    continue;
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(kvp.Key, 0);
                if (missionBase != null && missionBase.MissionType == (int)MISSIONTYPE.MISSION_GUIDE)
                {
                    _GuidMissionList.Add(kvp.Key);
                }
            }

            for(int index = 0; index < _GuidMissionList.Count; index++)
            {
                if(m_MissionList.m_aMission.ContainsKey(_GuidMissionList[index]))
                {
                    m_MissionList.m_aMission.Remove(_GuidMissionList[index]);
                }
            }

            AddGuidMissionToList();
            List<KeyValuePair<int, CurOwnMission>> _MissionDicList = new List<KeyValuePair<int, CurOwnMission>>(m_MissionList.m_aMission);
            _MissionDicList.Sort(delegate(KeyValuePair<int, CurOwnMission> missionA, KeyValuePair<int, CurOwnMission> missionB) {
                Tab_MissionBase missionBaseA = TableManager.GetMissionBaseByID(missionA.Key, 0);
                Tab_MissionBase missionBaseB = TableManager.GetMissionBaseByID(missionB.Key, 0);

                int _MissionTypeA = missionBaseA.MissionType;
                int _MissionTypeB = missionBaseB.MissionType;

                if(_MissionTypeA == _MissionTypeB)
                {
                    return missionBaseA.Id < missionBaseB.Id ? -1 : 1;
                }else
                {
                    return GetMissionSortLevel(_MissionTypeA) < GetMissionSortLevel(_MissionTypeB) ? -1 : 1;
                }
            });

            var mainMisisonId = -1;
            foreach(var mission in _MissionDicList)
            {
                var missionBase = TableManager.GetMissionBaseByID(mission.Key, 0);
                if (missionBase == null)
                    continue;
                if(missionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN && GameManager.gameManager.MissionManager.IsStopedMission(mission.Key))
                {
                    mainMisisonId = mission.Key;
                    continue;
                }
                nMissionIDList.Add(mission.Key);
            }
            //不能进行的主线任务插在第二位
            if(mainMisisonId != -1)
            {
                if (nMissionIDList.Count > 0)
                {
                    nMissionIDList.Insert(1, mainMisisonId);
                }
                else
                {
                    nMissionIDList.Insert(0, mainMisisonId);
                }
                mainMisisonId = -1;
            }

            return nMissionIDList;
        }

        public int GetMissionSortLevel(int _MissonType)
        {
            Tab_MissionSortBase missionSortBase = TableManager.GetMissionSortBaseByID(_MissonType, 0);
            if (missionSortBase == null)
            {
                return 99;
            }
            return missionSortBase.Level;
        }

        public bool IsGuidMissionCpmpleted(int _GuidMissionId)
        {
            Tab_MissionGuidBase guidBase = TableManager.GetMissionGuidBaseByID(_GuidMissionId, 0);
            if(guidBase == null)
            {
                return false;
            }

            int times = ActivityDataManager.Instance.GetActivityCompleteTimes(guidBase.ActivityType);
            if (times < 0)
                return false;
            //主线副本限制次数要通过副本表进行累加计算
            if(guidBase.GuidMissionType == 1)
            {

                return times >= GetMainMissionCopyRemainTimes();

            }
            else
            {
                return times >= guidBase.LimitTimes;
            }
        }

        public int GetMainMissionCopyRemainTimes()
        {
            int _ChallengeTimes = 0;
            var copyBaseDic = TableManager.GetNewCopyBase().Values;
            foreach (var info in copyBaseDic)
            {
                if (info.Type == 2 && GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level >= info.UnLockLevel)
                {
                    Tab_Fuben funben = TableManager.GetFubenByID(info.GetId(), 0);
                    {
                        _ChallengeTimes += funben.ChallengeTimes;
                    }
                }
            }
            return _ChallengeTimes;
        }

        public Dictionary<MISSIONTYPE, List<int>> GetClassifyMission()
        {
            Dictionary<MISSIONTYPE, List<int>> missionDict = new Dictionary<MISSIONTYPE, List<int>>();

            // 遍历玩家任务列表
            foreach (KeyValuePair<int, CurOwnMission> kvp in m_MissionList.m_aMission)
            {
                if (kvp.Key < 0)
                    continue;

                Tab_MissionBase misBase = TableManager.GetMissionBaseByID(kvp.Key, 0);
                var missionType = (MISSIONTYPE)misBase.MissionType;
                if (missionDict.ContainsKey(missionType))
                {
                    missionDict[missionType].Add(kvp.Key);
                }
                else
                {
                    List<int> missionIDs = new List<int>();
                    missionIDs.Add(kvp.Key);
                    missionDict.Add(missionType, missionIDs);
                }
            }
            return missionDict;
        }

        // 获取玩家身上的非日常任务
        public List<int> GetAllNotDailyMissionList()
        {
            List<int> nMissionIDList = new List<int>();

            // 遍历玩家任务列表
            foreach (KeyValuePair<int, CurOwnMission> kvp in m_MissionList.m_aMission)
            {
                if (kvp.Key < 0)
                    continue;

                Tab_MissionBase misBase = TableManager.GetMissionBaseByID(kvp.Key, 0);
                if (null == misBase || misBase.MissionType == (int)MISSIONTYPE.MISSION_DAILY || misBase.MissionType == (int)MISSIONTYPE.MISSION_INSEC)  //师门也作为日常任务
                {
                    continue;
                }

                nMissionIDList.Add(kvp.Key);
            }
            return nMissionIDList;
        }


        // 遍历场景中前nNum个可接任务（按等级先大后小） 任务日志用
        public List<int> GetCanAcceptedMissionID(int nNum)
        {
            List<int> nMissionIDList = new List<int>();

            // 遍历表格 查任务
            var AllNpc = TableManager.GetSceneNpc().Values;
            foreach (var NpcTable in AllNpc)
            {
                Tab_RoleBaseAttr npcRoleBase = TableManager.GetRoleBaseAttrByID(NpcTable.DataID, 0);
                if (null == npcRoleBase || npcRoleBase.DialogID < 0)
                {
                    continue;
                }

                Tab_NpcDialog npcDialog = TableManager.GetNpcDialogByID(npcRoleBase.DialogID, 0);
                if (null == npcDialog)
                {
                    continue;
                }
                for (int index = 0; index < npcDialog.getMissionIDCount(); index++)
                {
                    int nMissionID = npcDialog.GetMissionIDbyIndex(index);
                    if (nMissionID < 0)
                    {
                        continue;
                    }

                    if(nMissionID == GlobeVar.MISSIONINSECTIONSTANDARDENTERID)
                    {
                        continue;
                    }

                    Tab_MissionBase misBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                    if (null == misBase)
                    {
                        continue;
                    }

                    //师门要添加一个门派限制
                    if (nMissionID == GlobeVar.MISSIONINSECTIONENTER1 || nMissionID == GlobeVar.MISSIONINSECTIONENTER2)
                    {
                        if (IsMissionCompleted((int)ActivityDataManager.Activity_Type.ACTIVITY_MISSIONINSECTION))  //当天师门已经全部完成
                        {
                            continue;
                        }

                        Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(misBase.LimitID, 0);
                        if(missionLimit != null)
                        {
                            if (((1 << GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession) & missionLimit.ClassNeed) == 0)
                            {
                                continue;
                            }
                        }
                    }

                    if(nMissionID == GlobeVar.RINGMISSIONENTERID)
                    {
                        if (IsMissionCompleted((int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_RINGMISSION))  //当天师门已经全部完成
                        {
                            continue;
                        }
                    }

                    if (false == CanAcceptMission(nMissionID)
                        || misBase.AcceptDataID != NpcTable.DataID)
                    {
                        continue;
                    }

                    if(nMissionIDList.Count < nNum)
                    {
                        AddMissionIDByLevel(nMissionIDList, nMissionID);
                    }

                }
            }

            return nMissionIDList;
        }

        public Dictionary<MISSIONTYPE, List<int>> GetClassifyCanAcceptMission()
        {
            Dictionary<MISSIONTYPE, List<int>> missionDict = new Dictionary<MISSIONTYPE, List<int>>();

            // 遍历玩家任务列表
            foreach (int missionID in GetCanAcceptedMissionID(99))
            {
                if (missionID < 0)
                    continue;

                Tab_MissionBase misBase = TableManager.GetMissionBaseByID(missionID, 0);
                var missionType = (MISSIONTYPE)misBase.MissionType;
                if (missionDict.ContainsKey(missionType))
                {
                    missionDict[missionType].Add(missionID);
                }
                else
                {
                    List<int> missionIDs = new List<int>();
                    missionIDs.Add(missionID);
                    missionDict.Add(missionType, missionIDs);
                }
            }

            _CanAcceptMissionDic = missionDict;
            return missionDict;
        }

        // 按任务限制等级排序 任务日志用
        bool AddMissionIDByLevel(List<int> MissionList, int nMissionID)
        {
            if (MissionList.Count < 0)
            {
                return false;
            }

            if (MissionList.Contains(nMissionID))
                return false;

            bool bFlag = false;
            for (int i = 0; i < MissionList.Count; i++)
            {
                Tab_MissionBase misBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                Tab_MissionLimit TempMisLimit = TableManager.GetMissionLimitByID(misBase.LimitID, 0);
                if (TempMisLimit == null)
                {
                    return false;
                }

                Tab_MissionBase misBaseI = TableManager.GetMissionBaseByID(MissionList[i], 0);
                Tab_MissionLimit MisLimit = TableManager.GetMissionLimitByID(misBaseI.LimitID, 0);
                if (MisLimit == null)
                {
                    // 异常 怎么处理？
                    continue;
                }

                if (TempMisLimit.LowLevel > MisLimit.LowLevel)
                {
                    bFlag = true;
                    MissionList.Insert(i, nMissionID);
                    break;
                }
            }

            if (bFlag == false)
            {
                MissionList.Add(nMissionID);
            }

            return true;
        }

        public bool MissionNearbyPathFinder(int missionId)
        {
            var missionDic = TableManager.GetMissionDictionaryByID(missionId, 0);
            var missionIndex = getCurMissionIndex(missionId);
            var missionState = GetMissionState(missionId);

            var desPos = new Vector2(0, 0);

            if (missionState == (int)MissionState.Mission_Completed)
            {
                var targetSceneId = missionDic.CompleteNpcSceneID;
                if (GameManager.gameManager.RunningScene != targetSceneId)
                    return false;

                desPos = new Vector2(missionDic.CompleteNpcPosX, missionDic.CompleteNpcPosZ);
            }else if(missionState == (int)MissionState.Mission_NotAccept)
            {
                var targetSceneId = missionDic.AccepteNpcSceneID;
                if (GameManager.gameManager.RunningScene != targetSceneId)
                    return false;

                desPos = new Vector2(missionDic.AccepteNpcPosX, missionDic.AccepteNpcPosZ);
            }
            else
            {
                //同一个场景，就判断是否在当前的位置附近，是的话就走Agent
                var targetSceneId = missionDic.GetTargetNpcSceneIDbyIndex(missionIndex);
                if (GameManager.gameManager.RunningScene != targetSceneId)
                    return false;

                desPos = new Vector2(missionDic.GetTargetNpcPosXbyIndex(missionIndex), missionDic.GetTargetNpcPosZbyIndex(missionIndex));
            }

            var mainPlayerPos = ObjManager.Instance.MainPlayer.transform.position;
            var destDistance = 2.0f;
            if ((desPos - mainPlayerPos.RemoveY()).sqrMagnitude < destDistance.ToSquare())
            {
                var roleBaseAttr = TableManager.GetRoleBaseAttrByID(missionDic.AcceptNpcDataID, 0);
                if (roleBaseAttr != null)
                {
                    var obj = ObjManager.Instance.FindObjCharacterInSceneByName(roleBaseAttr.Name);
                    ObjManager.Instance.MainPlayer.SetClientTargetByClick(obj);
                    return true;
                }
            }
            return false;
        }

        private Dictionary<int, Vector3> _MissionFlyPos = new Dictionary<int, Vector3>();
        public static float _MissionFlyDis = 1.5f;
        public static Vector3 GetMissionFlyPos(int npcDataID)
        {
            //if (_MissionFlyPos.ContainsKey(npcDataID))
            //    return _MissionFlyPos[npcDataID];

            var sceneNpcTabs = TableManager.GetSceneNpc();
            foreach (var sceneNPC in sceneNpcTabs)
            {
                if (sceneNPC.Value.DataID == npcDataID)
                {
                    var npcPos = new Vector3(sceneNPC.Value.PosX, 0, sceneNPC.Value.PosZ);
                    npcPos += new Vector3(Mathf.Cos(sceneNPC.Value.FaceDirection) * _MissionFlyDis, 0, Mathf.Sin(sceneNPC.Value.FaceDirection) * _MissionFlyDis);
                    //_MissionFlyPos.Add(npcDataID, npcPos);
                    return npcPos;
                }
            }
            return Vector3.zero;
        }

        // 任务追踪、任务日志寻路
        public bool MissionPathFinder(int nMissionID, ulong guildGuid = Games.GlobeDefine.GlobeVar.INVALID_GUID, bool isFly = false)
        {
            if (FirstShowScene.Instance() != null && FirstShowScene.CanFindMissionPath())
                return false;
            if (nMissionID < 0)
            {
                return false;
            }

            //if (MissionNearbyPathFinder(nMissionID))
            //    return false;

            Tab_MissionDictionary MDLine = TableManager.GetMissionDictionaryByID(nMissionID, 0);
            if (MDLine == null)
            {
                return false;
            }

            
            if (MDLine.IsAcceptAutoFindPath) //自动寻路
            {
                //接受任务后自动寻路
                Vector3 targetPos = new Vector3();
                int nTargetScene = -1;
                int nTargetNpcDataID = -1;
                // 任务是否完成
                MissionState misState = (MissionState)GetMissionState(nMissionID);
                if (MissionState.Mission_None == misState
                    || MissionState.Mission_Failed == misState)
                {
                    if (Faild_OpenMissionWindow(nMissionID))
                    {
                        return false;
                    }

                    nTargetScene = MDLine.AccepteNpcSceneID;
                    targetPos.x = MDLine.AccepteNpcPosX;
                    targetPos.z = MDLine.AccepteNpcPosZ;
                    nTargetNpcDataID = MDLine.AcceptNpcDataID;
                }
                else if (MissionState.Mission_Accepted == misState)
                {
                    int index = getCurMissionIndex(nMissionID);
                    nTargetScene = MDLine.GetTargetNpcSceneIDbyIndex(index);
                    targetPos.x = MDLine.GetTargetNpcPosXbyIndex(index);
                    targetPos.z = MDLine.GetTargetNpcPosZbyIndex(index);
                    nTargetNpcDataID = MDLine.GetTargetNpcDataIDbyIndex(index);
                }
                else if (MissionState.Mission_Completed == misState)
                {
                    nTargetScene = MDLine.CompleteNpcSceneID;
                    targetPos.x = MDLine.CompleteNpcPosX;
                    targetPos.z = MDLine.CompleteNpcPosZ;
                    nTargetNpcDataID = MDLine.CompleteNpcDataID;
                }
                else if(MissionState.Mission_NotAccept == misState)
                {
                    nTargetScene = MDLine.AccepteNpcSceneID;
                    targetPos.x = MDLine.AccepteNpcPosX;
                    targetPos.z = MDLine.AccepteNpcPosZ;
                    nTargetNpcDataID = MDLine.AcceptNpcDataID;
                }

                if (nTargetScene < 0)
                    return false;

                if (null != Singleton<ObjManager>.GetInstance()
                    && null != Singleton<ObjManager>.GetInstance().MainPlayer)
                {
                    Singleton<ObjManager>.GetInstance().MainPlayer.BreakAutoCombatState();

                    TableType missionType = TableType.Table_Invalid;
                    int missionState = -1;
                    Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
                    if (missionBase != null)
                    {
                        Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
                        if (missionLogic != null)
                        {
                            missionType = (TableType)missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID));
                        }
                        missionState = GetMissionState(nMissionID);
                    }

                    // 自动寻路
                    AutoSearchPoint point = new AutoSearchPoint(nTargetScene, targetPos.x, targetPos.z, -1, AutoSearchPoint.ChangeMap_Type.WORLDMAP, guildGuid);
                    if (isFly)
                    {
                        var pointPos = GetMissionFlyPos(nTargetNpcDataID);
                        point.ChangeMapType = AutoSearchPoint.ChangeMap_Type.MISSIONFLY;
                        if (pointPos != Vector3.zero)
                        {
                            point.PosX = pointPos.x;
                            point.PosZ = pointPos.z;
                        }
                    }
                    if (GameManager.gameManager && GameManager.gameManager.AutoSearch)
                    {
                        Tab_RoleBaseAttr RoleBase = TableManager.GetRoleBaseAttrByID(nTargetNpcDataID, 0);
                        if (null != RoleBase && null != GameManager.gameManager.AutoSearch.Path)
                        {
                            //当前子任务是采集任务，任务状态未完成，则设置目标名字为空，这样在寻路到终点时候不会弹出npc头像框
                            if (missionType == TableType.Table_CollectItem 
                                && missionState != (int)MissionState.Mission_Completed
                                && missionState != (int)MissionState.Mission_NotAccept //采集任务处于未接取状态的时候，这边会将目标名字置空
                                && missionState != (int)MissionState.Mission_None) //因为调整了结构，在条用CompleteOver的时候会传递下一个任务的ID，
                                                                                   //如果判断任务可接，那么会寻路，但是这个时候服务器还没有调用AddmissionToUser，所以这边通过NextMissionId获取返回的是状态是None
                                GameManager.gameManager.AutoSearch.BuildPath(point, false, null, RoleBase.DialogRadius);
                            else
                                GameManager.gameManager.AutoSearch.BuildPath(point, false, RoleBase.Name, RoleBase.DialogRadius);
                            GameManager.gameManager.AutoSearch.Path.autoSearchRadius = RoleBase.DialogRadius;
                        }else
                        {
                            GameManager.gameManager.AutoSearch.BuildPath(point, false, "");
                        }
                    }

                    MoveOverMissionEvent(nMissionID);
                }
            }
            return true;
        }

        private int collcetMissionId = -1;
        private int collectMissonIndex = -1;
        public void SetCollectMissionIdAndIndex(int missionId, int missionIndex)
        {
            collcetMissionId = missionId;
            collectMissonIndex = missionIndex;
        }
        public int GetCollectMissionId()
        {
            int missionId = collcetMissionId;
            collcetMissionId = -1;
            return missionId;
        }
        public int GetCollectMissionIndex()
        {
            int missionIndex = collectMissonIndex;
            collectMissonIndex = -1;
            return missionIndex;
        }


        // 任务寻路完成后 任务相关事件处理
        void MoveOverMissionEvent(int nMissionID)
        {
            // 收集任务特殊处理
            Tab_MissionBase missBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (missBase == null)
            {
                return;
            }
            MissionState misState = (MissionState)GetMissionState(nMissionID);
            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missBase.LogicID, 0);
            if (missionLogic == null)
                return;

            //采集
            if (missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)) == (int)TableType.Table_CollectItem)
            {
                if (misState != MissionState.Mission_Accepted)
                {
                    return;
                }

                GameEvent gameEvent = new GameEvent();
                gameEvent.Reset();
                gameEvent.EventID = Games.GlobeDefine.GameDefine_Globe.EVENT_DEFINE.EVENT_MISSION_COLLECTITEM;
                SetCollectMissionIdAndIndex(nMissionID, getCurMissionIndex(nMissionID));
                Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(nMissionID, 0);
                if(missionDic != null)
                {
                    int curMissionIndex = getCurMissionIndex(nMissionID);
                    gameEvent.AddFloatParam(missionDic.GetTargetNpcPosXbyIndex(curMissionIndex));
                    gameEvent.AddFloatParam(missionDic.GetTargetNpcPosZbyIndex(curMissionIndex));
                }
                //注意,要在MoveTo之后调用
                if (null != GameManager.gameManager.AutoSearch &&
                    null != GameManager.gameManager.AutoSearch.Path)
                    GameManager.gameManager.AutoSearch.Path.FinishCallBackEvent = gameEvent;
            }


            //探索区域
            if (missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)) == (int)TableType.Table_Enterarea)
            {
                if (misState != MissionState.Mission_Accepted)
                {
                    return;
                }
                m_CurActionMissionId = nMissionID;
                GameEvent gameEvent = new GameEvent();
                gameEvent.Reset();
                gameEvent.EventID = Games.GlobeDefine.GameDefine_Globe.EVENT_DEFINE.EVENT_MISSION_ENTERAREA;
                //gameEvent.AddIntParam(nMissionID);
                //注意,要在MoveTo之后调用
                if (null != GameManager.gameManager.AutoSearch &&
                    null != GameManager.gameManager.AutoSearch.Path)
                    GameManager.gameManager.AutoSearch.Path.FinishCallBackEvent = gameEvent;
            }

            //寻路杀怪
            if (missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)) == (int)TableType.Table_KillMonster)
            {
                if (misState != MissionState.Mission_Accepted)
                {
                    return;
                }
                m_CurActionMissionId = nMissionID;
                GameEvent gameEvent = new GameEvent();
                gameEvent.Reset();
                gameEvent.EventID = Games.GlobeDefine.GameDefine_Globe.EVENT_DEFINE.EVENT_KILLMONSTER;
                //gameEvent.AddIntParam(nMissionID);
                //注意,要在MoveTo之后调用
                if (null != GameManager.gameManager.AutoSearch &&
                    null != GameManager.gameManager.AutoSearch.Path)
                    GameManager.gameManager.AutoSearch.Path.FinishCallBackEvent = gameEvent;
            }

        }

        enum ActionType
        {
            None = 0,
            UseVirtualItem,
            DoAction,
            CallMonster,
        }

        public void MissionCollectItemUnMountCallBack()
        {
            var mainPlayer = Singleton<ObjManager>.Instance.MainPlayer;
            if (!mainPlayer)
                return;
            mainPlayer.StopMove();
            GameManager.gameManager.AutoSearch.Stop();

            //Debug.LogError("UnMountCallBack");
            var missionBase = TableManager.GetMissionBaseByID(GameManager.gameManager.MissionManager.GetCollectMissionId(), 0);
            if (missionBase == null)
                return;

            var missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
            if (missionLogic == null)
                return;

            var collectItem = TableManager.GetMissionCollectItemByID(missionLogic.GetLogicIDbyIndex(GameManager.gameManager.MissionManager.GetCollectMissionIndex()), 0);
            if (collectItem == null)
                return;

            var _targetCharModelId = collectItem.CharModelID;
            GameManager.gameManager.MissionManager.MissionCollectItem(_targetCharModelId);
        }

        public void missionEntreAreaCallBack()
        {
            var mainPlayer = Singleton<ObjManager>.GetInstance().MainPlayer;
            if (mainPlayer &&
                GameManager.gameManager.PlayerDataPool.m_objMountParam.AdvanceMountId > 0)  //当前骑乘ID
            {
                mainPlayer.StopMove();
                GameManager.gameManager.AutoSearch.Stop();

                GameEvent gameEvent = new GameEvent();
                gameEvent.Reset();
                gameEvent.EventID = GameDefine_Globe.EVENT_DEFINE.EVENT_ENTERAUNMOUNTCALLBACK;

                mainPlayer.CurObjAnimState = GameDefine_Globe.OBJ_ANIMSTATE.STATE_FINSH;
                mainPlayer.AskUnMount();

                mainPlayer.UnMountEventCallBack = gameEvent;
                return;
            }

            UnMountCallBack();
        }

        public void UnMountCallBack()
        {
            var mainPlayer = Singleton<ObjManager>.Instance.MainPlayer;
            if (!mainPlayer)
                return;
            mainPlayer.StopMove();
            GameManager.gameManager.AutoSearch.Stop();

            var missionBase = TableManager.GetMissionBaseByID(m_CurActionMissionId, 0);
            if (missionBase == null)
            {
                return;
            }
            MissionState misState = (MissionState)GetMissionState(m_CurActionMissionId);
            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(missionBase.LogicID, 0);
            if (missionLogic == null)
                return;
            int logicId = missionLogic.GetLogicIDbyIndex(getCurMissionIndex(m_CurActionMissionId));
            Tab_MissionEnterArea enterArea = TableManager.GetMissionEnterAreaByID(logicId, 0);
            if (enterArea == null)
                return;
            var actType = enterArea.ActType;
            //1. 使用道具    2.动作  3.使用道具召唤怪物
            //播放动作
            int index = getCurMissionIndex(m_CurActionMissionId);
            if (actType == (int)ActionType.UseVirtualItem || actType == (int)ActionType.CallMonster)
            {
                if (CollectItemSliderLogic.Instance() && CollectItemSliderLogic.Instance().isActiveAndEnabled)  //施展动作状态不判断,不然会刷新一个新的召唤道具UI出来,而且关不掉
                    return;
                Singleton<ObjManager>.GetInstance().MainPlayer.OnSwithObjAnimState(GameDefine_Globe.OBJ_ANIMSTATE.STATE_NORMOR);
                //使用道具
                var commonItem = TableManager.GetCommonItemByID(enterArea.ItemId, 0);
                if (commonItem == null)
                {
                    return;
                }
                //弹窗 快捷使用
                if (ShortCutItemControl.CanShow)
                {
                    UIManager.ShowUI(UIInfo.ShortCutItem, delegate (bool bSuccess, object param)
                    {
                        if (bSuccess)
                        {
                            ShortCutItemControl.Instance.initMyVirtualItem(commonItem.Icon, commonItem.Name, commonItem.Quality, enterArea.AnimationId, enterArea.ItemId);
                            return;
                        }
                    });
                }
            }
            if (actType == (int)ActionType.DoAction)  //直接做动作
            {
                //播放动作
                if (Singleton<ObjManager>.GetInstance().MainPlayer && enterArea.AnimationId != -1)
                {
                    //切换到动作合集状态(各种动作)
                    Singleton<ObjManager>.GetInstance().MainPlayer.OnSwithObjAnimState(GameDefine_Globe.OBJ_ANIMSTATE.STATE_FINSH);
                    Singleton<ObjManager>.GetInstance().MainPlayer.AnimLogic.Play(enterArea.AnimationId);
                }
                UIManager.ShowUI(UIInfo.CollectItemSlider, delegate (bool bSuccess, object param)
                {
                    if (bSuccess)
                    {
                        CollectItemSliderLogic.Instance().setTime(enterArea.AnimationTime, m_CurActionMissionId, enterArea.ItemId, enterArea.MissionDesc);
                    }
                });
                return;
            }
        }
        
        public bool IsMissionCompleted(int type)
        {
            switch (type)
            {
                case (int)ActivityDataManager.Activity_Type.ACTIVITY_MISSIONINSECTION:
                    {
                        int complete = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_MISSIONINSECTION);
                        if (complete >= 20)
                            return true;
                    }
                    break;
                case (int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_RINGMISSION:
                    {
                        Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(GlobeVar.RINGMISSIONENTERID, 0);
                        if(missionLimit == null)
                        {
                            return false;
                        }
                        int complete = ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.ACTIVITY_TYPE_RINGMISSION);
                        if (complete >= 20)
                            return true;
                    }
                    break;
            }
           
            return false;
        }

        // 服务器同步数据
        public void SyncMissionList(GC_MISSION_SYNC_MISSIONLIST data)
        {
            m_MissionList.CleanUp();
            //setMissionInSecState((int)data.SectionMissionFlag);  //同步师门状态
            for (int missionIndex = 0; missionIndex </* MissionList.MAX_CHAR_MISSION_NUM*/data.missionsCount; missionIndex++)
            {
                int nMissionID = data.GetMissions(missionIndex).MissionID;

                if (true == AddMission(nMissionID, (byte)data.GetMissions(missionIndex).Qualitytype))
                {
                    m_MissionList.m_aMission[nMissionID].SetStatus((byte)data.GetMissions(missionIndex).State);
                    m_MissionList.m_aMission[nMissionID].m_CompleteFlag = data.GetMissions(missionIndex).Completeflag;
                    m_MissionList.m_aMission[nMissionID].m_CurMissionIndex = getCurMissionIndex(nMissionID);

                    for (int paramIndex = 0; paramIndex < data.GetMissions(missionIndex).nParamCount; paramIndex++)
                    {
                        if (paramIndex == 7)   //任务倒计时参数
                        {
                            m_MissionList.m_aMission[nMissionID].m_nParam[paramIndex] = data.GetMissions(missionIndex).GetNParam(paramIndex) + (int)Time.realtimeSinceStartup;
                        }
                        else
                        {
                            m_MissionList.m_aMission[nMissionID].m_nParam[paramIndex] = data.GetMissions(missionIndex).GetNParam(paramIndex);
                        }
                    }
                    SceneMovieManager.Instance.OnAddMission(nMissionID, (byte)data.GetMissions(missionIndex).State);
                }
            }
            GuildPaoShangeAutoMove();
            for (int nIndex = 0; nIndex < MissionList.MAX_CHAR_MISSION_FLAG_LEN; nIndex++)
            {
                m_MissionList.m_aMissionHaveDoneFlags[nIndex] = data.GetHavedoneFlag(nIndex);
            }

            GameManager.gameManager.PlayerDataPool.MissionSortList.Clear();

            //添加每日指引任务
            AddGuidMissionToList();

            // 如果UI存在，更新UI
            if (MissionDialogAndLeftTabsLogic.Instance())
            {
                MissionDialogAndLeftTabsLogic.Instance().InitMissionFollow();
            }

            if(FunctionPreviewCtr.Instance)
            {
                FunctionPreviewCtr.Instance.GetLastCompleteMainMissionId();
                FunctionPreviewCtr.Instance.OnMissionComplteOver();
            }

            //先进的场景，才同步的任务，这边也要判断一次
            Singleton<CollectItem>.Instance.InitMissionCollectItem();
        }

        private enum GuidMissionType
        {
            Noramal = 0,  //一条龙等入口任务
            Copy = 1,  //副本任务(装备 主线 进阶 门派挑战)
        }

        //添加每日指引任务
        public void AddGuidMissionToList()
        {
            var guidMissionDic = TableManager.GetMissionGuidBase().Values;
            foreach(var guidMission in guidMissionDic)
            {

                 if(guidMission.NeedCompletedMissionId != -1)
                {
                    //判断需要完成的前置任务ID
                    if (!IsMissionHaveDone(guidMission.NeedCompletedMissionId))
                    {
                        continue;
                    }
                }
                else
                {
                    if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level < guidMission.NeedLevel)
                    {
                        continue;
                    }
                }


                if(IsHaveThisTypeGuidMission(guidMission.Id))
                {
                    continue;
                }

                //判断活动剩余的次数
               if(guidMission.LimitTimes != -1 && IsGuideMissionCompleted(guidMission.Id))
                {
                    continue;
                }

                AddMission(guidMission.Id);
            }
        }

        //是否已经拥有对应类型的指引任务
        public bool IsHaveThisTypeGuidMission(int _GuidBaseId)
        {
            Tab_MissionGuidBase missionGuidBase = TableManager.GetMissionGuidBaseByID(_GuidBaseId, 0);
            if(missionGuidBase == null)
            {
                return false;  //不是指引任务 不做判断（别的地方有对应的判断）
            }

            foreach(var missionInfo in m_MissionList.m_aMission)
            {
                Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(missionInfo.Key, 0);
                if(missionBase != null)
                {
                    if(missionBase.MissionType == missionGuidBase.MissionBaseType)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public bool IsGuideMissionCompleted(int _GuidMissionId)
        {
            Tab_MissionGuidBase guideBase = TableManager.GetMissionGuidBaseByID(_GuidMissionId, 0);
            if (guideBase == null)
            {
                return false;
            }
            int complete = ActivityDataManager.Instance.GetActivityCompleteTimes(guideBase.ActivityType);
            if(complete>=0 && complete >= guideBase.LimitTimes)
            {
                return true;
            }
            return false;
        }

        //MissionBoard用，Npc头顶任务特效
        public MissionBoard.MissionBoardState IsHaveMissionAccepted(Obj_NPC oNpc)
        {
            for(int i = 0; i< oNpc.MissionList.Count; ++i)
            {
                Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(oNpc.MissionList[i], 0);
                if (MissionBase == null)
                {
                    continue;
                }

                if (MissionBase.AcceptDataID != oNpc.BaseAttr.RoleBaseID)
                {
                    continue;
                }

                Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(MissionBase.LimitID, 0);
                if (missionLimit != null)
                {
                    if (missionLimit.ClassNeed != -1
                        && ((1 << Singleton<ObjManager>.GetInstance().MainPlayer.Profession) & missionLimit.ClassNeed) == 0)
                    {
                        continue;
                    }
                }

                if (CanAcceptMission(oNpc.MissionList[i]))
                {
                    if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN)  //除了主线都是支线
                    {
                        return MissionBoard.MissionBoardState.MISSION_MAINCANACCEPTED;      //主线类型
                    }
                    else
                    {
                        return MissionBoard.MissionBoardState.MISSION_BRANCHCANACCEPTED;  //支线类型
                    }
                }
            }

            if(oNpc.RoleBaseID == 912 || oNpc.RoleBaseID == 913 || oNpc.RoleBaseID == 914)
            {
                var missionLimites = ActivityDataManager.Instance.GetActivityTabByServerType(ActivityDataManager.Activity_Type.CROSS_SER_ESCORT).ActityLimitTimes;
                switch (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Force)
                {
                    case 6:
                        {
                            if (oNpc.RoleBaseID == 912 && !IsOwnTypeMission((int)MISSIONTYPE.MISSION_CROSSSERVERPOST))
                            {
                                if (ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.CROSS_SER_ESCORT) < missionLimites)
                                {
                                    return MissionBoard.MissionBoardState.MISSION_BRANCHCANACCEPTED;
                                }
                            }
                        }
                        break;
                    case 7:
                        if (oNpc.RoleBaseID == 913 && !IsOwnTypeMission((int)MISSIONTYPE.MISSION_CROSSSERVERPOST))
                        {
                            if (ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.CROSS_SER_ESCORT) < missionLimites)
                            {
                                return MissionBoard.MissionBoardState.MISSION_BRANCHCANACCEPTED;
                            }
                        }
                        break;
                    case 27:
                        if (oNpc.RoleBaseID == 914 && !IsOwnTypeMission((int)MISSIONTYPE.MISSION_CROSSSERVERPOST))
                        {
                            if (ActivityDataManager.Instance.GetActivityCompleteTimes((int)ActivityDataManager.Activity_Type.CROSS_SER_ESCORT) < missionLimites)
                            {
                                return MissionBoard.MissionBoardState.MISSION_BRANCHCANACCEPTED;
                            }
                        }
                        break;
                }
            }

            return MissionBoard.MissionBoardState.MISSION_NONE;
        }

        bool IsOwnTypeMission(int type)
        {
            for(int index = 0; index < MissionList.m_Count; index++)
            {
                var missionBase = TableManager.GetMissionBaseByID(MissionList.m_aMission[index].m_nMissionID, 0);
                if (missionBase.MissionType == type)
                    return true;
            }
            return false;
        }

        public MissionBoard.MissionBoardState GetMissionBoardState(Obj_NPC oNpc)
        {
            if (oNpc == null)
            {
                return MissionBoard.MissionBoardState.MISSION_NONE;
            }


            for (int i = 0; i < oNpc.MissionList.Count; ++i)
            {
                if (IsMissionHaveDone(oNpc.MissionList[i]))
                    continue;

                Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(oNpc.MissionList[i], 0);
                if (MissionBase == null)
                {
                    continue;
                }

                Tab_MissionLimit missionLimit = TableManager.GetMissionLimitByID(MissionBase.LimitID, 0);
                if (missionLimit != null)
                {
                    if (missionLimit.ClassNeed != -1
                        && ((1 << Singleton<ObjManager>.GetInstance().MainPlayer.Profession) & missionLimit.ClassNeed) == 0)
                    {
                        continue;
                    }
                }
                
                byte yState = GetMissionState(oNpc.MissionList[i]);

                //未接取
                if (yState == (byte)MissionState.Mission_NotAccept)
                {
                    if (MissionBase.AcceptDataID == oNpc.BaseAttr.RoleBaseID)
                    {
                        if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN) //主线任务
                        {
                            return MissionBoard.MissionBoardState.MISSION_MAINCANACCEPTED;
                        }
                        else
                        {
                            return MissionBoard.MissionBoardState.MISSION_BRANCHCANACCEPTED;
                        }
                    }

                    if(MissionBase.CompleteDataID == oNpc.BaseAttr.RoleBaseID)
                    {
                        return MissionBoard.MissionBoardState.MISSION_NONE;
                    }
                }

                //进行中
                if (yState == (byte)MissionState.Mission_Accepted)
                {
                    if (MissionBase.CompleteDataID == oNpc.BaseAttr.RoleBaseID)  //当前任务发布者是完成者
                    {
                        if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN) //主线任务
                        {
                            return MissionBoard.MissionBoardState.MISSION_MAINMISSIONHASACCEPTED;
                        }
                        else
                        {
                            return MissionBoard.MissionBoardState.MISSION_BRANCHMISSIONHASACCEPTED;
                        }
                    }
                    else  //当前任务发布者不是完成者
                    {
                        return MissionBoard.MissionBoardState.MISSION_NONE;
                    }
                }

                //完成
                if (yState == (byte)MissionState.Mission_Completed)
                {
                    if (MissionBase.MissionType == (int)MISSIONTYPE.MISSION_MAIN)
                    {
                        if (MissionBase.CompleteDataID == oNpc.BaseAttr.RoleBaseID)
                            return MissionBoard.MissionBoardState.MISSION_MAINCANCOMPLETED;
                        else
                            return MissionBoard.MissionBoardState.MISSION_NONE;
                    }
                    else
                    {
                        if (MissionBase.CompleteDataID == oNpc.BaseAttr.RoleBaseID)
                            return MissionBoard.MissionBoardState.MISSION_BRANCHCANCOMPLETED;
                        else
                            return MissionBoard.MissionBoardState.MISSION_NONE;
                    }
                }
            }

            //NPC没有挂载对应的任务，但是需要在改NPC处完成任务
            foreach (KeyValuePair<int, CurOwnMission> kvp in m_MissionList.m_aMission)
            {
                if (kvp.Key > 0)
                {
                    Tab_MissionDictionary missionDic = TableManager.GetMissionDictionaryByID(kvp.Key, 0);
                    if (missionDic != null)
                    {
                        if (missionDic.CompleteNpcDataID == oNpc.BaseAttr.RoleBaseID)
                        {
                            //判断任务状态
                            byte state = GetMissionState(kvp.Key);

                            if(state == (int)MissionState.Mission_NotAccept)
                            {
                                return MissionBoard.MissionBoardState.MISSION_NONE;
                            }

                            if (state == (int)MissionState.Mission_Completed)
                            {
                                return MissionBoard.MissionBoardState.MISSION_BRANCHCANCOMPLETED;
                            }
                            else
                            {
                                return MissionBoard.MissionBoardState.MISSION_BRANCHMISSIONHASACCEPTED;
                            }
                        }
                    }
                }
            }
            return MissionBoard.MissionBoardState.MISSION_NONE;
        }

        public int GetMissionType(int nMissionID)
        {
            Tab_MissionBase missionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (missionBase == null)
                return (int)MISSIONTYPE.MISSION_INVALID;
            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(nMissionID, 0);
            if (missionLogic == null)
                return (int)MISSIONTYPE.MISSION_INVALID;
            if (missionBase != null)
            {
                return missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID));
            }
            return (int)MISSIONTYPE.MISSION_INVALID;
        }

        public bool GetMissionLogicType(int nMissionID, TableType type)
        {
            Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
            if (MissionBase == null)
                return false;

            Tab_MissionLogic missionLogic = TableManager.GetMissionLogicByID(MissionBase.LogicID, 0);
            if (missionLogic == null)
                return false;

            for(int index = 0; index < missionLogic.getLogicTypeCount(); index++)
            {
                if(missionLogic.GetLogicTypebyIndex(index) == (int)type)
                {
                    return true;
                }
            }

            //if (missionLogic.GetLogicTypebyIndex(getCurMissionIndex(nMissionID)) == (int)type)
            //    return true;

            return false;
        }

        // 采集任务处理
        public void MissionCollectItem(int targetCharModelId)
        {
            var otherObjPool = Singleton<ObjManager>.GetInstance().otherObjPools;
            if (otherObjPool.Count <= 0)
            {
                LogModule.ErrorLog("Cur otherObjPool is Null");
                return;
            }

            var mainPlayerPos = Singleton<ObjManager>.Instance.MainPlayer.transform.position;
            var distance = 3.1f;
            foreach (var obj in otherObjPool.Values)
            {
                if(mainPlayerPos != null)
                    distance = Vector2.Distance(mainPlayerPos, obj.gameObject.transform.position);
                if (distance <= 3.0f && obj.gameObject.CompareTag("CollectItem") && obj.ModelID == targetCharModelId)
                {
                    if(Singleton<CollectItem>.GetInstance().RemoveItem(obj.gameObject))
                        return;
                }
            }
        }

        public void ReqSetMissionParam(int missionId, int missionIndex, int type)
        {
            CG_CLIENT_MISSION_UPDATE req = (CG_CLIENT_MISSION_UPDATE)PacketDistributed.CreatePacket(MessageID.PACKET_CG_CLIENT_MISSION_UPDATE);
            req.SetMissionID(missionId);
            req.SetLogicIdx(missionIndex);
            req.SetLogicType(type);
            req.SendPacket();
        }

        // 显示日常任务界面
        //void OpenDailyMissionUI()
        //{
        //    UIManager.ShowUI(UIInfo.Activity, ShowDailyMissionOver);
        //}

        // 显示任务界面
        void OnOpenMissionLogUI(bool bSuccess, object param)
        {
            if (bSuccess == false)
            {
                return;
            }

            int nMissionID = (int)param;
            if (nMissionID <= GlobeVar.INVALID_ID)
            {
                return;
            }

            if (MissionLogLogic.Instance())
            {
                MissionLogLogic.Instance().SelectMissionID = nMissionID;
            }

        }

        void OpenDailyLuckyUI()
        {

        }

        //int GetDailyMissionType(int nMissionID)
        //{
        //    Tab_MissionBase MissionBase = TableManager.GetMissionBaseByID(nMissionID, 0);
        //    if (MissionBase == null)
        //    {
        //        return (int)DailyMissionType.DailyMissionType_Invalid;
        //    }
        //    //Tab_DailyMission DailyMission = TableManager.GetDailyMissionByID(MissionBase.DalityMissionTabID, 0);
        //    //if (DailyMission == null)
        //    //{
        //    //    return (int)DailyMissionType.DailyMissionType_Invalid;
        //    //}
        //    //return DailyMission.Type;
        //    return 0;
        //}

        //void ShowDailyMissionOver(bool bSuccess, object param)
        //{
        //    if (bSuccess)
        //    {
        //        if (ActivityController.Instance())
        //        {
        //            //ActivityController.Instance().ChangeToDailyMissionTab();0
        //        }
        //    }
        //}

        public int GetMissionFunctionType(Obj_NPC oNpc)
        {
            //if (oNpc == null)
            //{
            //    return -1;
            //}
            //int npcId = oNpc.RoleBaseID;
            //var NpcTab = TableManager.GetRoleBaseAttrByID(npcId, 0);
            //if(NpcTab != null)
            //{
            //    return NpcTab.SceneNpcType;
            //}
            return -1;
        }

        // 特殊不可接任务
        //public bool SpecialMission_CanAccept(int nMissionID)
        //{
        //    if (nMissionID == 236)
        //    {
        //        bool bRet = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_MISSION_DAILYMISSION_FLAG);
        //        if (bRet == true)
        //        {
        //            return false;
        //        }
        //    }
        //    else if (nMissionID == 238)
        //    {
        //        bool bRet = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_ACTIVITY_SINGLEDAY_FLAG);
        //        bool bFlag = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_ACTIVITY_SINGLEDAYMISSION_FLAG);
        //        if (bRet == false || bFlag == true)
        //        {
        //            return false;
        //        }
        //    }
        //    else if (nMissionID == 239 || nMissionID == 240)
        //    {
        //        bool bRet = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_ACTIVITY_THANKSGIVINGDAYFLAG);
        //        bool bFlag = GameManager.gameManager.PlayerDataPool.CommonData.GetCommondFlag((int)USER_COMMONFLAG.CF_ACTIVITY_THANKSMISSIONERYDAYFLAG);
        //        if (bRet == false || bFlag == true)
        //        {
        //            return false;
        //        }
        //    }
        //    return true;
        //}

        // 新手指引任务 点击指引
        //bool Mission_NewPlayerGuide(int nMissionID)
        //{
        //    bool bRet = false;
        //    string strUIName = "";
        //    int nIndex = -1;
        //    switch (nMissionID)
        //    {
        //        case 7: // 赠兽
        //            strUIName = "PlayerFrame";
        //            nIndex = 2;
        //            break;
        //        case 10: // 钟灵
        //            strUIName = "PlayerFrame";
        //            nIndex = 1;
        //            break;
        //        case 19: // 放毒
        //            strUIName = "PlayerFrame";
        //            nIndex = 3;
        //            break;
        //        case 37: // 结拜
        //            strUIName = "PlayerFrame";
        //            nIndex = 5;
        //            break;
        //        case 38: // 竞技
        //            strUIName = "FunctionButton";
        //            nIndex = 2;
        //            break;
        //        case 39: // 强化
        //            strUIName = "PlayerFrame";
        //            nIndex = 0;
        //            break;
        //        case 124: // 爬塔
        //            strUIName = "FunctionButton";
        //            nIndex = 8;
        //            break;
        //        case 125: // 重入
        //            strUIName = "FunctionButton";
        //            nIndex = 8;
        //            break;
        //        case 144: // 伪装--燕子坞
        //            strUIName = "FunctionButton";
        //            nIndex = 9;
        //            break;
        //        case 157: // 历练
        //            {
        //                DailyMission rDailyMission = GameManager.gameManager.PlayerDataPool.DailyMissionData.GetDailyMissionByKind(0);
        //                if (rDailyMission.MissionID > GlobeVar.INVALID_ID)
        //                {
        //                    bool bHasMission = IsHaveMission(rDailyMission.MissionID);
        //                    if (bHasMission)
        //                    {
        //                        OpenDailyMissionUI();
        //                    }
        //                    else
        //                    {
        //                        strUIName = "FunctionButton";
        //                        nIndex = 4;
        //                    }
        //                }
        //            }
        //            break;
        //        case 209: // 珍珑棋局
        //            strUIName = "FunctionButton";
        //            nIndex = 14;
        //            break;
        //        case 210: // 聚贤庄
        //            strUIName = "FunctionButton";
        //            nIndex = 10;
        //            break;
        //        case 150: // 伙伴抽取
        //            strUIName = "PlayerFrame";
        //            nIndex = 6;
        //            break;
        //        case 179: // 宝石镶嵌
        //            strUIName = "PlayerFrame";
        //            nIndex = 9;
        //            break;
        //        case 237: // 批量买药
        //            strUIName = "PlayerFrame";
        //            nIndex = 10;
        //            break;
        //    }


        //    return bRet;
        //}

        // 日常任务 显示对应界面
        //bool OpenMissionWindow(int nMissionID)
        //{
        //    bool bRet = true;
        //    if ((nMissionID >= 85 && nMissionID <= 90)
        //        || nMissionID == 94 || nMissionID == 223
        //        || (nMissionID >= 233 && nMissionID <= 235))
        //    {
        //        UIManager.ShowUI(UIInfo.Activity, ShowMissionWindow, nMissionID);
        //    }
        //    else if (nMissionID == 93)
        //    {
        //        UIManager.ShowUI(UIInfo.RoleView, OpenRoleView);
        //    }
        //    else
        //    {
        //        bRet = false;
        //    }

        //    return bRet;
        //}

        // 失败 打开Mission界面 显示对应界面
        bool Faild_OpenMissionWindow(int nMissionID)
        {
            bool bRet = false;
            if ((nMissionID == GlobeVar.PAOSHANG_MISSIONID_H
                || nMissionID == GlobeVar.PAOSHANG_MISSIONID_L))
            {
                bRet = true;
                UIManager.ShowUI(UIInfo.MissionLogRoot, OnOpenMissionLogUI, nMissionID);
            }
            else
            {
                bRet = false;
            }
            return bRet;
        }

        void OpenEquipStar(bool bSuccess, object param)
        {
            if (bSuccess == false)
            {
                return;
            }
        }
        //void OpenRoleView(bool bSuccess, object param)
        //{
        //    if (RoleViewLogic.Instance() != null)
        //    {
        //        //RoleViewLogic.Instance().m_delAfterStart = RoleViewLogic.Instance().GemBtClick;
        //    }
        //}
        //void OpenFellow(bool bSuccess, object param)
        //{

        //}
        //// 任务相关 打开相关界面
        //void ShowMissionWindow(bool bSuccess, object param)
        //{
        //    if (bSuccess == false)
        //    {
        //        return;
        //    }

        //    if (ActivityController.Instance() == null)
        //    {
        //        return;
        //    }

        //    int nMissionID = (int)param;

        //    string strTabName = "";
        //    switch (nMissionID)
        //    {
        //        case 85:
        //            strTabName = "Tab6";
        //            break;
        //        case 86:
        //            strTabName = "Tab8";
        //            break;
        //        case 87:
        //        case 234:
        //        case 235:
        //            strTabName = "Tab7";
        //            break;
        //        case 88:
        //        case 233:
        //            strTabName = "Tab3";
        //            break;
        //        case 89:
        //            strTabName = "Tab10";
        //            break;
        //        case 90:
        //            strTabName = "Tab5";
        //            break;
        //        case 94:
        //            strTabName = "Tab2";
        //            break;
        //        case 223:
        //            strTabName = "Tab13";
        //            break;

        //    }

        //    if (strTabName != "")
        //    {
        //        //ActivityController.Instance().StrTabName = strTabName;
        //    }
        //}

        // 有任务并且任务未失败
        public bool IsMissionNotFaild(int nMissionID)
        {
            if (IsHaveMission(nMissionID))
            {
                MissionState MState = (MissionState)GetMissionState(nMissionID);
                if (MissionState.Mission_None != MState
                    && MissionState.Mission_Failed != MState)
                {
                    return true;
                }
            }
            return false;
        }

        #region mission uncheck tip

        public Dictionary<MISSIONTYPE, List<int>> _CanAcceptMissionDic = new Dictionary<MISSIONTYPE, List<int>>();

        public bool IsMissionChecked(int missionID)
        {
            var missionTab = TableManager.GetMissionBaseByID(missionID, 0);
            if (missionTab.MissionType == (int)MISSIONTYPE.MISSION_MAIN)
            {
                return true;
            }

            if (PlayerPreferenceData.GetMissionReadFlag(missionID))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public bool IsMissionClassChecked(MISSIONTYPE missionType)
        {
            if (!_CanAcceptMissionDic.ContainsKey(missionType))
                return true;

            foreach (var mission in _CanAcceptMissionDic[missionType])
            {
                if (!IsMissionChecked(mission))
                    return false;
            }

            return true;
        }

        public bool IsMissionChecked()
        {
            foreach (var missionClass in _CanAcceptMissionDic)
            {
                if (!IsMissionClassChecked(missionClass.Key))
                    return false;
            }
            return true;
        }

        public void SetMissionChecked(int missionID)
        {
            PlayerPreferenceData.SetMissionReadFlag(missionID);

            if (MissionLogLogic.Instance())
            {
                MissionLogLogic.Instance().UpdateInitRedDotTips();
            }

            if (MissionDialogAndLeftTabsLogic.Instance())
            {
                MissionDialogAndLeftTabsLogic.Instance().UpdateRedDotTips();
            }
        }

        #endregion
    }

}