服务端发来通知





调用新手引导的  Control     



 //新手引导的控制器
    public class UIGuideCtrl : Singleton<UIGuideCtrl>
    {
        //进入引导
        public void Enter()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_PlayGuideEnter);
        }

        public void Exit()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_PlayGuideExit);
        }

        public void InitLobbyGuideInfo()
        {
            if (!UIGuideModel.Instance.mIsGuideComp && UIGuideModel.Instance.mCurrentTaskModelId != mGuideStepInfo.GuideStepNull)
            {
                //this.Enter();
            }
        }

        /// <summary>
        /// 进入新手引导
        /// </summary>
        public void UIGuideAskEnterPrimaryGuide()
        {
            //CGLCtrl_GameLogic.Instance.AskEnterNewsGuideBattle(1002);
        }

        /// <summary>
        /// 新手新手引导的完成信息
        /// </summary>
        /// <param name="pMsg"></param>
        public void GuideRespStep(GSToGC.GuideCSStepInfo pMsg)
        {
            UIGuideModel.Instance.GuideFinishModelList(pMsg.taskid);//通过model进行数据更新
        }

        public void GuideBattleType(GCToCS.AskCSCreateGuideBattle.guidetype mType)
        {
            UIGuideModel.Instance.GuideType = mType;
        }

        /// <summary>
        /// 将要触发事件的新手引导的按钮放入列表
        /// </summary>
        /// <param name="gobj"></param>
        public void AddUiGuideEventBtn(GameObject gobj)
        {
            if (gobj == null || UIGuideModel.Instance.UiGuideButtonGameObjectList.Contains(gobj))
            {
                return;
            }
            UIGuideModel.Instance.UiGuideButtonGameObjectList.Add(gobj);
            EventCenter.Broadcast(EGameEvent.eGameEvent_UIGuideEvent, gobj);
        }

      
        public void RemoveGuideBtnEvent(GameObject gobj)
        {
            if (gobj == null || !UIGuideModel.Instance.UiGuideButtonGameObjectList.Contains(gobj))
            {
                return;
            }
            UIGuideModel.Instance.UiGuideButtonGameObjectList.Remove(gobj);
        }

    }

 

再调用model



 //新手引导的数据
    public class UIGuideModel : Singleton<UIGuideModel>
    {

        /// <summary>
        /// 获取任务模块要完成的任务id列表
        /// </summary>
        /// <param name="mdId"></param>
        /// <returns></returns>
        public List<int> GetTaskIdList(int mdId)
        {
            List<int> taskList = new List<int>();
            //从配置表中获取所有的配置信息，放入任务表中
            foreach (var item in ConfigReader.GuideTaskXmlInfoDict)
            {
                if (item.Value.ModelID == mdId)
                {
                    taskList.Add(item.Key);
                    continue;
                }
            }
            return taskList;
        }

        /// <summary>
        /// 引导类型
        /// </summary>
        public GCToCS.AskCSCreateGuideBattle.guidetype GuideType = GCToCS.AskCSCreateGuideBattle.guidetype.other;

        public mGuideStepInfo mCurrentTaskModelId
        {
            private set;
            get;
        }

        /// <summary>
        /// 新手引导已完成的模块list
        /// </summary>
        /// <param name="pList"></param>
        public void GuideFinishModelList(List<uint> pList)
        {
            mGuideFinishList = pList;//新手引导已完成的模块
            mCurrentTaskModelId  = mGuideStepInfo.GuideStepNull;
            //遍历表中所有的新手引导
            foreach (mGuideStepInfo step in Enum.GetValues(typeof(mGuideStepInfo)))
            {
                if (step == mGuideStepInfo.GuideStepNull)
                {
                    continue;
                }
                //新手引导已完成的列表中不包含当前ID，即该新手没完成，把当前的新手制定为它
                if (!mGuideFinishList.Contains((uint)step))
                {
                    mCurrentTaskModelId = step;
                    break;
                }
            }
            if (mCurrentTaskModelId != mGuideStepInfo.GuideStepNull)
            {
                //设置模型数据，给现在新手引导的ID赋值
                GamePlayGuideCtrl.Instance.StartModelTask(mCurrentTaskModelId);//从当前的模块开始了
                //界面控制的
                UIGuideCtrl.Instance.Enter();
            }
        }

        /// <summary>
        /// 清理数据
        /// </summary>
        public void ClearModelData()
        {
            mGuideFinishList.Clear();
            UiGuideButtonGameObjectList.Clear();
        }

        /// <summary>
        /// 获取要复制的按钮
        /// </summary>
        /// <param name="ne"></param>
        /// <returns></returns>
        public GameObject GetUiGuideButtonGameObject(string ne)
        {
            foreach (GameObject item in UiGuideButtonGameObjectList)
            {
                if (item == null)
                {
                    continue;
                }
                if (item.name == ne)
                {
                    return item;
                }
            }
            return null;
        }
        public List<GameObject> UiGuideButtonGameObjectList = new List<GameObject>();

        /// <summary>
        /// 已完成模块ID列表
        /// </summary>
        public List<uint> mGuideFinishList = new List<uint>();

        public bool mIsGuideComp;
    }

    /// <summary>
    /// 新手引导总的分四个大步骤
    /// </summary>
    public enum mGuideStepInfo
    {
        GuideStepNull = 0,
        PrimaryGuide = 1001,//个人的新手引导，1001与GuideTask配置表的点击进入新手训练关卡有关系
        BuyHeroGuide,//买英雄的新手引导
        BattleAiGuide,//战斗ai的新手引导
        BuyRuneGuide,//商城引导
    }



