服务端发来通知
调用新手引导的 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);
}
}
任务结束后调用了基类的
监听的地方
要么引导结束，要么继续去执行引导