private void StartFuncMethod()
{
//WindowManager.Instance.HideAllWindow();
HandleTarget target = HandleTarget.GetHandleTarget(PlayerManager.Instance.GetPlayerInstance());
FuncMethods.HandleFuncExec(target, m_CurrentStage.EnterFuncId, null);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
int missionStep = MissionManager.Instance.GetMissionStepCounter(funcdata.ParamIntList[0]);
OperationFunc.FuncOperatorValue((EFuncOperator)funcdata.Oper, ref missionStep, funcdata.ParamIntList[1]);
MissionManager.Instance.SetMissionStepCounter(funcdata.ParamIntList[0], missionStep);
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
ThriftVector3 pos = new ThriftVector3();
pos.X = funcdata.ParamIntList[0];
pos.Y = funcdata.ParamIntList[1];
pos.Z = funcdata.ParamIntList[2];
ThriftVector3 rot = new ThriftVector3();
rot.X = 0;
rot.Y = funcdata.ParamIntList[3];
rot.Z = 0;
ThriftVector3 scal = new ThriftVector3();
scal.X = funcdata.ParamIntList[4];
scal.Y = funcdata.ParamIntList[4];
scal.Z = funcdata.ParamIntList[4];
GameObject elem = EffectContainer.EffectFactory(funcdata.ParamStringList[0]);
elem.transform.position = pos.GetVector3();
elem.transform.eulerAngles = rot.GetVector3();
elem.transform.localScale = scal.GetVector3();
}
catch
{
}
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
ThriftVector3 pos = new ThriftVector3();
pos.X = funcdata.ParamIntList[1];
pos.Y = funcdata.ParamIntList[2];
pos.Z = funcdata.ParamIntList[3];
ThriftVector3 rot = new ThriftVector3();
rot.X = 0;
rot.Y = funcdata.ParamIntList[4];
rot.Z = 0;
ThriftVector3 scal = new ThriftVector3();
scal.X = funcdata.ParamIntList[5];
scal.Y = funcdata.ParamIntList[5];
scal.Z = funcdata.ParamIntList[5];
TerrainManager.Instance.CreateNpcById(id, pos, rot, scal);
}
catch (Exception)
{
Debuger.LogWarning("error on create npc by function ");
}
return(EFuncRet.Continue);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
int missionId = funcdata.ParamIntList[0];
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_ACCEPT_MISSION, missionId));
return(EFuncRet.Continue);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
ThriftVector3 pos = new ThriftVector3();
pos.X = funcdata.ParamIntList[0];
pos.Y = funcdata.ParamIntList[1];
pos.Z = funcdata.ParamIntList[2];
ThriftVector3 rot = new ThriftVector3();
rot.X = 0;
rot.Y = funcdata.ParamIntList[3];
rot.Z = 0;
ThriftVector3 scal = new ThriftVector3();
scal.X = funcdata.ParamIntList[4];
scal.Y = funcdata.ParamIntList[4];
scal.Z = funcdata.ParamIntList[4];
GameObject elem = EffectContainer.EffectFactory(funcdata.ParamStringList[0]);
elem.transform.position = pos.GetVector3();
elem.transform.eulerAngles = rot.GetVector3();
elem.transform.localScale = scal.GetVector3();
}
catch
{
}
return(EFuncRet.Continue);
}
private void TriggerSceneState(MessageObject obj)
{
if (!(obj.msgValue is GameLogicSceneType))
{
return;
}
var map = ConfigManager.Instance.GetLimitFuncSceneConfig();
if (null == map)
{
Debuger.Log("can't load limit func scene config ");
return;
}
int sceneid = (int)(((GameLogicSceneType)(obj.msgValue)));
foreach (var elem in map.LimitFuncSceneConfigMap)
{
if (elem.Key == sceneid)
{
for (int i = 0; i < elem.Value.Count; ++i)
{
HandleTarget target = HandleTarget.GetHandleTarget(null);
if (LimitMethods.HandleLimitExec(target, elem.Value[i].LimitId, null))
{
FuncMethods.HandleFuncExec(target, elem.Value[i].FuncId, null);
}
}
}
}
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
ThriftVector3 pos = new ThriftVector3();
pos.X = funcdata.ParamIntList[1];
pos.Y = funcdata.ParamIntList[2];
pos.Z = funcdata.ParamIntList[3];
ThriftVector3 rot = new ThriftVector3();
rot.X = 0;
rot.Y = funcdata.ParamIntList[4];
rot.Z = 0;
ThriftVector3 scal = new ThriftVector3();
scal.X = funcdata.ParamIntList[5];
scal.Y = funcdata.ParamIntList[5];
scal.Z = funcdata.ParamIntList[5];
TerrainManager.Instance.CreateNpcById(id, pos, rot, scal);
}
catch (Exception)
{
Debuger.LogWarning("error on create npc by function ");
}
return EFuncRet.Continue;
}
public override EBTState Tick()
{
EBTState res;
do
{
Ilife Owner = m_Database.GetData <Ilife>(EDataBaseKey.Owner);
if (null == Owner)
{
res = EBTState.False;
break;
}
HandleTarget handleTarget = HandleTarget.GetHandleTarget(Owner);
if (LimitMethods.HandleLimitExec(handleTarget, m_iLimitId, null))
{
res = EBTState.True;
break;
}
res = EBTState.False;
} while (false);
//mark current status
CurrentStatus = res;
return(res);
}
private void StartResumeFuncMethod()
{
//WindowManager.Instance.HideAllWindow();
HandleTarget target = HandleTarget.GetHandleTarget(PlayerManager.Instance.GetPlayerInstance());
FuncMethods.HandleFuncExec(target, WorldSceneDispatchController.Instance.GetParam().m_iExitSceneStep2FuncId, null);
}
public bool CanEnterScene()
{
CheckSceneStageConfig();
HandleTarget target = HandleTarget.GetHandleTarget(PlayerManager.Instance.GetPlayerInstance());
return(LimitMethods.HandleLimitExec(target, m_CurrentStage.EnterLimitId, null));
}
public void TriggerSceneState(GameLogicSceneType sceneType)
{
for (int i = 0; i < m_CurrentMissionStepList.Count; ++i)
{
MissionStepConfig elemStep = m_CurrentMissionStepList[i];
if (elemStep.SceneId == (int)(sceneType))
{
HandleTarget target = HandleTarget.GetHandleTarget(null);
if (LimitMethods.HandleLimitExec(target, elemStep.SceneLimitId, null))
{
FuncMethods.HandleFuncExec(target, elemStep.SceneFuncId, null);
}
}
HandleTarget target1 = HandleTarget.GetHandleTarget(null);
if (LimitMethods.HandleLimitExec(target1, elemStep.CompleteLimitId, null))
{
FuncMethods.HandleFuncExec(target1, elemStep.CompleteFuncId, null);
}
}
bool isMissionComplete = false;
HandleTarget target2 = HandleTarget.GetHandleTarget(null);
if (LimitMethods.HandleLimitExec(target2, m_CurrentMission.CompleteLimitId, null))
{
isMissionComplete = true;
FuncMethods.HandleFuncExec(target2, m_CurrentMission.CompleteFuncId, null);
}
if (isMissionComplete)
{
m_OnMissioinComplete(this);
}
}
public static HandleTarget GetHandleTarget(Ilife userTarget, List<Ilife> targetList)
{
HandleTarget instance = new HandleTarget();
instance.m_lstUser.Add(userTarget);
instance.m_lstTarget = targetList;
return instance;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
int missionStep = MissionManager.Instance.GetMissionStepCounter(funcdata.ParamIntList[0]);
OperationFunc.FuncOperatorValue((EFuncOperator)funcdata.Oper, ref missionStep, funcdata.ParamIntList[1]);
MissionManager.Instance.SetMissionStepCounter(funcdata.ParamIntList[0], missionStep);
return(EFuncRet.Continue);
}
//Limit Exec Func
static public bool HandleLimitExec(HandleTarget Target, int iLimitGroupId, FuncContext context)
{
if (null == Target || 0 == iLimitGroupId)
{
return true;
}
bool bResult = false;
LimitGroup limitdataGroup = ConfigManager.Instance.GetLimitGroup( iLimitGroupId );
if (null == limitdataGroup || null == limitdataGroup.LimitDataList)
{
return bResult;
}
//Exec Limit
LimitData ExecData;
for( int iLoop = 0; iLoop < limitdataGroup.LimitDataList.Count; ++iLoop )
{
ExecData = limitdataGroup.LimitDataList[iLoop];
if( null == ExecData )
continue;
LimitMethodsBase handler = null;
if( ! LimitExec.TryGetValue(ExecData.Id, out handler) )
{
Debug.LogError("limitId:" + ExecData.Id + " is not found.");
return false;
}
if( 0 == limitdataGroup.Logic )
{
// Or-logic
bResult = handler.LimitExecHandler(Target, ExecData,context);
if (true == bResult)
{
break;
}
}
else if( 1 == limitdataGroup.Logic )
{
// And-logic
bResult = handler.LimitExecHandler(Target, ExecData,context);
if( false == bResult )
{
break;
}
}
else
{
Debug.LogWarning( "The limitdataGroup's logic is error!" );
break;
}
}
return bResult;
}
public static HandleTarget GetHandleTarget(Ilife userTarget, List <Ilife> targetList)
{
HandleTarget instance = new HandleTarget();
instance.m_lstUser.Add(userTarget);
instance.m_lstTarget = targetList;
return(instance);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List<Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
if (target.Count <= 0)
{
return false;
}
Vector3 targetPos = ((ITransformBehaviour) (target[0])).GetTransformData().GetPosition();
float distance = Vector3.Distance(PlayerManager.Instance.GetPlayerInstance().GetTransformData().GetPosition(), targetPos);
return OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, (int)(distance), Limit.ParamIntList[0]);
}
static public int HandleFuncExec(HandleTarget Target, int iFuncGroupId, FuncContext context)
{
if (null == Target || 0 == iFuncGroupId)
{
return(0);
}
FuncGroup funcdataGroup = ConfigManager.Instance.GetFuncGroup(iFuncGroupId);
if (null == funcdataGroup || null == funcdataGroup.FuncDataList)
{
return(0);
}
//Exec Func
FuncData ExecData = null;
int iLoop = 0;
for ( ; iLoop < funcdataGroup.FuncDataList.Count; ++iLoop)
{
ExecData = funcdataGroup.FuncDataList[iLoop];
if (null == ExecData)
{
continue;
}
FuncMethodsBase func = null;
FuncExec.TryGetValue(ExecData.Id, out func);
//
if (null == func)
{
continue;
}
EFuncRet eRet = func.FuncExecHandler(Target, ExecData, context);
if (EFuncRet.Break == eRet)
{
break;
}
else if (EFuncRet.Error == eRet)
{
UnityEngine.Debug.LogWarning("HandleFuncExec is error, id : " + ExecData.Id.ToString());
}
}
if (iLoop == funcdataGroup.FuncDataList.Count)
{
return(-1);
}
return(iLoop);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
bool newValue = funcdata.ParamIntList[0] != 0;
GestureManager.Instance.SetDictation(newValue);
}
catch (Exception)
{
Debuger.LogWarning("error on Change Dictate Game Status by function ");
}
return EFuncRet.Continue;
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List<Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
if (Limit.Oper == (int) ELimitOperator.ELO_Equal)
{
return target[0] is PlayerCharacter;
}
else if (Limit.Oper == (int)ELimitOperator.ELO_NotEuqal)
{
return (!(target[0] is PlayerCharacter));
}
return false;
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List<Ilife> target = Target.GetTarget(EFuncTarget.EFT_User);
if (target == null || target.Count <= 0)
return false;
if (!(target[0] is Npc))
return false;
Npc npc = (Npc)target[0];
return npc.IsPlayerControlled;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
bool newValue = funcdata.ParamIntList[0] != 0;
GestureManager.Instance.SetDictation(newValue);
}
catch (Exception)
{
Debuger.LogWarning("error on Change Dictate Game Status by function ");
}
return(EFuncRet.Continue);
}
public static HandleTarget GetHandleTarget(Ilife userTarget, params Ilife[] targetList)
{
HandleTarget instance = new HandleTarget();
instance.m_lstUser.Add(userTarget);
if (null != targetList)
{
foreach (Ilife Child in targetList)
{
instance.m_lstTarget.Add(Child);
}
}
return instance;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
TerrainManager.Instance.DestroyNpcById(id);
}
catch (Exception)
{
Debuger.LogWarning("error on create npc by function ");
}
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_CHANGE_TO_WORLD_GAME, id));
}
catch (Exception)
{
Debuger.LogWarning("error on Change To WorldGame by function ");
}
return(EFuncRet.Continue);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
TerrainManager.Instance.DestroyNpcById(id);
}
catch (Exception)
{
Debuger.LogWarning("error on create npc by function ");
}
return(EFuncRet.Continue);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List <Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
if (target.Count <= 0)
{
return(false);
}
Vector3 targetPos = ((ITransformBehaviour)(target[0])).GetTransformData().GetPosition();
float distance = Vector3.Distance(PlayerManager.Instance.GetPlayerInstance().GetTransformData().GetPosition(), targetPos);
return(OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, (int)(distance), Limit.ParamIntList[0]));
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List <Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
if (Limit.Oper == (int)ELimitOperator.ELO_Equal)
{
return(target[0] is PlayerCharacter);
}
else if (Limit.Oper == (int)ELimitOperator.ELO_NotEuqal)
{
return(!(target[0] is PlayerCharacter));
}
return(false);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_CHANGE_TO_WORLD_GAME, id));
}
catch (Exception)
{
Debuger.LogWarning("error on Change To WorldGame by function ");
}
return EFuncRet.Continue;
}
public static HandleTarget GetHandleTarget(Ilife userTarget, params Ilife[] targetList)
{
HandleTarget instance = new HandleTarget();
instance.m_lstUser.Add(userTarget);
if (null != targetList)
{
foreach (Ilife Child in targetList)
{
instance.m_lstTarget.Add(Child);
}
}
return(instance);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
List<Ilife> target = Target.GetTarget((EFuncTarget) (funcdata.Target));
for (int i = 0; i < target.Count; ++i)
{
Ilife elem = target[i];
if (!(elem is PlayerCharacter))
{
continue;
}
bool newValue = funcdata.ParamIntList[1] != 0;
PlayerManager.Instance.GetCharCounterData().SetFlag(funcdata.ParamIntList[0], newValue);
}
return EFuncRet.Continue;
}
static public int HandleFuncExec(HandleTarget Target, int iFuncGroupId, FuncContext context)
{
if( null == Target || 0 == iFuncGroupId)
return 0;
FuncGroup funcdataGroup = ConfigManager.Instance.GetFuncGroup( iFuncGroupId );
if( null == funcdataGroup || null == funcdataGroup.FuncDataList )
return 0;
//Exec Func
FuncData ExecData = null;
int iLoop = 0;
for( ; iLoop < funcdataGroup.FuncDataList.Count; ++iLoop )
{
ExecData = funcdataGroup.FuncDataList[iLoop];
if (null == ExecData)
{
continue;
}
FuncMethodsBase func = null;
FuncExec.TryGetValue(ExecData.Id, out func);
//
if (null == func)
{
continue;
}
EFuncRet eRet = func.FuncExecHandler(Target, ExecData,context);
if (EFuncRet.Break == eRet)
{
break;
}
else if (EFuncRet.Error == eRet)
{
UnityEngine.Debug.LogWarning("HandleFuncExec is error, id : " + ExecData.Id.ToString());
}
}
if (iLoop == funcdataGroup.FuncDataList.Count)
{
return -1;
}
return iLoop;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
List<Ilife> target = Target.GetTarget((EFuncTarget)(funcdata.Target));
for (int i = 0; i < target.Count; ++i)
{
Ilife elem = target[i];
if (!(elem is PlayerCharacter))
{
continue;
}
int newValue = 0;
OperationFunc.FuncOperatorValue((EFuncOperator)(funcdata.Oper), ref newValue, funcdata.ParamIntList[1]);
PlayerManager.Instance.GetCharCounterData().SetBit32Count(funcdata.ParamIntList[0], newValue);
}
return EFuncRet.Continue;
}
private void OnHitLife(MessageObject msg)
{
var transform = ((Transform)(msg.msgValue));
if (transform == m_CharTransformData.GetGameObject().transform)
{
// set high light
//m_CharTransformData.SetSelectedStatus(true);
//trigger npc hit function
FuncMethods.HandleFuncExec(HandleTarget.GetHandleTarget(this), m_NpcBaseInfo.ClickFuncId, null);
}
else
{
//IsPlayerControlled = false;
m_CharTransformData.SetSelectedStatus(false);
}
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
List <Ilife> target = Target.GetTarget((EFuncTarget)(funcdata.Target));
for (int i = 0; i < target.Count; ++i)
{
Ilife elem = target[i];
if (!(elem is PlayerCharacter))
{
continue;
}
sbyte newValue = 0;
OperationFunc.FuncOperatorValue((EFuncOperator)(funcdata.Oper), ref newValue, (sbyte)(funcdata.ParamIntList[1]));
PlayerManager.Instance.GetCharCounterData().SetBit8Count(funcdata.ParamIntList[0], newValue);
}
return(EFuncRet.Continue);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List <Ilife> target = Target.GetTarget(EFuncTarget.EFT_User);
if (target == null || target.Count <= 0)
{
return(false);
}
if (!(target[0] is Npc))
{
return(false);
}
Npc npc = (Npc)target[0];
return(npc.IsPlayerControlled);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List<Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
for (int i = 0; i < target.Count; ++i)
{
if (!(target[i] is PlayerCharacter))
{
continue;
}
int index = Limit.ParamIntList[0];
bool flag = PlayerManager.Instance.GetCharCounterData().GetFlag(index);
if (!OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, flag, (Limit.ParamIntList[1] != 0)))
{
return false;
}
}
return true;
}
public void ExecuteExitNodeGame()
{
if (UIWindowSelectScene.m_iIndex != -1)
{
UIWindowSelectScene.OnExitFlightGame();
return;
}
if (m_ProcessData.m_iExitSceneFuncId != 0)
{
HandleTarget target = HandleTarget.GetHandleTarget(PlayerManager.Instance.GetPlayerInstance());
FuncMethods.HandleFuncExec(target, m_ProcessData.m_iExitSceneFuncId, null);
//m_ProcessData.m_iExitSceneFuncId = 0;
}
else
{
StageManager.Instance.ChangeState(GameStateType.SelectSceneState);
}
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
List <Ilife> target = Target.GetTarget((EFuncTarget)(Limit.Target));
for (int i = 0; i < target.Count; ++i)
{
if (!(target[i] is PlayerCharacter))
{
continue;
}
int index = Limit.ParamIntList[0];
bool flag = PlayerManager.Instance.GetCharCounterData().GetFlag(index);
if (!OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, flag, (Limit.ParamIntList[1] != 0)))
{
return(false);
}
}
return(true);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
if (id > 9 && id < 15)
{
PlayerManager.Instance.GetCharCounterData().SetFlag(id, true);
}
else
{
Debuger.LogWarning("error on unlock stage");
}
}
catch (Exception)
{
Debuger.LogWarning("error on unlock stage ");
}
return(EFuncRet.Continue);
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
if (id > 9 && id < 15)
{
PlayerManager.Instance.GetCharCounterData().SetFlag(id, true);
}
else
{
Debuger.LogWarning("error on unlock stage");
}
}
catch (Exception)
{
Debuger.LogWarning("error on unlock stage ");
}
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_CHANGE_TO_NODE_GAME, id));
if(funcdata.ParamIntList.Count > 2)
{
WorldSceneDispatchController.Instance.SetExitFunId(funcdata.ParamIntList[1], funcdata.ParamIntList[2]);
}
else if(funcdata.ParamIntList.Count > 1)
{
WorldSceneDispatchController.Instance.SetExitFunId(funcdata.ParamIntList[1], 0);
}
}
catch (Exception)
{
Debuger.LogWarning("error on Change To NodeGame by function ");
}
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
try
{
int id = funcdata.ParamIntList[0];
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_CHANGE_TO_NODE_GAME, id));
if (funcdata.ParamIntList.Count > 2)
{
WorldSceneDispatchController.Instance.SetExitFunId(funcdata.ParamIntList[1], funcdata.ParamIntList[2]);
}
else if (funcdata.ParamIntList.Count > 1)
{
WorldSceneDispatchController.Instance.SetExitFunId(funcdata.ParamIntList[1], 0);
}
}
catch (Exception)
{
Debuger.LogWarning("error on Change To NodeGame by function ");
}
return(EFuncRet.Continue);
}
private void OnTrigger()
{
//try get target
var param = m_ActionPlayer.GetActionParam();
if (null != param && null != param.Object && param.Object is FuncContext)
{
FuncContext context = param.Object as FuncContext;
if (!context.ContainsKey(FuncContext.ContextKey.LimitId) ||
!context.ContainsKey(FuncContext.ContextKey.FunctionId))
{
return;
}
int limitId = (int)(context.Get(FuncContext.ContextKey.LimitId));
int funcId = (int)(context.Get(FuncContext.ContextKey.LimitId));
HandleTarget target = null;
Ilife user = context.Get(FuncContext.ContextKey.User) as Ilife;
if (context.ContainsKey(FuncContext.ContextKey.Target))
{
//locked skill
target = HandleTarget.GetHandleTarget(user, context.Get(FuncContext.ContextKey.Target) as Ilife);
}
else
{
//target is null,unlocked skill
int targetId = (int)(context.Get(FuncContext.ContextKey.TargetId));
target = TargetMethods.GetTargetList(user, targetId, null);
}
//exec attack
if (LimitMethods.HandleLimitExec(target, limitId, null))
{
FuncMethods.HandleFuncExec(target, funcId, null);
}
}
}
public static HandleTarget GetTargetList(Ilife srcLife, int iTargetGroupId, FuncContext context)
{
HandleTarget handle = HandleTarget.GetHandleTarget(srcLife);
if (iTargetGroupId == 0)
{
return(handle);
}
TargetGroup targetGroup = ConfigManager.Instance.GetTargetGroup(iTargetGroupId);
if (null == targetGroup)
{
Debug.LogError("target groupId:" + iTargetGroupId + " is not found.");
return(handle);
}
if (null == targetGroup.TargetDataList || 0 == targetGroup.TargetDataList.Count)
{
Debug.LogError("target groupId:" + iTargetGroupId + " targetDataList is null.");
return(handle);
}
TargetMethodBase handler = null;
foreach (TargetData data in targetGroup.TargetDataList)
{
if (!TargetExec.TryGetValue(data.TargetId, out handler))
{
continue;
}
List <Ilife> targetUnitList = handler.GetTargetList(srcLife, data, context);
handle.AddTarget(targetUnitList);
}
return(handle);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
return ActionManager.Instance.CheckActionIsPlayed(Limit.ParamIntList[0]);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
int random = Random.Range(0, 100);
return OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, random, Limit.ParamIntList[0]);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
int missionStepCount = MissionManager.Instance.GetMissionStepCounter(Limit.ParamIntList[0]);
return(OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, missionStepCount, Limit.ParamIntList[1]));
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
int missionCount = MissionManager.Instance.GetMissionCounter(Limit.ParamIntList[0]);
return OperationFunc.LimitOperatorValue((ELimitOperator)Limit.Oper, missionCount, Limit.ParamIntList[1]);
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
return(MissionManager.Instance.CheckMissionAvailable(Limit.ParamIntList[0]));
}
public abstract EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata,FuncContext context);
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
MessageDispatcher.Instance.BroadcastMessage(new MessageObject(ClientCustomMessageDefine.C_PLAY_ACTION,funcdata.ParamIntList[0]));
return EFuncRet.Continue;
}
public override EFuncRet FuncExecHandler(HandleTarget Target, FuncData funcdata, FuncContext context)
{
AudioPlayer.Instance.PlayAudio(funcdata.ParamStringList[0], Vector3.zero,false);
return EFuncRet.Continue;
}
public override bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context)
{
return MissionManager.Instance.CheckMissionAvailable(Limit.ParamIntList[0]);
}
public abstract bool LimitExecHandler(HandleTarget Target, LimitData Limit, FuncContext context);