public class GamePlayGuideCtrl : Singleton<GamePlayGuideCtrl>
    {
        public GamePlayGuideCtrl()
        {

        }

        public void Enter()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_PlayGuideEnter);
        }

        public void Exit()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_PlayGuideExit);
        }



        /// <summary>
        /// 向服务器发送要执行的任务Id
        /// </summary>
        public void AskSSGuideStepComp(GCToSS.AskSSGuideStepComp.edotype ebornsolder, int mTaskId)
        {
            CGLCtrl_GameLogin.Instance.AskSSGuideStepComp(ebornsolder, mTaskId);
        }

        /// <summary>
        /// 开始该模块的引导
        /// </summary>
        /// <param name="modelId"></param>
        public void StartModelTask(mGuideStepInfo modelId)
        {
            GamePlayGuideModel.Instance.StartModelTask(modelId);//设置模型数据
        }

        /// <summary>
        /// 完成模块Id
        /// </summary>
        /// <param name="mdId"></param>
        /// <param name="comp"></param>
        public void GuideCSStepComplete(int mdId , bool allComp)
        {
            CGLCtrl_GameLogin.Instance.GuideCSStepComplete(mdId, allComp);
            if (allComp)
            {
                UIGuideModel.Instance.mIsGuideComp = allComp;
                UIGuideModel.Instance.ClearModelData();
                GamePlayGuideModel.Instance.ClearModelData();
            }
        }



 

 public class GamePlayGuideModel : Singleton<GamePlayGuideModel>
    {
        public int NowTaskId;

        /// <summary>
        /// 完成子任务
        /// </summary>
        /// <param name="taskId"></param>
        public void OnFinishChildTask(GuideTaskType type , int taskId)
        {
            if (!ConfigReader.GuideTaskMgrInfoDict.TryGetValue(NowTaskId, out GuideMgr))
            {
                return;
            }
            switch (GuideMgr.TaskEndType)
            {
                case GuideDate.TaskCheckType.AllMeetCheck: 
                    AllGuideChildTaskCheck(taskId); 
                    break;
                case GuideDate.TaskCheckType.AnyMeetCheck: 
                    AnyGuideChildTaskCheck(taskId); 
                    break;
                case GuideDate.TaskCheckType.PartMeetCheck: 
                    PartGuideChildTaskCheck(taskId); 
                    break;//调试进的这个
            }
        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
        /// <summary>
        /// 完成全部子任务
        /// </summary>
        private void AllGuideChildTaskCheck(int taskId)
        { 

        }

        /// <summary>
        /// 完成指定子任务
        /// </summary>
        private void AnyGuideChildTaskCheck(int taskId)
        {
        }

        private void PartGuideChildTaskCheck(int taskId)
        {
            if (GuideMgr.EndTaskChildId == taskId)
            {
                OnChangeToNextTask();
            }
        }

        /// <summary>
        /// 开始模块Id，读取配置文件
        /// </summary>
        /// <param name="modelId"></param>
        public void StartModelTask(mGuideStepInfo modelId)
        {
            foreach (var item in ConfigReader.GuideTaskMgrInfoDict)
            {
                if ((mGuideStepInfo)item.Value.mTasktype == modelId)
                {
                    NowTaskId = item.Key;
                    return;
                }
            }
        }

        /// <summary>
        /// 是否事件执行触发
        /// </summary>
        /// <param name="mType"></param>
        /// <param name="gObj"></param>
        /// <returns></returns>
        public bool IsGuideTrigger(ButtonTriggerType mType, GameObject gObj)
        {
            foreach (GuideTaskBase task in GuideTaskExecuteList)
            {
                if (task.taskType != GuideTaskType.ForceClickTask)
                {
                    continue;
                }
                GuideForceClick click = (GuideForceClick)task;
                if (click.IsGuideTrigger(mType, gObj))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 根据表中的配置决定下一步要干嘛，执行下一个任务
        /// </summary>
        public void OnChangeToNextTask()
        {
            
            GuideClearTask();

            if (GuideMgr.moduleend)             
            {
                //如果任务的最后一个模块完成，告诉服务器
                GamePlayGuideCtrl.Instance.GuideCSStepComplete(GuideMgr.mTasktype, (mGuideStepInfo)GuideMgr.mTasktype == mGuideStepInfo.BuyRuneGuide);
            }
            if (UIGuideModel.Instance.mIsGuideComp && GuideMgr != null && GuideMgr.moduleend)
            {
                GamePlayGuideCtrl.Instance.Exit();
                return;
            }
            if (GuideMgr == null)
            {
                return;
            }
            NowTaskId = GuideMgr.NextTaskId;//下一个任务90002
            if (!ConfigReader.GuideTaskMgrInfoDict.TryGetValue(NowTaskId, out GuideMgr))
            {
                return;
            }
            //if (UIGuideModel.Instance.mGuideFinishList.Contains((uint)GuideMgr.mTasktype))              //如果当前模块是之前已经完成的
            //{
            //    GamePlayGuideCtrl.Instance.Exit();
            //    return;
            //}
            if (GuideMgr.mToServerType != 0)
            {
                //告诉服务器新手引导,下一个新手引导的ID
                GamePlayGuideCtrl.Instance.AskSSGuideStepComp((GCToSS.AskSSGuideStepComp.edotype)GuideMgr.mToServerType, NowTaskId);
            }
            EventCenter.Broadcast(EGameEvent.eGameEvent_PlayTaskModelFinish);//发送执行下一个任务的通知
        }

        public void GuideClearTask()
        {
            foreach (GuideTaskBase task in GuideTaskExecuteList)
            {
                task.ClearTask();
            }
            GuideTaskExecuteList.Clear();
        }

        //
        public void ClearModelData()
        {
            GuideTaskExecuteList.Clear();
            GuideMgr = null;
        }

        public List<GuideTaskBase> GuideTaskExecuteList = new List<GuideTaskBase>();

        private GuideMgrInfo GuideMgr;
    }







 

public class GamePlayGuideWindow : BaseWindow
    {
        public GamePlayGuideWindow()
        {
            mScenesType = EScenesType.EST_None;
            mResName = GameConstDefine.UIGuideRestPath;
            mResident = true;//常驻内存
        }

        继承接口/
        //类对象初始化

        public override void Init()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_PlayGuideEnter, Show);
            EventCenter.AddListener(EGameEvent.eGameEvent_PlayGuideExit, Hide);
            //EventCenter.AddListener<GameObject>(EGameEvent.eGameEvent_UIGuideEvent, OnUiGuideAddButtonEvent);
        }

        //类对象释放
        public override void Realse()
        {
            EventCenter.RemoveListener(EGameEvent.eGameEvent_PlayGuideEnter, Show);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_PlayGuideExit, Hide);
            //EventCenter.RemoveListener<GameObject>(EGameEvent.eGameEvent_UIGuideEvent, OnUiGuideAddButtonEvent);
        }

        //窗口控件初始化
        protected override void InitWidget()
        {
            
        }

        protected override void RealseWidget()
        {

        }

        public override void OnEnable()
        {
            //完成一个任务执行下一个
            EventCenter.AddListener(EGameEvent.eGameEvent_PlayTaskModelFinish, ExecuteNextGuide);
            //完成一个子任务
            EventCenter.AddListener<GuideTaskType, int>(EGameEvent.eGameEvent_PlayChildTaskFinish, OnFinishChildTask);//子类任务的完成情况
            EventCenter.AddListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff);
            if (GamePlayGuideModel.Instance.GuideTaskExecuteList.Count == 0)//当前任务没有，执行下一个
            {
                ExecuteNextGuide();
            }
        }

        public override void OnDisable()
        {
            EventCenter.RemoveListener(EGameEvent.eGameEvent_PlayTaskModelFinish, ExecuteNextGuide);
            EventCenter.RemoveListener<GuideTaskType, int>(EGameEvent.eGameEvent_PlayChildTaskFinish, OnFinishChildTask);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff);
        }

        //每帧更新
        public override void Update(float deltaTime)
        {
            base.Update(deltaTime);
            for (int i = GamePlayGuideModel.Instance.GuideTaskExecuteList.Count - 1; i >= 0; i--)
            {
                GamePlayGuideModel.Instance.GuideTaskExecuteList[i].ExcuseTask();
            }
        }

        //游戏事件注册
        protected override void OnAddListener()
        {

        }

        //游戏事件注消
        protected override void OnRemoveListener()
        {

        }

        /// <summary>
        /// 界面打开需要表现引导
        /// </summary>
        /// <param name="gobj"></param>
        private void OnUiGuideAddButtonEvent(GameObject gobj)
        {
            if (!ConfigReader.GuideTaskXmlInfoDict.ContainsKey(mCurrentTaskId))
            {
                return;
            }
            if (ConfigReader.GuideTaskXmlInfoDict[mCurrentTaskId].BtnName == gobj.name)
            {
                DeltGuideInfos(mCurrentTaskId);
            }
        }

        private void SdkLogOff()
        {
            GamePlayGuideModel.Instance.GuideClearTask();
            GamePlayGuideModel.Instance.ClearModelData();
            GamePlayGuideCtrl.Instance.Exit();
        }

        /// <summary>
        /// 显示当前要出现的UI引导
        /// </summary>
        /// <param name="taskId"></param>
        private void DeltGuideInfos(int taskId)
        {
            //UIGuideType type = (UIGuideType)ConfigReader.GuideTaskXmlInfoDict[taskId].GuideType;
            //foreach (var item in mTypeGameObject)
            //{
            //    if (item.Key == type)
            //    {
            //        item.Value.SetActive(true);
            //        continue;
            //    }
            //    item.Value.SetActive(false);
            //}
            //switch (type)
            //{
            //    case UIGuideType.BackGroundBtn: InitGuideGroundBtn(taskId); break;
            //}
        }

        /// <summary>
        /// 初始化有强制的UI引导
        /// </summary>
        private void InitGuideGroundBtn(int taskId)
        {
            //GuideTaskInfo info = ConfigReader.GuideTaskXmlInfoDict[taskId];
            //string name = info.BtnName;
            //GuideEventButton = UIGuideModel.Instance.GetUiGuideButtonGameObject(name);
            //if (GuideEventButton == null)
            //{
            //    return;
            //}
            //LocalParent = GuideEventButton.transform.parent.gameObject;
            //GuideEventButton.transform.parent = mRoot.transform;
            //GuideEventButton.SetActive(false);
            //GuideEventButton.SetActive(true);

            //GameObject obj = LoadUiResource.LoadRes(mRoot, "Guide/" + info.PrefabName);
            //obj.transform.FindChild("Label").GetComponent<UILabel>().text = info.Text;
            //obj.transform.localPosition = info.PosXYZ;
            //ButtonOnPress ck = GuideEventButton.AddComponent<ButtonOnPress>();
            //ck.AddListener(taskId, OnUiGuideBtnFinishEvent, ButtonOnPress.EventType.ClickType);
        }

        /// <summary>
        /// 新手引导事件触发
        /// </summary>
        /// <param name="gobj"></param>
        private void OnUiGuideBtnFinishEvent(int taskId, bool presses)
        {
            if (GuideEventButton == null)
            {
                return;
            }
            GuideEventButton.transform.parent = LocalParent.transform;
            GuideEventButton.SetActive(false);
            GuideEventButton.SetActive(true);
            //TaskIdList.Remove(taskId);
            //if (TaskIdList.Count <= 0)
            //{
            //    return;
            //}
            //mCurrentTaskId = TaskIdList[0];
            //DeltGuideInfos(mCurrentTaskId);
        }

        /// <summary>
        /// 完成子任务
        /// </summary>
        /// <param name="taskId"></param>
        private void OnFinishChildTask(GuideTaskType type , int taskId)
        {
            GamePlayGuideModel.Instance.OnFinishChildTask(type, taskId);
        }

        /// <summary>
        /// 根据Id对引导信息处理然后调用相应界面
        /// </summary>
        private void ExecuteNextGuide()
        {
            //通过配置表读取当前的任务，90004
            int taskId = GamePlayGuideModel.Instance.NowTaskId;
            if (!ConfigReader.GuideTaskMgrInfoDict.ContainsKey(taskId))
            {
                return;
            }
            //ID集合
            List<int> idList = ConfigReader.GuideTaskMgrInfoDict[taskId].ChildTaskId;
            //类型集合
            List<int> TypeList = ConfigReader.GuideTaskMgrInfoDict[taskId].ChildTaskType;
            for (int tp = 0; tp < TypeList.Count; tp++)
            {
                GuideTaskBase task = null;
                GuideTaskType type = (GuideTaskType)TypeList[tp];
                switch (type)
                {
                    case GuideTaskType.ClickButtonTask:
                        task = new GuideClickButtonTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.PathTask:
                        task = new GuidePathTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.TimeCtrlTask:
                        task = new GuideTimeCtrlTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.MoveCameraTask:
                        task = new GuideCameraTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.TipTask:
                        task = new GuideTipTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.PopTipTask:
                        task = new GuidePopTipTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.ObstructTask:
                        task = new GuideObstructTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.VoiceTask:
                        task = new GuideVoiceTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.ObjFlashTask:
                        task = new GuideFlashTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.ObjShowTask:
                        task = new GuideShowObjTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.AbsorbTask:
                        task = new GuideAbsorbTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.SenderSoldierTask:
                        task = new GuideSendNpcTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.SenderHeroTask:
                        task = new GuideSendHeroTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.KillTask:
                        task = new GuideKillTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.RewardTipTask:
                        task = new GuideRewardTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.ForceClickTask:
                        task = new GuideForceClick(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.ScreenClickTask:
                        task = new GuideScreenClickTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.KillHeroTask:
                        task = new GuideKillHeroTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.GetHeroTask:
                        task = new GuideGetHeroTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.GetGuideToAdGuide:
                        task = new GuideToAdGuideTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.LevelToBuyRunes:
                        task = new GuideLevelToBuyRuneTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.GetRuneTask:
                        task = new GuideGetRuneTask(idList[tp], type, mRoot.gameObject);
                        break;
                    case GuideTaskType.EquipRuneTask:
                        task = new GuideEquipRuneTask(idList[tp], type, mRoot.gameObject);
                        break;

                }
                //进入任务
                task.EnterTask();
                GamePlayGuideModel.Instance.GuideTaskExecuteList.Add(task);
            }
        }

        private Dictionary<UIGuideType, GameObject> mTypeGameObject = new Dictionary<UIGuideType, GameObject>();

        private GameObject GuideEventButton;
        private GameObject LocalParent;
        private int mCurrentTaskId;

        public enum UIGuideType
        {
            BackGroundBtn = 1,
            TypeCheckBox,
            TypeBubble,
        }

        //public List<GuideTaskBase> GuideTaskExecuteList = new List<GuideTaskBase>();

    }

 



 

 

