private bool IsRightHumanImageMode()
{
bool isRightHumanImage = false;
GuideDefine.LocalGuideData localGuideData = null;
if (!DataManager.Manager <GuideManager>().TryGetGuideLocalData(ID, out localGuideData))
{
return(isRightHumanImage);
}
switch (localGuideData.GStyle)
{
case GuideDefine.GuideStyle.Left:
case GuideDefine.GuideStyle.LeftUp:
case GuideDefine.GuideStyle.Up:
case GuideDefine.GuideStyle.LeftDown:
case GuideDefine.GuideStyle.Down:
{
isRightHumanImage = true;
}
break;
case GuideDefine.GuideStyle.Right:
case GuideDefine.GuideStyle.RightDown:
case GuideDefine.GuideStyle.RightUp:
{
isRightHumanImage = false;
}
break;
}
return(isRightHumanImage);
}
public void CheckTriggerData(uint guideId, UIEventDelegate dlg)
{
GuideDefine.LocalGuideData localGuideData = null;
if (DataManager.Manager <GuideManager>().TryGetGuideLocalData(ID, out localGuideData))
{
if (null != localGuideData.GuideTargetObj)
{
GuideTrigger trigger = localGuideData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null == trigger)
{
trigger = localGuideData.GuideTargetObj.AddComponent <GuideTrigger>();
trigger.InitTrigger(localGuideData.ID, dlg);
}
else
{
trigger.AddTriggerId(localGuideData.ID);
}
//如果没有事件触发，需要手动添加碰撞器触发引导事件
if (localGuideData.TriggerEventType == GuideDefine.GuideTriggerEventType.None)
{
BoxCollider boxCollider = localGuideData.GuideTargetObj.GetComponent <BoxCollider>();
if (null == boxCollider)
{
boxCollider = localGuideData.GuideTargetObj.AddComponent <BoxCollider>();
boxCollider.size = localGuideData.GuideTargetObjLocalBounds.size;
boxCollider.center = localGuideData.GuideTargetObjLocalBounds.center;
}
}
}
}
}
public void RefreshPos()
{
GuideDefine.LocalGuideData localGuideData = null;
if (!DataManager.Manager <GuideManager>().TryGetGuideLocalData(ID, out localGuideData) || !localGuideData.RefreshPosInTime)
{
return;
}
GameObject targetObj = localGuideData.GuideTargetObj;
if (null != targetObj && null != m_ts_PointBox)
{
Vector3 curentPos = targetObj.transform.position;
float dis = Vector3.Distance(curentPos, m_sourcePos);
if (dis <= Mathf.Epsilon)
{
return;
}
m_sourcePos = curentPos;
Bounds targetTempBounds = NGUIMath.CalculateRelativeWidgetBounds(m_tsContent, targetObj.transform, false);
m_ts_PointBox.localPosition = targetTempBounds.center - m_v3ContentOffset;
//Bounds targetBounds = NGUIMath.CalculateRelativeWidgetBounds(m_tsContent, m_ts_PointBox.transform, false);
//m_ts_PointBox.localPosition = targetBounds.center - m_v3ContentOffset;
}
}
/// <summary>
/// 重置引导
/// </summary>
/// <param name="guideId"></param>
private void ResetGuide(uint guideId)
{
GuideDefine.LocalGuideData localData = null;
if (DataManager.Manager <GuideManager>().TryGetGuideLocalData(guideId, out localData))
{
//1、清除预制
CacheUnconstrainGrid(guideId);
//2、清除数据
if (null != localData.GuideTargetObj)
{
GuideTrigger gt = localData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null != gt)
{
gt.RemoveTriggerId(guideId);
if (!gt.HaveTriggerData())
{
GameObject.Destroy(gt);
}
//无事件触发，引导完成后删除碰撞器
if (localData.TriggerEventType == GuideDefine.GuideTriggerEventType.None)
{
BoxCollider bCollider = localData.GuideTargetObj.GetComponent <BoxCollider>();
if (null != bCollider)
{
GameObject.Destroy(bCollider);
}
}
}
}
}
}
/// <summary>
/// 检测引导数据是否准备好(一般是指目标对象)
/// </summary>
/// <param name="guideId"></param>
/// <returns></returns>
private bool CheckGuideDataReady(uint guideId)
{
GuideDefine.LocalGuideData guideData = null;
bool ready = true;
if (TryGetGuideLocalData(guideId, out guideData))
{
//1、目标依赖面板为空 2、目标对象不存在 3、依赖数据为空
if (guideData.GuideTargetDependPanel == PanelID.None ||
(guideData.GDType == GuideDefine.GuideGUIDependType.None && guideData.GuideTargetObj == null) ||
(guideData.GDType != GuideDefine.GuideGUIDependType.None && guideData.GDParam.Count == 0))
{
ready = false;
}
//数据检测
if (ready)
{
if (guideData.GuideCheckType == GuideDefine.GuideCheckDataType.Type &&
guideData.GuideCheckItemType != GameCmd.ItemBaseType.ItemBaseType_None)
{
List <uint> itemIds = DataManager.Manager <ItemManager>().GetItemByType(guideData.GuideCheckItemType);
if (null == itemIds || itemIds.Count == 0)
{
ready = false;
}
}
}
}
return(ready);
}
/// <summary>
///刷新
/// </summary>
/// <param name="pid"></param>
private void RefreshGuideTargetObj(PanelID pid)
{
GuideDefine.LocalGuideGroupData localGroupData = null;
GuideDefine.LocalGuideData localGuideData = null;
if (null != CurDoUnConstraintGuide && CurDoUnConstraintGuide.Count > 0)
{
var iemurator = CurDoUnConstraintGuide.GetEnumerator();
while (iemurator.MoveNext())
{
localGroupData = iemurator.Current.Value;
if (null == localGroupData || !localGroupData.LoopTrigger)
{
continue;
}
if (localGroupData.CurStep != 0 &&
TryGetGuideLocalData(localGroupData.CurStep, out localGuideData) &&
localGuideData.GuideTargetDependPanel == pid)
{
localGuideData.GuideTargetObj = null;
}
}
}
if (null != CurDoRepeatUnConstraintGuide)
{
if (CurDoRepeatUnConstraintGuide.CurStep != 0 &&
TryGetGuideLocalData(CurDoRepeatUnConstraintGuide.CurStep, out localGuideData) &&
localGuideData.GuideTargetDependPanel == pid)
{
localGuideData.GuideTargetObj = null;
}
}
}
/// <summary>
/// 刷新已经显示的引导可见状态
/// </summary>
private void RefreshShowGuideVisbieStatus(UIDefine.GameObjMoveData moveData = null)
{
if (null != m_dic_showGuide && m_dic_showGuide.Count > 0)
{
bool visible = false;
GuideTrigger gTrigger = null;
foreach (KeyValuePair <uint, UIUnconstraintGrid> pair in m_dic_showGuide)
{
GuideDefine.LocalGuideData localData = null;
if (!DataManager.Manager <GuideManager>().TryGetGuideLocalData(pair.Key, out localData))
{
continue;
}
visible = DataManager.Manager <GuideManager>().IsGuideUIStatusReady(pair.Key) && UIManager.IsObjVisibleByCamera(localData.GuideTargetObj);
if (visible && null != moveData && null != moveData.Objs &&
moveData.Objs.Contains(localData.GuideTargetObj))
{
switch (moveData.Status)
{
case UIDefine.GameObjMoveStatus.MoveToInvisible:
case UIDefine.GameObjMoveStatus.Invisible:
visible = false;
break;
case UIDefine.GameObjMoveStatus.Visible:
visible = true;
break;
}
}
if (null != pair.Value)
{
if (visible)
{
if (!pair.Value.Visible)
{
ShowGuide(pair.Key);
}
if (localData.RefreshPosInTime)
{
pair.Value.RefreshPos();
}
}
else if (!visible && pair.Value.Visible)
{
pair.Value.SetVisible(false);
if (null != localData.GuideTargetObj)
{
gTrigger = localData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null != gTrigger && gTrigger.enabled)
{
gTrigger.enabled = false;
}
}
}
}
}
}
}
/// <summary>
/// 取消非强制引导显示
/// </summary>
/// <param name="guideID"></param>
private void CancelUnconstrainGuideShow(uint guideID)
{
GuideDefine.LocalGuideData localData = null;
if (TryGetGuideLocalData(guideID, out localData) &&
localData.GType == GuideDefine.GuideType.Unconstrain)
{
Engine.Utility.EventEngine.Instance().DispatchEvent((int)Client.GameEventID.UIEVENTGUIDERESET, guideID);
}
}
/// <summary>
/// 完成单个类型引导
/// </summary>
/// <param name="gType"></param>
private void CompleteGuide(uint guideId)
{
GuideDefine.LocalGuideData localData = null;
if (IsShowUnconstrainGuide(guideId) &&
DataManager.Manager <GuideManager>().TryGetGuideLocalData(guideId, out localData))
{
ResetGuide(guideId);
Engine.Utility.EventEngine.Instance().DispatchEvent((int)Client.GameEventID.UIEVENTGUIDECOMPLETE, guideId);
}
}
/// <summary>
/// 尝试获取引导的组ID
/// </summary>
/// <param name="guideId"></param>
/// <param name="groupId"></param>
/// <returns></returns>
public bool TryGetGuideGroupID(uint guideId, out uint groupId)
{
groupId = 0;
GuideDefine.LocalGuideData localData = null;
if (TryGetGuideLocalData(guideId, out localData))
{
groupId = localData.GuideGroupID;
return(true);
}
return(false);
}
/// <summary>
/// 是否引导UI准备好(获取了焦点)
/// </summary>
/// <param name="guideId"></param>
/// <returns></returns>
public bool IsGuideUIStatusReady(uint guideId)
{
GuideDefine.LocalGuideData localdata = null;
bool ready = false;
if (TryGetGuideLocalData(guideId, out localdata) &&
DataManager.Manager <UIPanelManager>().IsPanelFocus(localdata.GuideTargetDependPanel) &&
((localdata.GDType != GuideDefine.GuideGUIDependType.None && localdata.GDParam.Count > 0) ||
(localdata.GDType == GuideDefine.GuideGUIDependType.None && UIManager.IsObjVisibleByCamera(localdata.GuideTargetObj))))
{
ready = true;
}
return(ready);
}
protected override void OnShow(object data)
{
base.OnShow(data);
RegisterGlobalUIEvent(true);
if (null != data && data is GuideDefine.LocalGuideData)
{
GuideDefine.LocalGuideData localData = data as GuideDefine.LocalGuideData;
if (localData.GType != GuideDefine.GuideType.Unconstrain)
{
Engine.Utility.Log.Error("GuidePanel Show Failed,localData.GType != GuideDefine.GuideType.Unconstrain");
return;
}
CoroutineMgr.Instance.StartCorountine(DelayOp(localData));
}
RefreshShowGuideVisbieStatus();
}
/// <summary>
/// 引导UI事件回调
/// </summary>
/// <param name="eventType">事件类型</param>
/// <param name="data"></param>
/// <param name="param"></param>
private void GuideTriggerDlg(UIEventType eventType, object data, object param)
{
switch (eventType)
{
case UIEventType.Click:
if (data is GuideTrigger)
{
GuideTrigger gTrigger = data as GuideTrigger;
if (null != gTrigger && null != gTrigger.TriggerIds)
{
List <uint> triggerIds = new List <uint>();
triggerIds.AddRange(gTrigger.TriggerIds);
GuideDefine.LocalGuideData localData = null;
for (int i = 0; i < triggerIds.Count; i++)
{
if (i == 0)
{
if (DataManager.Manager <GuideManager>().TryGetGuideLocalData(triggerIds[i], out localData))
{
if (null != localData.GuideTargetObj)
{
GuideTrigger trigger = localData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null != trigger)
{
GameObject.Destroy(trigger);
}
//无事件触发，引导完成后删除碰撞器
if (localData.TriggerEventType == GuideDefine.GuideTriggerEventType.None)
{
if (null != localData.GuideTargetObj.GetComponent <BoxCollider>())
{
GameObject.Destroy(localData.GuideTargetObj.GetComponent <BoxCollider>());
}
}
}
}
}
CompleteGuide(triggerIds[i]);
}
}
}
break;
}
}
/// <summary>
/// 获取下一个强制引导
/// </summary>
/// <param name="guideId"></param>
/// <returns></returns>
private bool TakeNextConstraitGuide(out uint guideId)
{
guideId = 0;
List <uint> guideIds = null;
List <uint> groups = null;
bool isMatch = false;
GuideDefine.GuideType gType = GuideDefine.GuideType.Constraint;
if (m_dic_canDoGuideGroup.TryGetValue(gType, out groups) && groups.Count > 0)
{
GuideDefine.LocalGuideGroupData groupData = null;
GuideDefine.LocalGuideData localData = null;
uint tempGuideId = 0;
if (!IsDoingGuide(gType))
{
do
{
isMatch = false;
if (IsGuideGroupComplete(groups[0]))
{
SilentCompleteGuideGroup(groups[0]);
}
else
{
if (TryGetGuideGroupData(groups[0], out groupData) &&
groupData.TryGetNextStep(out guideId) &&
TryGetGuideLocalData(guideId, out localData) &&
(localData.IsStartStep || localData.TryGetPreStep(out tempGuideId) && IsGuideStepComplete(tempGuideId)))
{
isMatch = true;
}
if (isMatch && IsNeedIgnoreGroup(groups[0]))
{
CompleteGuide(guideId);
isMatch = false;
}
}
} while (groups.Count > 0 && !isMatch);
}
}
return(isMatch);
}
protected override void OnShow(object data)
{
base.OnShow(data);
if (null != data && data is GuideDefine.LocalGuideData)
{
GuideDefine.LocalGuideData localData = data as GuideDefine.LocalGuideData;
if (localData.GType != GuideDefine.GuideType.Constraint)
{
Engine.Utility.Log.Error("GuidePanel Show Failed,localData.GType != GuideDefine.GuideType.Constraint");
return;
}
if (IsDataReady)
{
CompleteGuide();
}
m_helpData.LocalData = localData;
m_float_sinceShow = 0;
ShowSkip(false);
StartCoroutine(DelayOp(localData.DelayTime));
}
}
/// <summary>
/// 延迟执行部分
/// </summary>
/// <param name="delayTime"></param>
/// <returns></returns>
private System.Collections.IEnumerator DelayOp(GuideDefine.LocalGuideData localData)
{
yield return(new WaitForSeconds(localData.DelayTime));
ShowGuide(localData.ID);
}
/// <summary>
/// 引导ID
/// </summary>
/// <param name="guideId"></param>
private void ShowGuide(uint guideId)
{
GuideDefine.LocalGuideData localData = null;
if (DataManager.Manager <GuideManager>().TryGetGuideLocalData(guideId, out localData))
{
if (null == localData.GuideTargetObj)
{
return;
}
PanelType ptype = PanelType.SmartPopUp;
UIPanelManager.LocalPanelInfo localInfo = null;
if (DataManager.Manager <UIPanelManager>().TryGetLocalPanelInfo(localData.GuideTargetDependPanel, out localInfo))
{
ptype = localInfo.PType;
}
if (IsShowUnconstrainGuide(guideId))
{
//如果不可见重新获取当前面板深度
UIUnconstraintGrid showGrid = m_dic_showGuide[guideId];
if (!showGrid.Visible)
{
showGrid.SetVisible(true);
GuideTrigger gTrigger = localData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null != gTrigger && !gTrigger.enabled)
{
gTrigger.enabled = true;
}
int maxDepth = DataManager.Manager <UIPanelManager>().GetTargetRootMaxDepth(ptype);
showGrid.SetDepth(maxDepth + 1);
if (localData.RefreshPosInTime)
{
showGrid.RefreshPos();
}
showGrid.CheckTriggerData(guideId, GuideTriggerDlg);
}
}
else
{
int maxDepth = DataManager.Manager <UIPanelManager>().GetTargetRootMaxDepth(ptype);
UIUnconstraintGrid grid = GetUnconstrainGrid();
if (null != grid)
{
grid.CacheTransform.gameObject.name = guideId.ToString();
m_dic_showGuide.Add(guideId, grid);
}
grid.SetData(maxDepth + 1, guideId, GuideTriggerDlg);
if (localData.TableData.voiceID != 0)
{
DataManager.Manager <UIManager>().PlayUIAudioEffect(localData.TableData.voiceID);
}
}
GuideTriggerData gtData = localData.GuideTargetObj.GetComponent <GuideTriggerData>();
if (null == gtData)
{
gtData = localData.GuideTargetObj.AddComponent <GuideTriggerData>();
}
if (null != gtData && !gtData.IsGuideTrigger)
{
gtData.IsGuideTrigger = true;
}
}
}
private void InitGuideData()
{
m_lst_completeGroupGuide = new List <uint>();
m_dic_canDoGuideGroup = new Dictionary <GuideDefine.GuideType, List <uint> >();
m_dic_guideDatas = new Dictionary <uint, GuideDefine.LocalGuideData>();
m_dic_guideGroupDatas = new Dictionary <uint, GuideDefine.LocalGuideGroupData>();
m_dic_curDoUnConstraintGuide = new Dictionary <uint, GuideDefine.LocalGuideGroupData>();
m_lstGuideGroups = new List <uint>();
m_lstTriggerGuideGroups = new List <uint>();
List <table.GuideDataBase> guideDatas = GameTableManager.Instance.GetTableList <table.GuideDataBase>();
if (null != guideDatas)
{
GuideDefine.LocalGuideData localData = null;
GuideDefine.LocalGuideGroupData localGroupData = null;
for (int i = 0; i < guideDatas.Count; i++)
{
localData = GuideDefine.LocalGuideData.Create(guideDatas[i].id);
if (null == localData || localData.GuideGroupID == 0)
{
continue;
}
if (!m_dic_guideDatas.ContainsKey(localData.ID))
{
m_dic_guideDatas.Add(localData.ID, localData);
}
if (!m_dic_guideGroupDatas.TryGetValue(localData.GuideGroupID, out localGroupData))
{
localGroupData = GuideDefine.LocalGuideGroupData.Create(localData.GuideGroupID);
m_dic_guideGroupDatas.Add(localData.GuideGroupID
, localGroupData);
}
localGroupData.Add(localData);
//构造数据引导组步骤数据
if (!m_lstGuideGroups.Contains(localData.GuideGroupID))
{
m_lstGuideGroups.Add(localData.GuideGroupID);
}
}
//对引导组内部步骤排序
if (m_dic_guideGroupDatas.Count > 0)
{
var groupEmurator = m_dic_guideGroupDatas.GetEnumerator();
GuideDefine.LocalGuideData leftData = null;
GuideDefine.LocalGuideData rightData = null;
while (groupEmurator.MoveNext())
{
localGroupData = groupEmurator.Current.Value;
localGroupData.InitData();
localGroupData.GroupSteps.Sort((left, right) =>
{
if (TryGetGuideLocalData(left, out leftData) && TryGetGuideLocalData(right, out rightData))
{
return((int)leftData.GuideGroupStep - (int)rightData.GuideGroupStep);
}
return(0);
});
}
}
}
}
/// <summary>
/// 尝试获取引导本地数据
/// </summary>
/// <param name="guideId"></param>
/// <param name="localData"></param>
/// <returns></returns>
public bool TryGetGuideLocalData(uint guideId, out GuideDefine.LocalGuideData localData)
{
return(m_dic_guideDatas.TryGetValue(guideId, out localData));
}
/// <summary>
/// 设置非强制引导数据
/// </summary>
/// <param name="panelDepath"></param>
/// <param name="id"></param>
public void SetData(int panelDepth, uint id, UIEventDelegate dlg)
{
Init();
if (!Visible)
{
SetVisible(true);
}
this.m_uint_id = id;
GuideDefine.LocalGuideData localGuideData = null;
SetDepth(panelDepth);
if (DataManager.Manager <GuideManager>().TryGetGuideLocalData(ID, out localGuideData))
{
//设置位置
SetPos(out m_v3ContentOffset);
//显示内容
UILabel tempLab = null;
RefreshHumanImage(ref tempLab);
if (null != tempLab)
{
tempLab.text = localGuideData.Des;
}
if (null != localGuideData.GuideTargetObj)
{
m_sourcePos = localGuideData.GuideTargetObj.transform.position;
GuideTrigger trigger = localGuideData.GuideTargetObj.GetComponent <GuideTrigger>();
if (null == trigger)
{
trigger = localGuideData.GuideTargetObj.AddComponent <GuideTrigger>();
trigger.InitTrigger(localGuideData.ID, dlg);
}
else
{
trigger.AddTriggerId(localGuideData.ID);
}
//如果没有事件触发，需要手动添加碰撞器触发引导事件
if (localGuideData.TriggerEventType == GuideDefine.GuideTriggerEventType.None)
{
BoxCollider boxCollider = localGuideData.GuideTargetObj.GetComponent <BoxCollider>();
if (null == boxCollider)
{
boxCollider = localGuideData.GuideTargetObj.AddComponent <BoxCollider>();
boxCollider.size = localGuideData.GuideTargetObjLocalBounds.size;
boxCollider.center = localGuideData.GuideTargetObjLocalBounds.center;
}
}
}
if (null != m_particle)
{
m_effectRoot.transform.localPosition = Vector3.zero;
m_particle.ReleaseParticle();
m_particle.AddParticle(50042, endCallback: OnParticleDispalyEffectComplete);
}
//if (null != m_particle && !m_bAddEffect)
//{
// m_particle.AddParticle(50041);
// m_bAddEffect = true;
//}
SetVisible(false);
SetVisible(true);
}
}
/// <summary>
/// 执行引导组
/// </summary>
/// <param name="groupId"></param>
/// <returns></returns>
private bool DoGuideGroup(uint groupId)
{
bool success = false;
if (GuideManager.IsGuideEnable)
{
GuideDefine.LocalGuideGroupData localGroupData = null;
if (TryGetGuideGroupData(groupId, out localGroupData))
{
uint curDoGuideID = 0;
if (!IsDoingGroup(groupId, out curDoGuideID))
{
localGroupData.Reset();
if (localGroupData.GType == GuideDefine.GuideType.Constraint)
{
m_curDoConstraintGuide = localGroupData;
}
else if (localGroupData.GType == GuideDefine.GuideType.Unconstrain)
{
if (!localGroupData.LoopTrigger)
{
m_dic_curDoUnConstraintGuide.Add(groupId, localGroupData);
}
else
{
if (curCanDoRepeatGroup != 0)
{
curCanDoRepeatGroup = 0;
}
m_curDoRepeatUnConstraintGuide = localGroupData;
}
}
}
if (localGroupData.CurStep == 0)
{
if (localGroupData.TryGetNextStep(out curDoGuideID))
{
GuideDefine.LocalGuideData localData = null;
if (CheckGuideDataReady(curDoGuideID) && TryGetGuideLocalData(curDoGuideID, out localData))
{
localData.GuideTargetObj = null;
localGroupData.MoveToNextStep();
if (localData.JumpID != 0)
{
ItemManager.DoJump(localData.JumpID);
}
if (localData.GDType != GuideDefine.GuideGUIDependType.None)
{
Engine.Utility.EventEngine.Instance().DispatchEvent((int)Client.GameEventID.UIEVENTGUIDEITEMFOCUS, new GuideDefine.GuideItemFocusData()
{
DependType = localData.GDType,
Data = localData.GDParam[0],
});
}
if (localGroupData.GType == GuideDefine.GuideType.Unconstrain)
{
DataManager.Manager <UIPanelManager>().ShowPanel(PanelID.GuideUnconstrainPanel, data: localData);
}
else if (localGroupData.GType == GuideDefine.GuideType.Constraint)
{
DataManager.Manager <UIPanelManager>().ShowPanel(PanelID.GuidePanel, data: localData);
}
Engine.Utility.Log.LogGroup("WJH", "DoGuide:" + localData.ID);
Engine.Utility.EventEngine.Instance().DispatchEvent((int)Client.GameEventID.UIEVENTGUIDESHOWOUT);
}
}
else
{
SilentCompleteGuideGroup(groupId);
}
}
}
else
{
SilentCompleteGuideGroup(groupId);
}
}
else
{
SilentCompleteGuideGroup(groupId);
}
return(success);
}
/// <summary>
/// 获取引导样式数据
/// </summary>
/// <param name="localData"></param>
/// <returns></returns>
public static GuideStyleData GetGuideStyleData(GuideShowHelpData helpData)
{
GuideStyleData styleData = new GuideStyleData();
Vector3 targetPos = Vector3.zero;
GuideDefine.LocalGuideData localData = helpData.LocalData;
if (null == helpData.GuideRoot)
{
return(styleData);
}
Matrix4x4 localMatrix = helpData.GuideRoot.worldToLocalMatrix;
Bounds bounds = localData.GuideTargetObjWorldBounds;
float offset = GuideManager.GuidePointAtOffset;
//转化为本地坐标
Vector3 min = localMatrix.MultiplyPoint3x4(bounds.min);
Vector3 max = localMatrix.MultiplyPoint3x4(bounds.max);
bounds = new Bounds(min, Vector3.zero);
bounds.Encapsulate(max);
if (helpData.StyleRoot.ContainsKey(localData.GStyle))
{
switch (localData.GStyle)
{
case GuideDefine.GuideStyle.LeftUp:
styleData.ArrowRotateAngle = 0;
styleData.ArrowRight = false;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.min.y - offset;
break;
case GuideDefine.GuideStyle.Up:
styleData.ArrowRotateAngle = 0;
styleData.ArrowRight = false;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.min.y - offset;
break;
case GuideDefine.GuideStyle.RightUp:
styleData.ArrowRotateAngle = 0;
styleData.ArrowRight = true;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.min.y - offset;
break;
case GuideDefine.GuideStyle.Down:
styleData.ArrowRight = false;
styleData.ArrowRotateAngle = -180;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.max.y + offset;
break;
case GuideDefine.GuideStyle.LeftDown:
styleData.ArrowRight = false;
styleData.ArrowRotateAngle = -180;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.max.y + offset;
break;
case GuideDefine.GuideStyle.RightDown:
styleData.ArrowRight = true;
styleData.ArrowRotateAngle = -180;
targetPos.x = (bounds.max.x + bounds.min.x) / 2f;
targetPos.y = bounds.max.y + offset;
break;
case GuideDefine.GuideStyle.Left:
styleData.ArrowRight = false;
styleData.ArrowRotateAngle = -270;
targetPos.x = bounds.max.x + offset;
targetPos.y = (bounds.max.y + bounds.min.y) / 2f;
break;
case GuideDefine.GuideStyle.Right:
styleData.ArrowRight = true;
styleData.ArrowRotateAngle = -90;
targetPos.y = (bounds.max.y + bounds.min.y) / 2f;
break;
}
styleData.TargetRoot = helpData.StyleRoot[localData.GStyle];
styleData.TargetPos = targetPos;
}
return(styleData);
}
/// <summary>
/// 显示引导
/// </summary>
/// <param name="data"></param>
private void ShowGuide()
{
Transform ts = null;
if (IsDataReady)
{
GuideDefine.LocalGuideData data = m_helpData.LocalData;
if (null == m_helpData.LocalData.GuideTargetObj)
{
SilentComplete();
}
if (!m_helpData.GuideRoot.gameObject.activeSelf)
{
m_helpData.GuideRoot.gameObject.SetActive(true);
}
GuideStyleData gstyleData = GuidePanel.GetGuideStyleData(m_helpData);
Vector3 angle = Vector3.zero;
angle.z = gstyleData.ArrowRotateAngle;
UILabel desLab = null;
if (null != m_trans_ArrowContent)
{
m_trans_ArrowContent.localEulerAngles = angle;
}
if (null != m_trans_PointBoxContent)
{
m_trans_PointBoxContent.parent = gstyleData.TargetRoot;
m_trans_PointBoxContent.localPosition = Vector3.zero;
}
if (null != m_trans_PBLeftContent)
{
if (m_trans_PBLeftContent.gameObject.activeSelf == gstyleData.ArrowRight)
{
m_trans_PBLeftContent.gameObject.SetActive(!gstyleData.ArrowRight);
}
if (!gstyleData.ArrowRight)
{
desLab = m_label_GuideLeftContent;
}
}
if (null != m_trans_PBRightContent)
{
if (m_trans_PBRightContent.gameObject.activeSelf != gstyleData.ArrowRight)
{
m_trans_PBRightContent.gameObject.SetActive(gstyleData.ArrowRight);
}
if (gstyleData.ArrowRight)
{
desLab = m_label_GuideRightContent;
}
}
if (null != desLab)
{
desLab.text = data.Des;
}
if (null != data.GuideTargetObj && null != m_helpData.AttachRoot)
{
//备份目标对象
GameObject cloneTarget = GameObject.Instantiate(data.GuideTargetObj);
cloneTarget.name = data.GuideTargetObj.name;
cloneTarget.transform.parent = m_helpData.AttachRoot;
cloneTarget.transform.localScale = data.GuideTargetObj.transform.localScale;
cloneTarget.transform.localPosition = data.GuideTargetObj.transform.localPosition;
cloneTarget.transform.localRotation = data.GuideTargetObj.transform.localRotation;
cloneTarget.transform.position = data.GuideTargetObj.transform.position;
m_helpData.CloneTarget = cloneTarget;
//删除UIPlayerTween
UIPlayTween[] tws = cloneTarget.GetComponents <UIPlayTween>();
int length = (null != tws) ? tws.Length:0;
if (length > 0)
{
for (int i = 0; i < length; i++)
{
GameObject.Destroy(tws[i]);
}
}
GuideTrigger trigger = cloneTarget.GetComponent <GuideTrigger>();
if (null == trigger)
{
trigger = cloneTarget.AddComponent <GuideTrigger>();
}
trigger.InitTrigger(data.ID, GuideTriggerDlg);
//如果没有事件触发，需要手动添加碰撞器触发引导事件
//if (data.TriggerEventType == GuideDefine.GuideTriggerEventType.None)
{
BoxCollider boxCollider = cloneTarget.GetComponent <BoxCollider>();
if (null == boxCollider)
{
boxCollider = cloneTarget.AddComponent <BoxCollider>();
boxCollider.size = data.GuideTargetObjLocalBounds.size;
boxCollider.center = data.GuideTargetObjLocalBounds.center;
}
if (!boxCollider.enabled)
{
boxCollider.enabled = true;
}
}
}
if (null != m_helpData.PointBoxRoot)
{
if (!m_helpData.PointBoxRoot.gameObject.activeSelf)
{
m_helpData.PointBoxRoot.gameObject.SetActive(true);
}
m_helpData.PointBoxRoot.localPosition = gstyleData.TargetPos;
}
ShowGuideDynamicMask(m_helpData.LocalData.GuideTargetWorldPos, 1);
if (null != m_trans_ConstraintAnimContent)
{
TweenScale tween = m_trans_ConstraintAnimContent.GetComponent <TweenScale>();
if (null != tween)
{
tween.ResetToBeginning();
tween.enabled = true;
}
}
SetVisible(false);
SetVisible(true);
}
}
/// <summary>
/// 初始化数据
/// </summary>
public void InitData()
{
if (m_bInit)
{
return;
}
m_bInit = true;
GuideDefine.LocalGuideData localData = GuideDefine.LocalGuideData.Create(FirstStep);
if (null == localData)
{
Engine.Utility.Log.Error("LocalGuideGroupData->InitData failed,data error id:{0}" + FirstStep);
return;
}
//1、触发条件
m_lstTriggerIds = new List <uint>();
//2、忽略条件
m_lstIgnoreTriggerIds = new List <uint>();
if (null != localData.TableData)
{
uint tempId = 0;
string[] idArrayStr = null;
if (!string.IsNullOrEmpty(localData.TableData.triggerCondiIDStr))
{
idArrayStr = localData.TableData.triggerCondiIDStr.Split(new char[] { '|' });
if (null != idArrayStr && idArrayStr.Length > 0)
{
for (int i = 0, max = idArrayStr.Length; i < max; i++)
{
if (string.IsNullOrEmpty(idArrayStr[i]))
{
continue;
}
if (!uint.TryParse(idArrayStr[i].Trim(), out tempId))
{
continue;
}
if (!m_lstTriggerIds.Contains(tempId))
{
m_lstTriggerIds.Add(tempId);
}
}
}
}
if (!string.IsNullOrEmpty(localData.TableData.ignoreCondiStr))
{
idArrayStr = localData.TableData.ignoreCondiStr.Split(new char[] { '|' });
if (null != idArrayStr && idArrayStr.Length > 0)
{
for (int i = 0, max = idArrayStr.Length; i < max; i++)
{
if (string.IsNullOrEmpty(idArrayStr[i]))
{
continue;
}
if (!uint.TryParse(idArrayStr[i].Trim(), out tempId))
{
continue;
}
if (!m_lstIgnoreTriggerIds.Contains(tempId))
{
m_lstIgnoreTriggerIds.Add(tempId);
}
}
}
}
}
//3、优先级
m_int_priority = localData.Priority;
//4、循环触发
m_bLoopTrigger = localData.LoopTrigger;
//5、引导类型
m_guideType = localData.GType;
}
private void SetPos(out Vector3 rootOffset)
{
rootOffset = Vector3.zero;
GuideDefine.LocalGuideData localGuideData = null;
if (!DataManager.Manager <GuideManager>().TryGetGuideLocalData(ID, out localGuideData))
{
return;
}
GameObject targetObj = localGuideData.GuideTargetObj;
if (null != targetObj && null != m_ts_PointBox)
{
m_ts_PointBox.localPosition = Vector3.zero;
Bounds targetBounds = NGUIMath.CalculateRelativeWidgetBounds(m_ts_PointBox, targetObj.transform, false);
Vector3 tempPos = Vector3.zero;
if (null != m_fingerEffectRoot)
{
tempPos.x = targetBounds.center.x;
tempPos.y = targetBounds.center.y;
m_fingerEffectRoot.transform.localPosition = tempPos;
}
if (null != m_sp_highLightBg)
{
m_sp_highLightBg.width = Mathf.CeilToInt(targetBounds.size.x + m_v2BroderOffset.x);
m_sp_highLightBg.height = Mathf.CeilToInt(targetBounds.size.y + m_v2BroderOffset.y);
tempPos.x = targetBounds.center.x;
tempPos.y = targetBounds.center.y;
m_sp_highLightBg.transform.localPosition = tempPos;
if (null != m_ts_Arrow && null != m_tween_Arrow)
{
Vector3 rotateAngle = Vector3.zero;
m_ts_Arrow.transform.localEulerAngles = rotateAngle;
m_tween_Arrow.enabled = false;
m_tween_Arrow.ResetToBeginning();
Bounds arrowBounds = NGUIMath.CalculateRelativeWidgetBounds(m_ts_PointBox, m_ts_Arrow, false);
tempPos.z = 0;
switch (localGuideData.GStyle)
{
case GuideDefine.GuideStyle.Left:
{
tempPos.x = m_sp_highLightBg.transform.localPosition.x + 0.5f * (m_sp_highLightBg.width + arrowBounds.size.y);
tempPos.y = m_sp_highLightBg.transform.localPosition.y;
rotateAngle.z = 90;
}
break;
case GuideDefine.GuideStyle.Right:
{
tempPos.x = m_sp_highLightBg.transform.localPosition.x - 0.5f * (m_sp_highLightBg.width + arrowBounds.size.y);
tempPos.y = m_sp_highLightBg.transform.localPosition.y;
rotateAngle.z = 270;
}
break;
case GuideDefine.GuideStyle.LeftUp:
case GuideDefine.GuideStyle.Up:
case GuideDefine.GuideStyle.RightUp:
{
tempPos.x = m_sp_highLightBg.transform.localPosition.x;
tempPos.y = m_sp_highLightBg.transform.localPosition.y - 0.5f * (arrowBounds.size.y + m_sp_highLightBg.height);
rotateAngle.z = 0;
}
break;
case GuideDefine.GuideStyle.LeftDown:
case GuideDefine.GuideStyle.RightDown:
case GuideDefine.GuideStyle.Down:
{
tempPos.x = m_sp_highLightBg.transform.localPosition.x;
tempPos.y = m_sp_highLightBg.transform.localPosition.y + 0.5f * (arrowBounds.size.y + m_sp_highLightBg.height);
rotateAngle.z = 180;
}
break;
}
m_ts_Arrow.transform.localPosition = tempPos;
m_ts_Arrow.transform.localEulerAngles = rotateAngle;
if (null != m_ts_pointContent && null != m_sp_GuideBorder)
{
arrowBounds = NGUIMath.CalculateRelativeWidgetBounds(m_ts_PointBox, m_ts_Arrow, false);
Bounds pointBounds = NGUIMath.CalculateRelativeWidgetBounds(m_ts_PointBox, m_sp_GuideBorder.transform, false);
Vector3 pointPos = Vector3.zero;
Vector3 tempv = Vector3.zero;
switch (localGuideData.GStyle)
{
case GuideDefine.GuideStyle.LeftUp:
{
pointPos = arrowBounds.min;
pointPos.z = 0;
tempv = pointBounds.max;
tempv.x = pointBounds.min.x;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.Left:
{
pointPos.x = arrowBounds.max.x;
pointPos.y = 0.5f * (arrowBounds.max.y + arrowBounds.min.y);
pointPos.z = 0;
tempv.x = pointBounds.min.x;
tempv.y = 0.5f * (pointBounds.max.y + pointBounds.min.y);
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.Right:
{
pointPos.x = arrowBounds.min.x;
pointPos.y = 0.5f * (arrowBounds.max.y + arrowBounds.min.y);
pointPos.z = 0;
tempv.x = pointBounds.max.x;
tempv.y = 0.5f * (pointBounds.max.y + pointBounds.min.y);
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.Up:
{
pointPos.x = 0.5f * (arrowBounds.min.x + arrowBounds.max.x);
pointPos.y = arrowBounds.min.y;
pointPos.z = 0;
tempv.x = 0.5f * (pointBounds.min.x + pointBounds.max.x);
tempv.y = pointBounds.max.y;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.RightUp:
{
pointPos.x = arrowBounds.max.x;
pointPos.y = arrowBounds.min.y;
pointPos.z = 0;
tempv.x = pointBounds.max.x;
tempv.y = pointBounds.max.y;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.LeftDown:
{
pointPos.x = arrowBounds.min.x;
pointPos.y = arrowBounds.max.y;
pointPos.z = 0;
tempv.x = pointBounds.min.x;
tempv.y = pointBounds.min.y;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.RightDown:
{
pointPos.x = arrowBounds.max.x;
pointPos.y = arrowBounds.max.y;
pointPos.z = 0;
tempv.x = pointBounds.max.x;
tempv.y = pointBounds.min.y;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
case GuideDefine.GuideStyle.Down:
{
pointPos.x = 0.5f * (arrowBounds.min.x + arrowBounds.max.x);
pointPos.y = arrowBounds.max.y;
pointPos.z = 0;
tempv.x = 0.5f * (pointBounds.min.x + pointBounds.max.x);
tempv.y = pointBounds.min.y;
tempv.z = 0;
tempPos = m_sp_GuideBorder.transform.localPosition + (pointPos - tempv);
}
break;
}
m_ts_pointContent.transform.localPosition = m_ts_pointContent.transform.localPosition + tempPos;
}
m_tween_Arrow.enabled = true;
}
}
Bounds targetTempBounds = NGUIMath.CalculateRelativeWidgetBounds(m_tsContent, targetObj.transform, false);
rootOffset = targetBounds.center - m_ts_PointBox.localPosition;
}
}
/// <summary>
/// 依赖面板关闭清空相应的循环触发引导（正在执行，或者等待执行的）
/// </summary>
/// <param name="id"></param>
private void ClearRecycleTriggerGuideByPanel(PanelID pid)
{
//1、等待列表移除
uint tempID = 0;
List <uint> waitDoList = null;
List <uint> removeList = null;
List <uint> stepList = null;
GuideDefine.LocalGuideGroupData localGroupData = null;
GuideDefine.LocalGuideData localGuideData = null;
if (m_dic_canDoGuideGroup.TryGetValue(GuideDefine.GuideType.Unconstrain, out waitDoList) &&
waitDoList.Count > 0)
{
for (int i = 0, max = waitDoList.Count; i < max; i++)
{
tempID = waitDoList[i];
if (!TryGetGuideGroupData(tempID, out localGroupData) || !localGroupData.LoopTrigger)
{
continue;
}
stepList = localGroupData.GroupSteps;
if (null == stepList || stepList.Count == 0)
{
continue;
}
for (int j = 0, maxj = stepList.Count; j < maxj; j++)
{
tempID = stepList[j];
if (!TryGetGuideLocalData(tempID, out localGuideData))
{
continue;
}
if (localGuideData.GuideTargetDependPanel == pid)
{
if (null == removeList)
{
removeList = new List <uint>();
}
if (!removeList.Contains(waitDoList[i]))
{
removeList.Add(waitDoList[i]);
}
}
}
}
}
if (null != removeList)
{
for (int i = 0, max = removeList.Count; i < max; i++)
{
tempID = removeList[i];
waitDoList.Remove(tempID);
}
}
//2、进行中引导
if (null != CurDoUnConstraintGuide && CurDoUnConstraintGuide.Count > 0)
{
var iemurator = CurDoUnConstraintGuide.GetEnumerator();
while (iemurator.MoveNext())
{
localGroupData = iemurator.Current.Value;
if (null == localGroupData || !localGroupData.LoopTrigger)
{
continue;
}
if (localGroupData.CurStep != 0 &&
TryGetGuideLocalData(localGroupData.CurStep, out localGuideData) &&
localGuideData.GuideTargetDependPanel == pid &&
( //localGroupData.CurStep != localGroupData.FirstStep ||
pid != PanelID.MainPanel))
{
if (null == removeList)
{
removeList = new List <uint>();
}
if (!removeList.Contains(localGroupData.GroupId))
{
removeList.Add(localGroupData.GroupId);
}
}
}
}
if (null != removeList)
{
for (int i = 0, max = removeList.Count; i < max; i++)
{
tempID = removeList[i];
ResetGuideGroup(tempID);
}
}
//3、重复触发引导
if (null != CurDoRepeatUnConstraintGuide && CurDoRepeatUnConstraintGuide.CurStep != 0)
{
if (CurDoRepeatUnConstraintGuide.CurStep != 0 &&
TryGetGuideLocalData(CurDoRepeatUnConstraintGuide.CurStep, out localGuideData) &&
localGuideData.GuideTargetDependPanel == pid &&
( //localGroupData.CurStep != localGroupData.FirstStep ||
pid != PanelID.MainPanel))
{
ResetGuideGroup(CurDoRepeatUnConstraintGuide.GroupId);
}
}
}
