public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.eventSrcId);
PoolObjHandle <ActorRoot> myLastAtker = _action.GetActorHandle(this.eventAtkerId);
if ((myLastAtker == 0) && (actorHandle != 0))
{
myLastAtker = actorHandle.handle.ActorControl.myLastAtker;
}
DefaultGameEventParam prm = new DefaultGameEventParam(actorHandle, myLastAtker);
if (this.eventType == GameEventDef.Event_GameEnd)
{
Singleton <GameEventSys> .instance.PostEvent <DefaultGameEventParam>(this.eventType, ref prm);
}
else
{
Singleton <GameEventSys> .instance.SendEvent <DefaultGameEventParam>(this.eventType, ref prm);
}
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorObj = _action.GetActorHandle(this.targetId);
if (!this.actorObj)
{
return;
}
this.actorObjID = this.actorObj.handle.ObjID;
MiniMapTrack_3DUI.Prepare(this.actorObj, this.iconPath);
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
this.targetActor = _action.GetActorHandle(this.targetID);
this.bFirstTrigger = true;
this.iLastTime = 0;
this.iLocalTime = 0;
this.iTriggerCount = 0;
this.context = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
Singleton <GameEventSys> .get_instance().AddEventHandler <HurtEventResultInfo>(GameEventDef.Event_ActorDamage, new RefAction <HurtEventResultInfo>(this.OnActorDamage));
}
private void InitContext(Action _action)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(1);
PoolObjHandle <ActorRoot> actorHandle2 = _action.GetActorHandle(0);
if (!actorHandle || !actorHandle2)
{
return;
}
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
BuffSkill refParamObject2 = _action.refParams.GetRefParamObject <BuffSkill>("SkillObj");
ResDT_SkillFunc inSkillFunc = null;
if (refParamObject2 != null && refParamObject2.FindSkillFunc(this.SkillFuncType, out inSkillFunc))
{
this.m_context.inTargetObj = actorHandle;
this.m_context.inOriginator = actorHandle2;
this.m_context.inUseContext = refParamObject;
this.m_context.inSkillFunc = inSkillFunc;
this.m_context.LocalParams = new SSkillFuncIntParam[8];
for (int i = 0; i < 8; i++)
{
this.m_context.LocalParams[i] = default(SSkillFuncIntParam);
this.m_context.LocalParams[i].iParam = 0;
}
this.m_context.inAction = new PoolObjHandle <Action>(_action);
this.m_context.inBuffSkill = new PoolObjHandle <BuffSkill>(refParamObject2);
this.m_context.inDoCount = 0;
this.m_context.inOverlayCount = refParamObject2.GetOverlayCount();
this.m_context.inLastEffect = true;
if (refParamObject != null)
{
this.m_context.inEffectCount = refParamObject.EffectCount;
this.m_context.inEffectCountInSingleTrigger = refParamObject.EffectCountInSingleTrigger;
this.m_context.inMarkCount = refParamObject.MarkCount;
}
this.m_context.InitSkillFuncContext();
refParamObject2.SetBuffLevel(this.m_context.iSkillLevel);
this.bInit = true;
}
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (!actorHandle)
{
return;
}
this.nextSkillObj = _action.GetActorHandle(this.nextSkillTargetID);
if (!this.nextSkillObj)
{
return;
}
SkillSlot skillSlot = actorHandle.handle.SkillControl.GetSkillSlot(this.slotType);
if (skillSlot != null && this.nextSkillTargetID > 0 && skillSlot.NextSkillTargetIDs.IndexOf(this.nextSkillObj.handle.ObjID) < 0)
{
skillSlot.NextSkillTargetIDs.Add(this.nextSkillObj.handle.ObjID);
}
}
private void Init(Action _action, Track _track)
{
this.actorHandle = _action.GetActorHandle(this.targetId);
if (this.actorHandle == 0)
{
this.isDone = true;
}
else if (!this.bOnlyRecover)
{
this.actorHandle.handle.AnimControl.ChangeAnimParam(this.originalAnimName, this.changedAnimName);
}
}
public void Enter(Action _action, Track _track)
{
this.hit = false;
this.collideCountMap.Clear();
this.collideTimeMap.Clear();
this.type_Filters = new bool[] { this.bFilterHero, this.bFileterMonter, this.bFileterOrgan };
this.type_actorList = new List <PoolObjHandle <ActorRoot> >[] { this.triggerHeroList, this.triggerMonsterList, this.triggerOrganList };
this.triggerActor = _action.GetActorHandle(this.triggerId);
if (this.bUseTriggerObj)
{
if (this.triggerActor == 0)
{
return;
}
if (AGE_Helper.GetCollisionShape(this.triggerActor.handle) == null)
{
return;
}
}
this.attackActor = _action.GetActorHandle(this.attackerId);
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorObj = _action.GetActorHandle(this.targetId);
if (!this.actorObj)
{
return;
}
if (ActorHelper.IsHostCampActor(ref this.actorObj))
{
BackCityCom_3DUI.ShowBack2City(this.actorObj);
}
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.TargetId);
if (!actorHandle)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
Singleton <GameObjMgr> .instance.DestroyActor(actorHandle.handle.ObjID);
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle != 0)
{
SkillComponent skillControl = actorHandle.handle.SkillControl;
if ((skillControl != null) && (skillControl.SkillUseCache != null))
{
skillControl.SkillUseCache.UseSkillCache(actorHandle);
}
}
}
private void Init(Action _action)
{
this.moveActor = _action.GetActorHandle(this.targetId);
if (this.moveActor == 0)
{
this.stopCondtion = true;
}
else
{
this.tarActor = _action.GetActorHandle(this.destId);
this.attackActor = _action.GetActorHandle(this.attackId);
if ((this.tarActor == 0) || (this.attackActor == 0))
{
this.stopCondtion = true;
}
else
{
this.gravityControler = new AccelerateMotionControler();
this.moveActor.handle.ObjLinker.AddCustomMoveLerp(new CustomMoveLerpFunc(this.ActionMoveLerp));
}
}
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorTarget = _action.GetActorHandle(this.targetId);
this.lastTime = 0;
if (!this.actorTarget)
{
return;
}
this.bNeedRotate = false;
this.curRotateSpd = 0;
this.actorTarget.get_handle().ObjLinker.AddCustomRotateLerp(new CustomRotateLerpFunc(this.ActionRotateLerp));
}
private List <PoolObjHandle <ActorRoot> > FilterTargetByTriggerRegion(Action _action, PoolObjHandle <ActorRoot> _attackActor, BaseSkill _skill)
{
if (!_attackActor || _skill == null)
{
return(null);
}
HitTriggerTick.targetActors.Clear();
if (this.bFindTargetByRotateBodyBullet)
{
PoolObjHandle <ActorRoot> poolObjHandle = default(PoolObjHandle <ActorRoot>);
_action.refParams.GetRefParam("FindEnemyActor", ref poolObjHandle);
if (poolObjHandle)
{
HitTriggerTick.targetActors.Add(poolObjHandle);
}
return(HitTriggerTick.targetActors);
}
PoolObjHandle <ActorRoot> targetActor = _skill.GetTargetActor();
if (targetActor && !targetActor.handle.ActorControl.IsDeadState)
{
HitTriggerTick.targetActors.Add(targetActor);
}
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.triggerId);
if (!actorHandle)
{
return(HitTriggerTick.targetActors);
}
this.shape = AGE_Helper.GetCollisionShape(actorHandle);
if (this.shape != null)
{
Singleton <TargetSearcher> .instance.BeginCollidedActorList(_attackActor, this.shape, false, true, null, this.bCheckSight);
List <PoolObjHandle <ActorRoot> > collidedActors = Singleton <TargetSearcher> .instance.GetCollidedActors();
if (collidedActors != null && collidedActors.get_Count() > 0)
{
List <PoolObjHandle <ActorRoot> > .Enumerator enumerator = collidedActors.GetEnumerator();
while (enumerator.MoveNext())
{
if (HitTriggerTick.targetActors.IndexOf(enumerator.get_Current()) == -1)
{
HitTriggerTick.targetActors.Add(enumerator.get_Current());
}
}
}
Singleton <TargetSearcher> .instance.EndCollidedActorList();
}
return(HitTriggerTick.targetActors);
}
public override void Process(Action _action, Track _track)
{
this.tarActor = _action.GetActorHandle(this.TargetId);
if (!this.tarActor)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
this.wayPoint = _action.GetGameObject(this.WayPointId);
this.SpawnMonster(_action);
this.tarActor.Release();
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.TargetId);
if (!actorHandle)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
this.wayPoint = _action.GetGameObject(this.WayPointId);
this.SpawnMonster(_action, ref actorHandle);
}
private void Init(Action _action, Track _track)
{
this.actor_ = _action.GetActorHandle(this.attackerId);
if (!this.actor_)
{
this.done_ = true;
return;
}
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (refParamObject == null)
{
this.done_ = true;
return;
}
VInt3 vInt;
if (!refParamObject.CalcAttackerDir(out vInt, this.actor_))
{
this.done_ = true;
return;
}
if (vInt == VInt3.zero)
{
return;
}
if (this.actor_.handle.MovementComponent == null)
{
return;
}
this.bRotate = true;
this.actor_.handle.MovementComponent.SetRotate(vInt, true);
this.actor_.handle.ActorControl.AddNoAbilityFlag(ObjAbilityType.ObjAbility_MoveRotate);
this.fromRot = this.actor_.handle.rotation;
this.toRot = Quaternion.LookRotation((Vector3)vInt);
if (this.length <= 30)
{
this.actor_.handle.rotation = this.toRot;
this.done_ = true;
return;
}
float num = Quaternion.Angle(this.fromRot, this.toRot);
if (num > 180.1f)
{
DebugHelper.Assert(num <= 180.1f);
}
this.rotTime_ = Mathf.FloorToInt(num * (float)this.length / 180f);
DebugHelper.Assert(this.rotTime_ <= this.length);
}
public override void Process(Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.targetId);
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (this.ShouldUseNormal(_action, _track, ref actorHandle))
{
Singleton <CSoundManager> .instance.PlayBattleSound(this.eventName, actorHandle, gameObject);
}
else
{
Singleton <CSoundManager> .instance.PlayBattleSound(this.CachedEventName, actorHandle, gameObject);
}
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.sourceId);
if (!actorHandle)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
PoolObjHandle <ActorRoot> actorHandle2 = _action.GetActorHandle(this.targetId);
if (!actorHandle2)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
this.CheckTransmitShowParticalDistance(ref actorHandle, ref actorHandle2);
base.Process(_action, _track);
}
public override void Leave(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (!actorHandle)
{
return;
}
this.switchFinished = true;
this.ChangeMesh(ref actorHandle, this.actorMesh);
this.actorMesh.CustomSetActive(true);
this.actorMesh = null;
base.Leave(_action, _track);
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(1);
PoolObjHandle <ActorRoot> handle2 = _action.GetActorHandle(0);
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
BuffSkill skill = _action.refParams.GetRefParamObject <BuffSkill>("SkillObj");
ResDT_SkillFunc outSkillFunc = null;
if ((skill != null) && skill.FindSkillFunc((int)this.SkillFuncType, out outSkillFunc))
{
SSkillFuncContext inContext = new SSkillFuncContext {
inTargetObj = actorHandle,
inOriginator = handle2,
inUseContext = refParamObject,
inSkillFunc = outSkillFunc,
inStage = ESkillFuncStage.Enter,
inAction = _action,
inBuffSkill = new PoolObjHandle <BuffSkill>(skill),
inSkillLevel = 1,
inOverlayCount = skill.GetOverlayCount(),
inLastEffect = false
};
inContext.InitSkillFuncContext();
inContext.LocalParams = new ResDT_IntParamArrayNode[6];
for (int i = 0; i < 6; i++)
{
inContext.LocalParams[i] = new ResDT_IntParamArrayNode();
inContext.LocalParams[i].iParam = 0;
}
if (!Singleton <BattleLogic> .GetInstance().isRuning || Singleton <BattleLogic> .GetInstance().isGameOver)
{
return;
}
this.m_bSucceeded = Singleton <SkillFuncDelegator> .GetInstance().DoSkillFunc((int)this.SkillFuncType, ref inContext);
}
base.Process(_action, _track);
}
private List <PoolObjHandle <ActorRoot> > FilterTargetByTriggerRegion(Action _action, PoolObjHandle <ActorRoot> _attackActor, BaseSkill _skill)
{
if ((_attackActor == 0) || (_skill == null))
{
return(null);
}
List <PoolObjHandle <ActorRoot> > list = null;
PoolObjHandle <ActorRoot> targetActor = _skill.GetTargetActor();
if ((targetActor != 0) && !targetActor.handle.ActorControl.IsDeadState)
{
if (list == null)
{
list = new List <PoolObjHandle <ActorRoot> >();
}
list.Add(targetActor);
}
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.triggerId);
if (actorHandle != 0)
{
this.shape = AGE_Helper.GetCollisionShape((ActorRoot)actorHandle);
if (this.shape == null)
{
return(list);
}
Singleton <TargetSearcher> .instance.BeginCollidedActorList(_attackActor, this.shape, false, true, null);
List <PoolObjHandle <ActorRoot> > collidedActors = Singleton <TargetSearcher> .instance.GetCollidedActors();
if ((collidedActors != null) && (collidedActors.Count > 0))
{
if (list == null)
{
list = new List <PoolObjHandle <ActorRoot> >();
}
List <PoolObjHandle <ActorRoot> > .Enumerator enumerator = collidedActors.GetEnumerator();
while (enumerator.MoveNext())
{
if (list.IndexOf(enumerator.Current) == -1)
{
list.Add(enumerator.Current);
}
}
}
Singleton <TargetSearcher> .instance.EndCollidedActorList();
}
return(list);
}
public override void Leave(Action _action, Track _track)
{
MinimapSys theMinimapSys = Singleton <CBattleSystem> .instance.TheMinimapSys;
if (theMinimapSys == null || theMinimapSys.miniMapEffectModule == null)
{
return;
}
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle)
{
theMinimapSys.miniMapEffectModule.StopFollowActorEffect(actorHandle);
}
}
public override void Enter(Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorObj = _action.GetActorHandle(this.targetId);
this.starTime = Singleton <FrameSynchr> .GetInstance().LogicFrameTick;
this.totalTime = this.length;
if (!this.actorObj || this.totalTime <= 0)
{
return;
}
SkillTimerEventParam skillTimerEventParam = new SkillTimerEventParam(this.totalTime, this.starTime, this.actorObj);
Singleton <GameSkillEventSys> .GetInstance().SendEvent <SkillTimerEventParam>(GameSkillEventDef.AllEvent_SetSkillTimer, this.actorObj, ref skillTimerEventParam, GameSkillEventChannel.Channel_AllActor);
}
public override void Enter(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (!actorHandle)
{
return;
}
this.switchFinished = false;
this.actorMesh = actorHandle.get_handle().ActorMesh;
this.actorMesh.CustomSetActive(false);
GameObject pooledGameObjLOD = MonoSingleton <SceneMgr> .GetInstance().GetPooledGameObjLOD(this.prefabName, false, SceneObjType.ActionRes, Vector3.zero);
this.ChangeMesh(ref actorHandle, pooledGameObjLOD);
base.Enter(_action, _track);
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle == 0)
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
this.FilterActorType(actorHandle);
this.FilterActorCamp(actorHandle);
base.Process(_action, _track);
}
}
private void Init(Action _action, Track _track)
{
this.actor_ = _action.GetActorHandle(this.attackerId);
if (this.actor_ == 0)
{
this.done_ = true;
}
else
{
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (refParamObject == null)
{
this.done_ = true;
}
else
{
VInt3 num;
if (!refParamObject.CalcAttackerDir(out num, this.actor_))
{
this.done_ = true;
}
else if ((num != VInt3.zero) && (this.actor_.handle.MovementComponent != null))
{
this.actor_.handle.MovementComponent.SetRotate(num, true);
this.actor_.handle.ActorControl.AddNoAbilityFlag(ObjAbilityType.ObjAbility_MoveRotate);
this.fromRot = this.actor_.handle.rotation;
this.toRot = Quaternion.LookRotation((Vector3)num);
if (base.length <= 30)
{
this.actor_.handle.rotation = this.toRot;
this.done_ = true;
}
else
{
float num2 = Quaternion.Angle(this.fromRot, this.toRot);
if (num2 > 180.1f)
{
DebugHelper.Assert(num2 <= 180.1f);
}
this.rotTime_ = Mathf.FloorToInt((num2 * base.length) / 180f);
DebugHelper.Assert(this.rotTime_ <= base.length);
}
}
}
}
}
public override void Process(Action _action, Track _track, int _localTime)
{
if (this.done)
{
return;
}
if (!this.targetActor || this.targetActor.handle.ActorControl.IsDeadState)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.AttackerID);
if (actorHandle && actorHandle.handle.SkillControl != null)
{
actorHandle.handle.SkillControl.ForceAbortCurUseSkill();
}
this.done = true;
}
base.Process(_action, _track, _localTime);
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (!actorHandle)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
SkillComponent skillControl = actorHandle.get_handle().SkillControl;
if (skillControl == null)
{
if (ActionManager.Instance.isPrintLog)
{
}
return;
}
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (refParamObject != null)
{
refParamObject.BulletPos = refParamObject.UseVector;
SkillRangeAppointType appointType = refParamObject.AppointType;
if (this.bSpawnBounceBullet)
{
appointType = refParamObject.AppointType;
refParamObject.AppointType = 1;
}
if (!refParamObject.bSpecialUse)
{
if (this.ActionName != string.Empty)
{
skillControl.SpawnBullet(refParamObject, this.ActionName, this.bDeadRemove, this.bAgeImmeExcute, this.bulletTypeId, this.bulletUpperLimit);
}
}
else if (this.SpecialActionName != string.Empty)
{
skillControl.SpawnBullet(refParamObject, this.SpecialActionName, this.bDeadRemove, this.bAgeImmeExcute, this.bulletTypeId, this.bulletUpperLimit);
}
refParamObject.AppointType = appointType;
}
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle != 0)
{
GameObject inActorMesh = MonoSingleton <SceneMgr> .GetInstance().GetPooledGameObjLOD(this.prefabName, false, SceneObjType.ActionRes, Vector3.zero);
if (inActorMesh != null)
{
Transform transform = inActorMesh.transform;
transform.SetParent(actorHandle.handle.gameObject.transform);
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
actorHandle.handle.SetActorMesh(inActorMesh);
}
}
}
public override void Process(Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
BaseSkill refParamObject = _action.refParams.GetRefParamObject <BaseSkill>("SkillObj");
if (refParamObject != null)
{
BulletSkill bulletSkill = refParamObject as BulletSkill;
if (bulletSkill != null)
{
if (this.bIgnoreLimit)
{
bulletSkill.IgnoreUpperLimit();
}
bulletSkill.lifeTime = this.iLifeTime;
}
}
}