//新手引导任务基类
    public class GuideTaskBase  //不继承子mono，不需要挂在某个对象上
    { 
        public int mTaskId
        {
            private set;
            get;
        }

        protected GameObject mRoot;

        protected bool isFinish = false;//任务是否完成

        public GuideTaskType taskType;//任务类型，枚举

        protected bool mIsTaskCoolDown;//任务是否冷却
        protected float mTaskCDtime;//任务CD
        protected float mTaskTime;//任务时间

        //构造函数初始化成员变量
        public GuideTaskBase(int id, GuideTaskType type, GameObject mParent)
        {
            mTaskId = id;
            taskType = type;
            mRoot = mParent;
        }

        public bool IsFinish() 
        {
            return isFinish;
        }

        /// <summary>
        /// 进入任务
        /// </summary>
        public virtual void EnterTask() 
        { 

        }

        /// <summary>
        /// 执行任务
        /// </summary>
        public virtual void ExcuseTask() 
        {
            if (!mIsTaskCoolDown)
            {
                return;
            }
            if (Time.realtimeSinceStartup - mTaskTime >= mTaskCDtime)
            {
                mIsTaskCoolDown = false;
            }
        }

        //任务结束广播消息
        public virtual void FinishTask() 
        {
            if (isFinish)
            {
                return;
            }
            isFinish = true;
            //完成任务之后播放出去，继续执行下一个任务
            EventCenter.Broadcast<GuideTaskType, int>(EGameEvent.eGameEvent_PlayChildTaskFinish, this.taskType, this.mTaskId);
        }

        //清理任务
        public virtual void ClearTask() 
        { 
            isFinish = true;
        }
    }

