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; } } }