精华内容
下载资源
问答
  • 新手引导

    2019-06-26 03:58:11
    服务端发来通知 ...调用新手引导的Control //新手引导的控制器 public class UIGuideCtrl : Singleton<UIGuideCtrl> { //进入引导 public void Enter() { EventCenter.Broadc...

    服务端发来通知

    调用新手引导的  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博客新手引导手册

    万次阅读 多人点赞 2020-08-26 15:44:49
    CSDN是鼓励用户创作的一个平台,作为一个创作平台,可能很多博客新手不知道如何在CSDN写博客,如何使用编辑器,所以这篇文章将教你如何发布CSDN博文。

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

    如何创作博客?

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

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

    第三步:选择博客编辑器

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

    Markdown编辑器

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

     

    富文本编辑器

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

     

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

     

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

    • 文章为原创文章
    • 文章内容质量要好(技术内容的话干货比较好哦、非技术文章追着热点写)
    • 文章标题要能吸引人(能够简单明要概括文章重点,杜绝标题党)

    博客文章可以变现吗?

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

    博客发布规则

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

     

    展开全文
  • Unity新手引导完整代码,圆形,矩形,带新手引导渐变动画 单例管理 方便快捷 快下载吧 内含新手引导shader
  • 1.由于项目的需要,我今天学习了新手的引导,接下我来说下新手引导的使用方法:(在程序中运行一次)接下来是实现代码:在AppDelegate.m 的代码:- (BOOL)application:(UIApplication *)application ...(NSDictionary *)...

    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];

    }

    }

    希望可以帮助有需要的人!欢迎你们提出宝贵的意见!!

    展开全文
  • 微盘新手引导

    2013-04-19 11:03:47
    微盘新手引导
  • 网页操作步骤新手引导,引入刚进入网站的人如何进行操作;jQuery bootstrap网页步骤引导新手特效
  • 新手引导页面实现

    2017-01-04 16:41:19
    新手引导页面实现
  • 新手引导.unitypackage

    2021-01-18 17:37:56
    Unity 新手引导教程 遮罩效果 圆形遮罩和矩形遮罩脚本
  • jquery新手引导

    2015-07-07 21:47:06
    该资源是实现新手引导的功能,里面有源代码,比较详细,主要是JQuery实现的,很简单
  • 引导设计,现在也是大家比较热衷讨论的话题,各类的web产品也都纷纷效仿起移动端的引导方式,...在互联网产品的范畴中,新手引导设计是引导新手用户更快速更愉悦地学习使用产品这一过程的设计,它力图像导游、老师、
  • android新手引导

    2017-01-20 16:52:37
    在activity,fragment等页面上的控件实现新手引导
  • 墨刀新手引导项目.zip

    2020-04-30 16:09:44
    墨刀新手引导项目.zip
  • 新手引导系统

    2021-02-18 00:28:32
    新手引导是游戏中必不可少的系统。 原理: 1.添加一个灰色的遮罩层 2.高亮显示引导玩家的内容,比如需要点击的按钮 3.显示提示语:“点击此处” 要解决的问题: 1.统一的触发接口 2.统一的引导基类 3.符合开闭原则 4...

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

    原理:
    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:实际会读取配置表,根据表中步骤再进行对应引导。

    展开全文
  • Unity3D 新手引导

    2018-05-11 15:57:23
    Unity3D 新手引导 博客有介绍 https://blog.csdn.net/nicepainkiller/article/details/80272740 https://blog.csdn.net/nicepainkiller/article/details/80272740
  • Android 新手引导

    2018-02-26 16:58:43
    有需要的可以看看哦,不错的新手引导页,代码是完整的,Android studio 运行,eclipse的可以复制代码哦
  • Julia 语言新手引导

    2018-08-30 11:25:28
    julia 新手引导。Julia 是一个面向科学计算的高性能动态高级程序设计语言。其语法与其他科学计算语言相似。在许多情况下拥有能与编译型语言相媲美的性能。Julia 是个灵活的动态语言,适合科学和数值计算,性能可与...
  • HandyControl新手引导

    2020-07-05 12:32:20
    从接触HandyControl(之后文章内容简称HC)开始,这些问题,是刚入组织时,最频繁问到的问题,针对这些重复问题写了这篇新手引导 资源在哪里? 源码及库包 源码包含目前最新的完整代码,编译运行 名称 类型 访问...
  • WPF 简易新手引导

    2019-04-29 11:17:00
    WPF 简易新手引导 原文:WPF 简易新手引导这两天不忙,所以,做了一个简易的新手引导小Demo。因为,不是项目上应用,所以,做的很粗糙,也就是给需要的人,一个思路而已。 新手引导功能的话,就是告诉...
  • 主要为大家详细介绍了Unity实现新手引导的镂空效果,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了iOS开发添加新手引导效果,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • ios-新手引导.zip

    2019-07-11 20:01:44
    聚光灯效果的新手引导,点击箭头指向的空白区域可以执行下一步操作。。
  • swift 实现新手引导

    2021-01-04 15:15:07
    swift实现一个简单的新手引导 实现效果如下: 无限堆叠单个引导的说明 镂空样式自定义 多个引导连续播放 引导位置自动定位 引导类型: 调用方式: 具体实现在以下git链接中: ......
  • autojs之新手引导

    2021-02-14 00:25:44
    作者: 牙叔 ... log("开启新手引导"); setTimeout(function () { 新手引导(); }, 500); }); 截图 function screenCapture(activity) { log("screenCapture"); // 获取windows中最顶层的vie
  • 新手引导插件

    2019-07-27 13:53:25
    这两天在做OA界面的新手引导,找到了一个网站,介绍了不少插件,可以使用 传送门 添加链接描述 我对其中的intro.js与EnjoyHint插件使用的较为熟练,intro.js操作简单,但是功能不太全,不可以点击高亮框里的东西, ...
  • 新手引导视图,初次打开页面时显示。 支持圆形,椭圆,矩形等多种图形 提示部分支持图片和文字提示 先看效果图 使用步骤。 使用起来特别简单,只需要把GuideView这个类复制到你的项目中就可以了 *使用图片 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,215
精华内容 886
关键字:

新手引导