以强制引导为例



 

    public class GuideForceClick : GuideTaskBase
    {
        private GameObject GuideEventButton;
        private GameObject LocalParent;
        private GameObject mObj;
        private ButtonOnPress Click;
        private GameObject mAnchorObj;
        private GuideTaskInfo mTaskInfo;
        private GameObject mGuideEffect;
        private GameObject mBlack;

        private int mTriggerCount;

        public GuideForceClick(int task, GuideTaskType type, GameObject mParent)
            : base(task, type, mParent)//不继承子mono，写一个构造函数
        {

        }

        public override void EnterTask()
        {
            //监听按钮的点击事件
            EventCenter.AddListener<GameObject>(EGameEvent.eGameEvent_UIGuideEvent, OnUiGuideAddButtonEvent);
            //处理任务表现
            DeltTask();
        }

        /// <summary>
        /// 处理按钮表现
        /// </summary>
        private void DeltTask()
        {
            //如果引导中没有，执行此行
            if (!ConfigReader.GuideTaskXmlInfoDict.TryGetValue(mTaskId, out mTaskInfo))
            {
                this.FinishTask();
                return;
            }
            string name = mTaskInfo.BtnName;
            //根据名字信息得到按钮名
            GuideEventButton = UIGuideModel.Instance.GetUiGuideButtonGameObject(name);
            if (GuideEventButton == null)
            {
                return;
            }
            //加特效
            LoadGuideEffect();
            //加引导框
            LoadGuideFrame();

            //处理需要强制点击的按钮的显示
            DeltTriggerInfo(ResolveEventButton());//触发下一个信息
        }

        /// <summary>
        /// 界面打开需要表现引导
        /// </summary>
        /// <param name="gobj"></param>
        private void OnUiGuideAddButtonEvent(GameObject gobj)
        {
            if (gobj.name == mTaskInfo.BtnName)
            {
                DeltTask();
            }
        }

        /// <summary>
        /// 添加点击监听
        /// </summary>
        /// <param name="anchor"></param>
        private void DeltTriggerInfo(bool anchor)
        {
            if (mTaskInfo.mBtnTriggerType == ButtonTriggerType.mTypeClick)
            {
                Click = GuideEventButton.AddComponent<ButtonOnPress>();
                if (anchor)
                {
                    Click.AddListener(mTaskId, OnPressDown, ButtonOnPress.EventType.PressType);
                }
                else
                {
                    Click.AddListener(mTaskId, OnClick, ButtonOnPress.EventType.ClickType);
                }
            }
            else
            {
                AddDragEventListener();
            }
        }

        /// <summary>
        /// 增加事件监听
        /// </summary>
        private void AddDragEventListener()
        {
            //EventCenter.AddListener<ButtonDragType>(EGameEvent.eGameEvent_PlayGuideDragEvent, OnGameObjectDragEvent);
        }

        /// <summary>
        /// 是否事件触发正确
        /// </summary>
        /// <param name="mType"></param>
        /// <param name="gObj"></param>
        /// <returns></returns>
        public bool IsGuideTrigger(ButtonTriggerType mType, GameObject gObj)
        {
            if (GuideEventButton == null)
            {
                return false;
            }
            if (mTaskInfo.mBtnTriggerType == mType && GuideEventButton == gObj)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 滑动的事件
        /// </summary>
        /// <param name="mType"></param>
        private void OnGameObjectDragEvent(ButtonDragType mType)
        {
            if (mType != this.mTaskInfo.mDragType)
            {
                return;
            }
            mTriggerCount++;
            if (mTriggerCount >= this.mTaskInfo.mTaskTimes)
            {
                this.FinishTask();

            }
        }

        /// <summary>
        /// Load Guide的方框
        /// </summary>
        private void LoadGuideFrame()
        {
            ResourceUnit Unit = ResourcesManager.Instance.loadImmediate("Guide/" + mTaskInfo.PrefabName, ResourceType.PREFAB);
            mObj = GameObject.Instantiate(Unit.Asset) as GameObject;
            mObj.transform.parent = mRoot.transform;
			mObj.transform.localPosition = Vector3.zero;
            mObj.transform.FindChild("Anchor/Label").GetComponent<UILabel>().text = mTaskInfo.Text;
            mObj.transform.FindChild("Anchor").localPosition = mTaskInfo.PosXYZ;
            mObj.transform.localScale = Vector3.one;
        }

        private void LoadGuideEffect()
        {
            if (mTaskInfo.GuideEffect == null || mTaskInfo.GuideEffect == "")
            {
                return;
            }
            ResourceUnit Unit = ResourcesManager.Instance.loadImmediate(mTaskInfo.GuideEffect, ResourceType.PREFAB);
            mGuideEffect = GameObject.Instantiate(Unit.Asset) as GameObject;
            mGuideEffect.transform.parent = GuideEventButton.transform;
            mGuideEffect.transform.localPosition = Vector3.zero;
            mGuideEffect.transform.localScale = Vector3.one;
        }

        /// <summary>
        /// 处理需要强制点击指定父类以及层级设置
        /// </summary>
        /// <returns></returns>
        private bool ResolveEventButton()
        {
            mBlack = mRoot.transform.FindChild("Black").gameObject;
            bool mAnc = false;
            LocalParent = GuideEventButton.transform.parent.gameObject;
            UIAnchor mAnchor = LocalParent.GetComponent<UIAnchor>();
            if (mAnchor)
            {
                mAnc = true;
                mAnchorObj = new GameObject("mAnchor");
                mAnchorObj.transform.parent = mRoot.transform;
                mAnchorObj.transform.position = LocalParent.transform.position;
                mAnchorObj.transform.localScale = Vector3.one;
                UIAnchor mAn = mAnchorObj.AddComponent<UIAnchor>();
                mAn.side = UIAnchor.Side.BottomLeft;
                mAn.uiCamera = GameMethod.GetUiCamera;
                GuideEventButton.transform.parent = mAnchorObj.transform;
            }
            else
            {
                GuideEventButton.transform.parent = mBlack.transform;
                if (mTaskInfo.mPos != null && mTaskInfo.mPos != Vector3.zero)
                {
                    GuideEventButton.transform.localScale = Vector3.one;
                    GuideEventButton.transform.localPosition = mTaskInfo.mPos;
                }
            }
            mBlack.SetActive(true);
            GuideEventButton.SetActive(false);
            GuideEventButton.SetActive(true);
            return mAnc;
        }

        /// <summary>
        /// 新手引导的点击按钮
        /// </summary>
        /// <param name="id"></param>
        /// <param name="isDown"></param>
        private void OnClick(int id, bool isDown)
        {
            if (isDown)
            {
                return;
            }
            mTriggerCount++;
            //后面的数默认为0
            if (mTriggerCount >= this.mTaskInfo.mTaskTimes)
            {
                this.FinishTask();//完成任务
            }
        }

        /// <summary>
        /// 按下的事件
        /// </summary>
        /// <param name="id"></param>
        /// <param name="isDown"></param>
        private void OnPressDown(int id, bool isDown)
        {
            if (!isDown)
            {
                return;
            }
            mTriggerCount++;
            if (mTriggerCount >= this.mTaskInfo.mTaskTimes)
            {
                this.FinishTask();
            }
        }


        //引导完成
        public override void FinishTask()
        {
            if (LocalParent == null)
            {
                GameObject.Destroy(GuideEventButton);
                base.FinishTask();
                return;
            }
            GuideEventButton.transform.parent = LocalParent.transform;
            LocalParent = null;
            GuideEventButton.SetActive(false);
            GuideEventButton.SetActive(true);
            base.FinishTask();
        }

        public override void ExcuseTask()
        {

        }

        public override void ClearTask()
        {
            if (LocalParent != null)
            {
                GuideEventButton.transform.parent = LocalParent.transform;
            }
            if (Click != null)
            {
                //UIGuideModel.Instance.UiGuideButtonGameObjectList.Remove(Click.gameObject);
                GameObject.Destroy(Click);
            }
            if (mObj != null)
            {
                GameObject.Destroy(mObj);
            }
            if (mAnchorObj != null)
            {
                GameObject.Destroy(mAnchorObj);
            }
            if (mGuideEffect != null)
            {
                GameObject.Destroy(mGuideEffect);
            }
            //if (mTaskInfo.mBtnTriggerType == ButtonTriggerType.mTypeDrag)
            //{
            //    EventCenter.RemoveListener<ButtonDragType>(EGameEvent.eGameEvent_PlayGuideDragEvent, OnGameObjectDragEvent);  
            //}

            mBlack.SetActive(false);
            EventCenter.RemoveListener<GameObject>(EGameEvent.eGameEvent_UIGuideEvent, OnUiGuideAddButtonEvent);
        }
    }

任务结束后调用了基类的



监听的地方



 



要么引导结束，要么继续去执行引导

CSDN是鼓励用户创作的一个平台，作为一个创作平台，可能很多博客新手不知道如何在CSDN写博客，如何使用编辑器，所以这篇文章将教你如何发布CSDN博文以及发布博文的一些规则。

如何创作博客？

第一步：首先在网站页面找到「创作中心」



第二步：进入「博客管理」后台



第三步：选择博客编辑器



编辑有两种：Markdown编辑器和富文本编辑器

Markdown编辑器

Markdown是一种可以使用普通文本编辑器编写的标记语言，通过简单的标记语法，它可以使用普通文本内容具有一定的格式。（通俗来讲，文本的格式都可以用语法来实现，喜欢用语法写文章的可以选择这个编辑器，如果不会，可以仔细看一下里面的操作说明）



 

富文本编辑器

富文本编辑器是一种内嵌于浏览器，所见即所得的文本编辑器。（个人觉得适合新手）



 

如果想写一篇排版好看的文章，可以在编辑器界面选择「模板」哦



 

如何能让自己的博客文章更加吸引人

文章为原创文章
	
文章内容质量要好（技术内容的话干货比较好哦、非技术文章追着热点写）
	
文章标题要能吸引人（能够简单明要概括文章重点，杜绝标题党）
博客文章可以变现吗？

CSDN支持博主通过自己的技术文章进行变现，具体变现规则可以参考次文档https://blog.csdn.net/blogdevteam/article/details/108000176

博客发布规则

博客发文规则，请参考：https://blog.csdn.net/home/help.html#enterprise

 

1.由于项目的需要,我今天学习了新手的引导,接下我来说下新手引导的使用方法:(在程序中运行一次)接下来是实现代码:
在AppDelegate.m 的代码:
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
UIViewController *root;
BOOL answer= [[NSUserDefaults standardUserDefaults]boolForKey:@"answer"];
if (!answer) {
root = [[WecomeViewController1 alloc]init];  //欢迎界面的,就是介绍产品的新特性
}
else{
root = [[TestViewController alloc]init];
}
self.window.rootViewController = root;
[self.window makeKeyAndVisible];
return YES;
}
在需要调用的的时候实现的代码为:
-(void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event{
NSString *anwerLabel  = self.anwerLabel.text;
if([anwerLabel isEqualToString:@""]){
[self showString:@"答案错误,不要太生气!!"];
return;
}
if([anwerLabel isEqualToString:@"1234"]){
[self showString:@"恭喜你回答正确!!"];
TestViewController *testVC = [[TestViewController alloc]init];
[self presentViewController:testVC animated:NO completion:nil];
//在这里设置判断是否为第一次,然后设置同步
[[NSUserDefaults standardUserDefaults]setBool:YES forKey:@"answer"];
[[NSUserDefaults standardUserDefaults]synchronize];
}
}
希望可以帮助有需要的人!欢迎你们提出宝贵的意见!!

新手引导是游戏中必不可少的系统。
原理：

1.添加一个灰色的遮罩层

2.高亮显示引导玩家的内容，比如需要点击的按钮

3.显示提示语：“点击此处”
要解决的问题：

1.统一的触发接口

2.统一的引导基类

3.符合开闭原则

4.按钮如何触发原按钮的点击事件，并触发下一步引导

5.如果不是按钮，点击背景触发下一步引导

6.遮罩锯齿（直接提到遮罩上，不会有锯齿）

7.记录是否已引导过

case 1：一个简单引导案例模拟

如图所示，只有一个按钮和一张图片。

1.引导玩家点击按钮

2.高亮图片

3.结束引导

这是一个很常见的引导需求，也是可以说明引导的核心逻辑。
开发步骤：

1.首先需要GuideManager，管理引导是否开启、是否已经引导过、以及创建引导的功能类。

a.需要一个enum，区分不同的类型
public enum EGuideType
{
    TestPanel = 1 << 1,
    TestPanel_2 = 1 << 2,
    TestPanel_3 = 1 << 3,
}

按位存储，可以节约内存。

b.主逻辑
public class GuideManager : MonoBehaviour
{
    private static GuideManager instance;
    public static GuideManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindObjectOfType<GuideManager>();
            }
            return instance;
        }
    }

    //功能开关
    public static bool bOpen = true;
    //PlayerPrefs存库的 KEY
    private const string KEY_GUIDE = "GuildRecord";

    //是否需要引导
    public bool Need(EGuideType guideType)
    {
        if (!bOpen)
            return false;

        int data = PlayerPrefs.GetInt(KEY_GUIDE, 0);
        return (data & (int)guideType) != (int)guideType;
    }

    //尝试直接进入引导
    public void TryEnter(EGuideType guideType)
    {
        if (!this.Need(guideType))
            return;

        string typeName = "Guide" + guideType.ToString();
        Assembly assembly = Type.GetType(typeName).Assembly;
        GuideBase guide = assembly.CreateInstance(typeName) as GuideBase;//使用反射代替工厂，符合开闭原则
        guide.Init(this);
        guide.Next();
    }

    //记录引导
    public void Save(EGuideType guideType)
    {
        int data = PlayerPrefs.GetInt(KEY_GUIDE, 0);
        int value = data | (int)guideType;
        PlayerPrefs.SetInt(KEY_GUIDE, value);
        PlayerPrefs.Save();
    }
}

