public override void Leave(AGE.Action _action, Track _track)
{
if (this.actor_ != 0)
{
if (this.IgnoreCollision)
{
bool flag = false;
_action.refParams.GetRefParam("_HitTargetHero", ref flag);
if (!flag)
{
this.SetFinalPos();
}
else
{
VInt3 zero = VInt3.zero;
_action.refParams.GetRefParam("_HitTargetHeroPos", ref zero);
if (!PathfindingUtility.IsValidTarget((ActorRoot)this.actor_, zero))
{
this.SetFinalPos();
}
else
{
this.actor_.handle.location = zero;
}
}
}
this.actor_.handle.ObjLinker.RmvCustomMoveLerp(new CustomMoveLerpFunc(this.ActionMoveLerp));
this.actor_.handle.ActorControl.RmvNoAbilityFlag(ObjAbilityType.ObjAbility_Move);
this.done_ = true;
}
}
public override void Process(AGE.Action _action, Track _track, int _localTime)
{
base.Process(_action, _track, _localTime);
if (this.bInit || !this.bDone)
{
if ((this.srcActor == 0) || (this.targetActor == 0))
{
this.bDone = true;
this.HideBeam();
}
else
{
VInt3 location = this.srcActor.handle.location;
VInt3 num4 = this.targetActor.handle.location - location;
int num3 = num4.magnitude2D;
if (num3 > 0)
{
this.SetBeamLength(num3);
this.RenderBeam();
}
if (this.srcActor.handle.ActorControl.IsDeadState || this.targetActor.handle.ActorControl.IsDeadState)
{
this.bDone = true;
this.HideBeam();
}
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
Vector3 targetPos = this.TargetPos;
GameObject gameObject = _action.GetGameObject(this.destId);
if (gameObject != null)
{
targetPos = gameObject.transform.position;
}
Player hostPlayer = Singleton <GamePlayerCenter> .GetInstance().GetHostPlayer();
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.srcId);
if ((actorHandle == 0) || ((hostPlayer.Captain != 0) && (actorHandle == hostPlayer.Captain)))
{
if (hostPlayer.Captain.handle.ActorControl != null)
{
FrameCommandFactory.CreateFrameCommand <StopMoveCommand>().Send();
FrameCommand <MoveToPosCommand> command2 = FrameCommandFactory.CreateFrameCommand <MoveToPosCommand>();
command2.cmdData.destPosition = (VInt3)targetPos;
command2.Send();
}
}
else if (actorHandle != 0)
{
actorHandle.handle.ActorControl.RealMovePosition((VInt3)targetPos, 0);
}
}
public override void Process(AGE.Action _action, Track _track)
{
Player hostPlayer = Singleton <GamePlayerCenter> .GetInstance().GetHostPlayer();
GameObject gameObject = _action.GetGameObject(this.srcId);
GameObject inDest = _action.GetGameObject(this.destId);
if ((gameObject == null) && (hostPlayer.Captain != 0))
{
gameObject = hostPlayer.Captain.handle.gameObject;
}
if (gameObject != null)
{
if (this.MyPathIndicator == null)
{
this.MyPathIndicator = UnityEngine.Object.FindObjectOfType <PathIndicator>();
}
if (this.MyPathIndicator != null)
{
if (this.bPlay)
{
this.MyPathIndicator.Play(gameObject, inDest, ref this.TargetPos);
}
else
{
this.MyPathIndicator.Stop();
}
}
}
this.MyPathIndicator = null;
}
public override void Enter(AGE.Action _action, Track _track)
{
this.actor_ = _action.GetActorHandle(this.targetId);
if (this.actor_ != 0)
{
MaterialHurtEffect matHurtEffect = this.actor_.handle.MatHurtEffect;
if (matHurtEffect == null)
{
this.actor_.Release();
}
else
{
switch (this.effectType)
{
case MaterialEffectType.Freeze:
this.playingId = matHurtEffect.PlayFreezeEffect();
break;
case MaterialEffectType.Stone:
this.playingId = matHurtEffect.PlayStoneEffect();
break;
case MaterialEffectType.Translucent:
matHurtEffect.SetTranslucent(true);
break;
case MaterialEffectType.HighLit:
matHurtEffect.PlayHighLitEffect(this.highLitColor);
break;
}
}
}
}
public override void Enter(AGE.Action _action, Track _track)
{
base.Enter(_action, _track);
if (this.BubbleTextId > 0)
{
this.actorRootList = new List <PoolObjHandle <ActorRoot> >();
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.srcId);
PoolObjHandle <ActorRoot> item = _action.GetActorHandle(this.targetId);
if (actorHandle != 0)
{
this.actorRootList.Add(actorHandle);
}
if (item != 0)
{
this.actorRootList.Add(item);
}
if (this.PlayerCamp == COM_PLAYERCAMP.COM_PLAYERCAMP_COUNT)
{
this.AddActorRootList(COM_PLAYERCAMP.COM_PLAYERCAMP_1);
this.AddActorRootList(COM_PLAYERCAMP.COM_PLAYERCAMP_2);
}
else
{
this.AddActorRootList(this.PlayerCamp);
}
List <PoolObjHandle <ActorRoot> > .Enumerator enumerator = this.actorRootList.GetEnumerator();
while (enumerator.MoveNext())
{
this.SetHudText(Utility.GetBubbleText((uint)this.BubbleTextId), enumerator.Current);
}
}
}
private void SpawnBullet(AGE.Action _action)
{
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
for (int i = 0; i < this.spawnMax; i++)
{
int index = 0;
VInt3 zero = VInt3.zero;
if (this.transArray.Length < 0)
{
zero = VInt3.zero;
}
else
{
if (this.bRandom)
{
index = FrameRandom.Random((uint)this.transArray.Length);
}
else
{
index = i % this.transArray.Length;
}
zero = this.transArray[index];
}
refParamObject.BulletPos = zero;
PoolObjHandle <BulletSkill> handle = this.skillControl.SpawnBullet(refParamObject, this.ActionName, this.bDeadRemove, this.bAgeImmeExcute);
}
}
public void Process(AGE.Action _action, Track _track, int _localTime)
{
if (this.attackActor != 0)
{
this.hit = false;
this.localTime = _localTime;
if (this.bFirstProcess)
{
this.bFirstProcess = false;
this.HitTrigger(_action);
}
else
{
this.deltaTime += _localTime - this.lastTime;
if (this.deltaTime >= this.triggerInterval)
{
this.HitTrigger(_action);
this.deltaTime -= this.triggerInterval;
}
}
this.lastTime = _localTime;
_action.refParams.SetRefParam("_HitTargetHero", this.bHitTargetHero);
if (this.bHitTargetHero)
{
_action.refParams.SetRefParam("_HitTargetHeroPos", this.HitTargetHeroPos);
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
PoolObjHandle <ActorRoot> handle;
base.Process(_action, _track);
switch (this.ActorType)
{
case enActorType.All:
handle = this.GetActor(Singleton <GameObjMgr> .GetInstance().GameActors, this.configId, this.index);
break;
case enActorType.Hero:
handle = this.GetActor(Singleton <GameObjMgr> .GetInstance().HeroActors, this.configId, this.index);
break;
case enActorType.Soldier:
handle = this.GetActor(Singleton <GameObjMgr> .GetInstance().SoldierActors, this.configId, this.index);
break;
default:
handle = new PoolObjHandle <ActorRoot>();
break;
}
Singleton <BattleSkillHudControl> .GetInstance().AddHighlightForActor(handle, this.bPauseGame);
}
public override void Process(AGE.Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle == 0)
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
if (this.bImmediateRevive)
{
this.bCheckFilter = actorHandle.handle.ActorControl.IsEnableReviveContext();
}
else if (!this.bOnlySelf)
{
this.FilterActorType(actorHandle);
this.FilterActorCamp(actorHandle);
}
else
{
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (((refParamObject == null) || (refParamObject.Originator == 0)) || (refParamObject.Originator.handle.ActorControl == null))
{
object[] inParameters = new object[] { _action.name };
DebugHelper.Assert(false, "Failed find orignal actor of this skill. action:{0}", inParameters);
return;
}
this.bCheckFilter = refParamObject.Originator == actorHandle;
}
base.Process(_action, _track);
}
}
public override void Enter(AGE.Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorObj = _action.GetActorHandle(this.targetId);
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.attackId);
if ((this.actorObj != 0) && (actorHandle != 0))
{
ObjWrapper actorControl = this.actorObj.handle.ActorControl;
if ((actorControl != null) && !actorControl.IsDeadState)
{
actorControl.TerminateMove();
actorControl.ClearMoveCommand();
actorControl.ForceAbortCurUseSkill();
actorControl.SetOutOfControl(true, (OutOfControlType)this.subType);
switch (this.subType)
{
case 0:
actorControl.SetTauntTarget(actorHandle);
break;
case 2:
actorControl.SetTerrorActor(actorHandle);
break;
}
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
this.actor = _action.GetActorHandle(this.targetId);
if (this.actor == 0)
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
ActorRoot handle = this.actor.handle;
if (this.type == ColliderType.Box)
{
VCollisionBox collisionShape = GetCollisionShape <VCollisionBox>(handle, CollisionShapeType.Box);
collisionShape.Pos = this.Pos;
collisionShape.Size = this.Size;
collisionShape.dirty = true;
collisionShape.ConditionalUpdateShape();
}
else if (this.type == ColliderType.Sphere)
{
VCollisionSphere sphere = GetCollisionShape <VCollisionSphere>(handle, CollisionShapeType.Sphere);
sphere.Pos = this.Pos;
sphere.Radius = this.Radius;
sphere.dirty = true;
sphere.ConditionalUpdateShape();
}
}
}
public override void Enter(AGE.Action _action, Track _track)
{
if (!Singleton <BattleLogic> .GetInstance().IsModifyingCamera&& this.ShouldShake(_action))
{
if (this.useMainCamera && (Camera.main != null))
{
this.targetObject = Camera.main.gameObject;
}
else
{
this.targetObject = _action.GetGameObject(this.targetId);
}
if ((this.targetObject == null) || (this.targetObject.transform == null))
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
Singleton <BattleLogic> .GetInstance().IsModifyingCamera = true;
this.enterShaking = true;
this.originPos = this.targetObject.transform.localPosition;
this.shock = this.shakeRange;
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
if (Singleton <BattleLogic> .GetInstance().mapLogic != null)
{
Singleton <BattleLogic> .GetInstance().mapLogic.ResetSoldierRegion();
}
}
public override void Process(AGE.Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.targetId);
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
Singleton <CSoundManager> .instance.PlayBattleSound(this.eventName, actorHandle, gameObject);
}
public override void Process(AGE.Action _action, Track _track, int _localTime)
{
if (!this.switchFinished && (this.curCamera != null))
{
if (_localTime >= this.slerpTick)
{
if (this.isMoba_camera)
{
this.curCamera.transform.position = this.curCamera.transform.parent.position;
this.curCamera.transform.rotation = this.curCamera.transform.parent.rotation;
}
else
{
this.curCamera.transform.position = this.destPos;
this.curCamera.transform.rotation = this.destRot;
}
this.switchFinished = true;
}
else if (this.isMoba_camera)
{
this.curCamera.transform.position = Vector3.Lerp(this.startPos, this.curCamera.transform.parent.position, ((float)_localTime) / ((float)this.slerpTick));
this.curCamera.transform.rotation = Quaternion.Slerp(this.startRot, this.curCamera.transform.parent.rotation, ((float)_localTime) / ((float)this.slerpTick));
}
else
{
this.curCamera.transform.position = Vector3.Lerp(this.startPos, this.destPos, ((float)_localTime) / ((float)this.slerpTick));
this.curCamera.transform.rotation = Quaternion.Slerp(this.startRot, this.destRot, ((float)_localTime) / ((float)this.slerpTick));
}
base.Process(_action, _track, _localTime);
}
}
public override void Enter(AGE.Action _action, Track _track)
{
base.Enter(_action, _track);
this.actorObj = _action.GetActorHandle(this.targetId);
this.SetMeshScale(this.scaleRate);
this.SetCollisionScale(this.scaleRate);
}
public override void OnRelease()
{
this.playSpeedOnPause = VFactor.zero;
this.deltaTime = 0;
this.started_ = false;
this.nextDestroy = false;
this.enabled = true;
this.name = string.Empty;
this.length = 0x1388;
this.loop = false;
this.playSpeed = VFactor.one;
this.unstoppable = false;
this.actionName = string.Empty;
this.refGameObjectsCount = -1;
this.time = 0;
this.parentAction = null;
this.actorHandles.Clear();
this.gameObjects.Clear();
this.tracks.Clear();
this.conditions.Clear();
this.conditionChanged = true;
this.refParams.Reset();
this.refParamsSrc = null;
this.templateObjectIds.Clear();
this.tempObjsAffectedByPlaySpeed.Clear();
this.onActionStop = (ActionStopDelegate)Delegate.RemoveAll(this.onActionStop, this.onActionStop);
}
public override void Process(AGE.Action _action, Track _track)
{
GameObject obj2 = (Singleton <CBattleSystem> .GetInstance().FightFormScript == null) ? null : Singleton <CBattleSystem> .GetInstance().FightFormScript.gameObject;
if (obj2 != null)
{
GameObject gameObject = obj2.transform.FindChild("Joystick").gameObject;
bool bActive = !this.bForbid;
CUIJoystickScript component = gameObject.GetComponent <CUIJoystickScript>();
if (component != null)
{
component.ResetAxis();
}
gameObject.CustomSetActive(bActive);
component = gameObject.GetComponent <CUIJoystickScript>();
if (component != null)
{
component.ResetAxis();
}
if ((this.bForbid && (Singleton <CBattleSystem> .GetInstance().FightForm != null)) && (Singleton <CBattleSystem> .GetInstance().FightForm.m_skillButtonManager != null))
{
for (int i = 0; i < 5; i++)
{
Vector2 screenPosition = new Vector2();
Singleton <CBattleSystem> .GetInstance().FightForm.m_skillButtonManager.SkillButtonUp(Singleton <CBattleSystem> .GetInstance().FightFormScript, (SkillSlotType)i, false, screenPosition);
}
}
}
}
public Quaternion GetRotation(AGE.Action _action)
{
if (_action.GetGameObject(this.targetId) != null)
{
this.SetCurrentTransform(_action.GetGameObject(this.targetId).transform);
}
GameObject gameObject = _action.GetGameObject(this.fromId);
GameObject obj3 = _action.GetGameObject(this.toId);
if ((gameObject != null) && (obj3 != null))
{
Vector3 vector = obj3.transform.position - gameObject.transform.position;
return(Quaternion.LookRotation(Vector3.Normalize(new Vector3(vector.x * axisWeight.x, vector.y * axisWeight.y, vector.z * axisWeight.z)), Vector3.up) * this.rotation);
}
GameObject obj4 = _action.GetGameObject(this.objectSpaceId);
if (obj4 != null)
{
return(obj4.transform.rotation * this.rotation);
}
GameObject obj5 = _action.GetGameObject(this.targetId);
if ((obj5 != null) && (obj5.transform.parent != null))
{
return(obj5.transform.parent.rotation * this.rotation);
}
return(this.rotation);
}
public override void Enter(AGE.Action _action, Track _track)
{
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (actorHandle == 0)
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
this.skillControl = actorHandle.handle.SkillControl;
if (this.skillControl == null)
{
if (ActionManager.Instance.isPrintLog)
{
}
}
else
{
this.SpawnBullet(_action);
}
}
}
public int HasDependObject(AGE.Action _action)
{
if ((this.currentTranslation || this.currentRotation) || this.currentScaling)
{
return(1);
}
if (this.fromId >= 0)
{
if (_action.GetGameObject(this.fromId) != null)
{
return(1);
}
return(-1);
}
if (this.toId >= 0)
{
if (_action.GetGameObject(this.toId) != null)
{
return(1);
}
return(-1);
}
if (this.objectSpaceId < 0)
{
return(0);
}
if (_action.GetGameObject(this.objectSpaceId) != null)
{
return(1);
}
return(-1);
}
public override void Leave(AGE.Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.targetId);
if ((gameObject != null) && (base.length != 0))
{
GameObject actorMesh = gameObject;
PoolObjHandle <ActorRoot> actorHandle = _action.GetActorHandle(this.targetId);
if (this.GetAnimation(gameObject) == null)
{
if (actorHandle != 0)
{
actorMesh = actorHandle.handle.ActorMesh;
}
else
{
actorMesh = null;
}
}
if (actorMesh != null)
{
if (actorHandle != 0)
{
actorHandle.handle.AnimControl.Stop(this.clipName, this.playNextAnim);
}
else
{
this.GetAnimation(actorMesh)[this.clipName].enabled = false;
}
}
}
}
public override void ProcessBlend(AGE.Action _action, Track _track, TickEvent _prevEvent, float _blendWeight)
{
if ((_action.GetGameObject(this.targetId) != null) && (_prevEvent != null))
{
if (this.enableTranslation)
{
if (this.cubic)
{
this.CubicVectorBlend(_action, _track, _prevEvent, _blendWeight, true);
}
else
{
_action.GetGameObject(this.targetId).transform.position = (Vector3)((this.GetTranslation(_action) * _blendWeight) + ((_prevEvent as ModifyTransform).GetTranslation(_action) * (1f - _blendWeight)));
}
}
if (this.enableRotation)
{
_action.GetGameObject(this.targetId).transform.rotation = Quaternion.Slerp((_prevEvent as ModifyTransform).GetRotation(_action), this.GetRotation(_action), _blendWeight);
}
if (this.enableScaling)
{
if (this.cubic)
{
this.CubicVectorBlend(_action, _track, _prevEvent, _blendWeight, false);
}
else
{
_action.GetGameObject(this.targetId).transform.localScale = (Vector3)((this.scaling * _blendWeight) + ((_prevEvent as ModifyTransform).scaling * (1f - _blendWeight)));
}
}
}
}
public override void Leave(AGE.Action _action, Track _track)
{
if (this.actor_ != 0)
{
MaterialHurtEffect matHurtEffect = this.actor_.handle.MatHurtEffect;
if (matHurtEffect != null)
{
switch (this.effectType)
{
case MaterialEffectType.Freeze:
matHurtEffect.StopFreezeEffect(this.playingId);
break;
case MaterialEffectType.Stone:
matHurtEffect.StopStoneEffect(this.playingId);
break;
case MaterialEffectType.Translucent:
matHurtEffect.SetTranslucent(false);
break;
case MaterialEffectType.HighLit:
matHurtEffect.StopHighLitEffect();
break;
}
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
base.Process(_action, _track);
if (this.NewbieTriggerType > 0)
{
if (this.bCurrentGuideOver)
{
if (this.bWeakGuide)
{
MonoSingleton <NewbieGuideManager> .GetInstance().ForceCompleteWeakGuide();
}
else
{
MonoSingleton <NewbieGuideManager> .GetInstance().ForceCompleteNewbieGuide();
}
}
else if (this.bWeakGuide)
{
MonoSingleton <NewbieGuideManager> .GetInstance().CheckWeakGuideTrigger((NewbieGuideWeakGuideType)this.NewbieTriggerType, new uint[0]);
}
else
{
MonoSingleton <NewbieGuideManager> .GetInstance().CheckTriggerTime((NewbieGuideTriggerTimeType)this.NewbieTriggerType, new uint[0]);
}
}
}
private bool Init(AGE.Action _action)
{
this.srcActor = _action.GetActorHandle(this.sourceId);
this.targetActor = _action.GetActorHandle(this.targetId);
if ((this.srcActor == 0) || (this.targetActor == 0))
{
return(false);
}
Vector3 srcPosition = this.GetSrcPosition();
Quaternion rot = Quaternion.LookRotation((Vector3)this.targetActor.handle.forward);
bool isInit = false;
this.beamObject = MonoSingleton <SceneMgr> .GetInstance().GetPooledGameObjLOD(this.resourceName, true, SceneObjType.ActionRes, srcPosition, rot, out isInit);
if (this.beamObject == null)
{
return(false);
}
this.lineRenderer = this.beamObject.gameObject.GetComponentInChildren <LineRenderer>();
if (this.lineRenderer == null)
{
return(false);
}
this.lineRenderer.SetWidth(this.beamWidth, this.beamWidth);
return(true);
}
public override void Leave(AGE.Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.srcId);
GameObject obj3 = _action.GetGameObject(this.atkerId);
base.Leave(_action, _track);
}
public override void Process(AGE.Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.targetId);
if (gameObject == null)
{
Debug.LogWarning("not find setting layer/tag target object");
}
else
{
if (this.enableLayer)
{
gameObject.layer = this.layer;
Transform[] componentsInChildren = gameObject.GetComponentsInChildren <Transform>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].gameObject.layer = this.layer;
}
}
if (this.enableTag)
{
gameObject.tag = this.tag;
Transform[] transformArray2 = gameObject.GetComponentsInChildren <Transform>();
for (int j = 0; j < transformArray2.Length; j++)
{
transformArray2[j].gameObject.tag = this.tag;
}
}
}
}
public override void Process(AGE.Action _action, Track _track)
{
GameObject gameObject = _action.GetGameObject(this.parentId);
if (gameObject != null)
{
GameObject go = _action.GetGameObject(this.targetId);
if (this.isGetByName)
{
Transform[] componentsInChildren = gameObject.GetComponentsInChildren <Transform>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (componentsInChildren[i].gameObject.name == this.subObjectName)
{
go = componentsInChildren[i].gameObject;
break;
}
}
}
else if (gameObject.transform.childCount > 0)
{
go = gameObject.transform.GetChild(0).gameObject;
}
_action.SetGameObject(this.targetId, go);
}
}