2.引导封装成基类，提取公共方法，易于扩展
public abstract class GuideBase
{
    public int step;
    public GuideManager manager;

    public abstract EGuideType GuideType { get; }

    public virtual void Init(GuideManager guideManager)
    {
        this.step = 0;
        this.manager = guideManager;
    }

    //===========================提取公共方法=====================
    //显示背景遮罩
    public void ShowMask()
    {
        GuideMask.Instance.Show(this);
    }
    //提高Button的物体的层级，统一点击按钮进行下一步引导
    public void RaiseTop(Button buttton)
    {
        GuideMask.Instance.RaiseTopButton(buttton);
    }
    //提高非Button的物体的层级，统一点击背景进行下一步引导
    public void RaiseTop(Transform transform)
    {
        GuideMask.Instance.RaiseTopTransform(transform);
    }
    //设置描述
    public void SetTip(string text, Vector2 position)
    {
        GuideMask.Instance.SetTip(text, position);
    }
    //隐藏背景遮罩
    public void HideMask()
    {
        GuideMask.Instance.Hide();
    }
    //存储
    public void Save()
    {
        GuideManager.Instance.Save(this.GuideType);
    }
    //===========================提取公共方法=====================

    //开启下一步引导，这里预定义了6步，基本可以满足需求
    //IEnumerator可以等几秒动画、网络请求、加载等因素
    public void Next()
    {
        this.step++;
        switch (this.step)
        {
            case 1:
                manager.StartCoroutine(ExecuteStep1());
                break;
            case 2:
                manager.StartCoroutine(ExecuteStep2());
                break;
            case 3:
                manager.StartCoroutine(ExecuteStep3());
                break;
            case 4:
                manager.StartCoroutine(ExecuteStep4());
                break;
            case 5:
                manager.StartCoroutine(ExecuteStep5());
                break;
            case 6:
                manager.StartCoroutine(ExecuteStep6());
                break;
        }
    }

    public virtual IEnumerator ExecuteStep1()
    {
        yield break;
    }
    public virtual IEnumerator ExecuteStep2()
    {
        yield break;
    }
    public virtual IEnumerator ExecuteStep3()
    {
        yield break;
    }
    public virtual IEnumerator ExecuteStep4()
    {
        yield break;
    }
    public virtual IEnumerator ExecuteStep5()
    {
        yield break;
    }
    public virtual IEnumerator ExecuteStep6()
    {
        yield break;
    }
}

3.对于遮罩的逻辑

1.copyBtn，点击触发下一步

2.copyTransform，点击背景触发下一步

3.设置提示问题
public class GuideMask : MonoBehaviour
{
    private static GuideMask instance;
    public static GuideMask Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindObjectOfType<GuideMask>();
                instance.btnMask.gameObject.SetActive(true);
                instance.txtTip.gameObject.SetActive(true);
                instance.Hide();
            }
            return instance;
        }
    }

    public Button btnMask;
    private bool canClick;
    public Text txtTip;

    //当前引导
    private GuideBase guide;

    //引导目标的copyBtn
    private Button btnGuide;
    private Button btnGuideCopy;
    //引导目标的copyTr
    private Transform trGuide;
    private Transform trGuideCopy;

    private void Awake()
    {
        btnMask.onClick.AddListener(OnBtnMaskClicked);
    }

    public void Show(GuideBase guide)
    {
        this.guide = guide;
        gameObject.SetActive(true);
    }
    public void Hide()
    {
        this.guide = null;
        gameObject.SetActive(false);
    }

    public void SetTip(string text, Vector2 anchoredPos)
    {
        this.txtTip.text = text;
        this.txtTip.rectTransform.anchoredPosition = anchoredPos;
    }

    public void RaiseTopButton(Button _button)
    {
        //原有按钮
        this.btnGuide = _button;
        //创建新按钮（也可以把原按钮的层提上去）
        this.btnGuideCopy = GameObject.Instantiate(_button.gameObject).GetComponent<Button>();
        this.btnGuideCopy.onClick.AddListener(OnBtnGuideCopyClicked);
        this.btnMask.gameObject.SetActive(true);
        this.btnGuideCopy.transform.SetParent(btnMask.transform);
        this.btnGuideCopy.transform.position = _button.transform.position;
        this.btnGuideCopy.transform.localScale = Vector3.one;
    }

    public void RaiseTopTransform(Transform _transform)
    {
        this.trGuide = _transform;
        this.trGuideCopy = GameObject.Instantiate(_transform.gameObject).transform;
        this.btnMask.gameObject.SetActive(true);
        this.trGuideCopy.SetParent(btnMask.transform);
        this.trGuideCopy.position = _transform.position;
        this.trGuideCopy.localScale = Vector3.one;
        //设置背景可点击
        this.canClick = true;
    }

    private void OnBtnGuideCopyClicked()
    {
        //触发原按钮点击方法
        this.btnGuide.OnSubmit(null);
        //删除新创建的按钮
        Destroy(this.btnGuideCopy.gameObject);
        this.btnGuide = null;
        this.btnGuideCopy = null;
        //触发下一步引导
        guide.Next();
    }

    private void OnBtnMaskClicked()
    {
        if (this.canClick)
        {
            this.trGuide = null;
            this.trGuideCopy = null;
            this.canClick = false;
            //触发下一步引导
            guide.Next();
        }
    }
}

这样基本就完成逻辑了。
4.添加GuideTestPanel，继承GuideBase，开始引导

1.第一步：显示遮罩，提高button

2.第二步：提高image的层级

3.第三步：关闭遮罩，记录引导
public class GuideTestPanel : GuideBase
{
    public override EGuideType GuideType
    {
        get
        {
            return EGuideType.TestPanel;
        }
    }

    public override IEnumerator ExecuteStep1()
    {
        this.ShowMask();
        Button btn = TestPanel.Instance.btn;
        this.RaiseTop(btn);
        this.SetTip("请按照提示点击继续", new Vector2(0f, -585f));
        yield break;
    }

    public override IEnumerator ExecuteStep2()
    {
        Transform tr = TestPanel.Instance.img.transform;
        this.RaiseTop(tr);
        this.SetTip("点击任意位置继续", new Vector2(0f, -585f));
        yield break;
    }

    public override IEnumerator ExecuteStep3()
    {
        this.HideMask();
        this.Save();
        yield break;
    }
}

5.触发引导
public class TestPanel : MonoBehaviour
{
    private static TestPanel instance;
    public static TestPanel Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindObjectOfType<TestPanel>();
            }
            return instance;
        }
    }

    public Button btn;
    public Image img;

    private void Awake()
    {
        btn.onClick.AddListener(OnBtnClicked);
    }

    private void Start()
    {
        //这里触发引导，一行代码即可
        GuideManager.Instance.TryEnter(EGuideType.TestPanel); 
    }

    public void OnBtnClicked()
    {
        Debug.LogError("Btn Clicked!!!!");
    }
}


OK！满足需求。

PS：实际会读取配置表，根据表中步骤再进行对应引导。