protected override void InitBulletForward(AbilityTriggerBullet bullet) { int num = this._traceBullets.SeekAddPosition <TraceDelay>(); Vector3 position = new Vector3(UnityEngine.Random.Range(-this.config.RandomPosX, this.config.RandomPosX), UnityEngine.Random.Range(-this.config.RandomPosY, this.config.RandomPosY), UnityEngine.Random.Range(-this.config.RandomPosZ, this.config.RandomPosZ)); Transform transform = bullet.triggerBullet.transform; transform.position += bullet.triggerBullet.transform.TransformPoint(position) - bullet.triggerBullet.transform.localPosition; Transform transform2 = bullet.triggerBullet.transform; transform2.localRotation *= Quaternion.Euler(10f, 0f, UnityEngine.Random.Range(-2, 3) * 10f); this._offsetAngle += 1.795196f; Vector3 vector2 = new Vector3(this.config.TargetOffset * Mathf.Sin(this._offsetAngle), 0f, this.config.TargetOffset * Mathf.Cos(this._offsetAngle)); TraceDelay delay = new TraceDelay { bulletID = bullet.runtimeID, holdTimer = this.config.HoldTime, lifeTimer = this.config.LifeTime, startPos = bullet.triggerBullet.transform.position, dummyPos = bullet.triggerBullet.transform.position, targetOffset = vector2 }; this._traceBullets[num] = delay; if (this._attackTarget != null) { this._traceBullets[num].dummyPos = this._attackTarget.transform.position; } }
protected override void InitBulletForwardWithArgument(AbilityTriggerBullet bullet, HitExplodeTracingBulletMixinArgument arg, uint otherID) { base.InitBulletForwardWithArgument(bullet, arg, otherID); if (this.config.IsRandomInit) { if (this.config.IsRandomInitCone) { bullet.triggerBullet.transform.forward = (Vector3)((Quaternion.AngleAxis((float)UnityEngine.Random.Range(-40, 40), base.entity.transform.up) * Quaternion.AngleAxis((float)-UnityEngine.Random.Range(-10, 40), base.entity.transform.right)) * base.entity.transform.forward); } else { bullet.triggerBullet.transform.forward = (Vector3)(Quaternion.AngleAxis((float)-UnityEngine.Random.Range(20, 0x2d), base.entity.transform.right) * base.entity.transform.forward); } } BaseMonoEntity entity = null; if (otherID != 0) { entity = Singleton <EventManager> .Instance.GetEntity(otherID); } int num = this._traceBullets.SeekAddPosition <TraceDelay>(); TraceDelay delay = new TraceDelay { lineTimer = this.config.TurnStartDelay, turnTimer = this.config.TraceStartDelay, bulletID = bullet.runtimeID, subAttackTarget = entity }; this._traceBullets[num] = delay; }
private void InitBulletPosAndForward(AbilityTriggerBullet bullet, out Vector3 startPos) { Vector3 forward; Vector3 zero = Vector3.zero; if (this.config.RandomPosPool.Length > 0) { this.randPosIx = ((this.randPosIx + 1) != this.config.RandomPosPool.Length) ? (this.randPosIx + 1) : 0; float[] numArray = this.config.RandomPosPool[this._posIndexOrderList[this.randPosIx]]; zero = new Vector3(numArray[0], numArray[1], numArray[2]); } startPos = bullet.triggerBullet.transform.TransformPoint(zero) - bullet.triggerBullet.transform.localPosition; Transform transform = bullet.triggerBullet.transform; transform.position += startPos; BaseMonoEntity entity = this._attackTarget; if ((entity == null) || !this.config.FaceTarget) { forward = base.entity.transform.forward; } else { forward = entity.GetAttachPoint("RootNode").position - bullet.triggerBullet.transform.position; } bullet.triggerBullet.transform.forward = forward; if (this.config.BackDistance > 0f) { Transform transform2 = bullet.triggerBullet.transform; transform2.position += (Vector3)(forward.normalized * this.config.BackDistance); } }
private void InitBulletDirAndPos(AbilityTriggerBullet bullet, Vector3 foward) { int num = this._traceBullets.SeekAddPosition <TraceDelay>(); bullet.triggerBullet.transform.forward = foward; bullet.triggerBullet.SetCollisionEnabled(false); TraceDelay delay = new TraceDelay { bulletID = bullet.runtimeID, delayTime = this.config.DelayTime, tarPos = bullet.triggerBullet.transform.position + ((Vector3)((foward * this.config.Offset) * UnityEngine.Random.value)), SpeedY = 0f, isTriggered = false, isStuck = false, hitGroundTime = 0 }; this._traceBullets[num] = delay; float speed = base.actor.Evaluate(this.config.BulletSpeed); float num3 = Vector3.Distance(this._traceBullets[num].tarPos, bullet.triggerBullet.transform.position); float y = bullet.triggerBullet.transform.position.y; float gravity = this.config.Gravity; while (num3 < ((1f * Mathf.Sqrt((2f * y) / gravity)) * speed)) { bullet.triggerBullet.speed *= 0.8f; speed = bullet.triggerBullet.speed; if (speed < 3f) { break; } } this._traceBullets[num].SpeedY = ((num3 * gravity) / (3f * speed)) * UnityEngine.Random.Range((float)0.5f, (float)2f); }
protected virtual void CreateBullet(HitExplodeTracingBulletMixinArgument arg, uint bulletRuntimeID, uint otherID) { string bulletTypeName = this.baseConfig.BulletTypeName; float speed = base.instancedAbility.Evaluate(this.baseConfig.BulletSpeed); if (arg != null) { if (arg.BulletName != null) { bulletTypeName = arg.BulletName; } if (arg.RandomBulletNames != null) { bulletTypeName = arg.RandomBulletNames[UnityEngine.Random.Range(0, arg.RandomBulletNames.Length)]; } if (arg.BulletSpeed != null) { speed = base.instancedAbility.Evaluate(arg.BulletSpeed); } } AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, speed, this.baseConfig.Targetting, this.baseConfig.IgnoreTimeScale, bulletRuntimeID, base.instancedAbility.Evaluate(this.baseConfig.AliveDuration)); if ((this.baseConfig.BulletEffect != null) && (this.baseConfig.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.baseConfig.BulletEffect.EffectPattern, bullet.triggerBullet, this.baseConfig.BulletEffectGround); } this.InitBulletForward(bullet); this.InitBulletForwardWithArgument(bullet, arg, otherID); this._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.baseConfig.HitAnimEventID)); }
protected virtual void InitBulletForwardWithArgument(AbilityTriggerBullet bullet, HitExplodeTracingBulletMixinArgument arg, uint otherID) { if ((arg != null) && (arg.XZAngleOffset != 0f)) { bullet.triggerBullet.transform.Rotate(new Vector3(0f, arg.XZAngleOffset, 0f)); } }
public AbilityTriggerBullet CreateAbilityLinearTriggerBullet(string bulletType, BaseAbilityActor owner, float speed, MixinTargetting targetting, bool ignoreTimeScale, uint runtimeID, float aliveDuration = -1) { MonoTriggerBullet entity = this.CreateDynamicObjectEntityInstance <MonoTriggerBullet>(owner.runtimeID, bulletType, runtimeID); AbilityTriggerBullet bullet2 = Singleton <EventManager> .Instance.CreateActor <AbilityTriggerBullet>(entity); bullet2.Setup(owner, speed, targetting, ignoreTimeScale, aliveDuration); return(bullet2); }
private bool OnBulletRefected(EvtAfterBulletReflected evt) { AbilityTriggerBullet bullet = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.bulletID); MonoTriggerBullet triggerBullet = bullet.triggerBullet; bullet.Setup(base.actor, triggerBullet.speed, MixinTargetting.All, triggerBullet.IgnoreTimeScale, triggerBullet.AliveDuration); evt.attackData.attackerAttackValue *= base.instancedAbility.Evaluate(this.config.DamageRatio); Vector3 position = Singleton <EventManager> .Instance.GetEntity(evt.launcherID).GetAttachPoint("RootNode").position; BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.launcherID); if (Vector3.Angle(base.instancedAbility.caster.entity.transform.forward, actor.entity.transform.position - base.instancedAbility.caster.entity.transform.position) < this.config.Angle) { if (this.config.IsReflectToLauncher) { triggerBullet.SetupTracing(position, triggerBullet._traceLerpCoef, triggerBullet._traceLerpCoefAcc, false); triggerBullet.transform.forward = -triggerBullet.transform.forward; } else { position.y += UnityEngine.Random.Range((float)1f, (float)3f); Vector3 rhs = position - base.entity.XZPosition; float sqrMagnitude = rhs.sqrMagnitude; rhs.y = 0f; Vector3 onUnitSphere = UnityEngine.Random.onUnitSphere; if (Vector3.Dot(onUnitSphere, rhs) < 0f) { onUnitSphere = -onUnitSphere; } onUnitSphere.y = Mathf.Abs(onUnitSphere.y); triggerBullet.transform.forward = onUnitSphere; triggerBullet.SetupTracing((Vector3)((onUnitSphere.normalized * sqrMagnitude) * 0.8f), triggerBullet._traceLerpCoef, triggerBullet._traceLerpCoefAcc, false); } if (this.config.ResetAliveDuration) { triggerBullet.AliveDuration = this.config.NewAliveDuration; } base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.ReflectSuccessActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.launcherID), evt); } else { EvtBulletHit hit = new EvtBulletHit(triggerBullet.GetRuntimeID(), base.actor.runtimeID) { ownerID = base.actor.runtimeID, cannotBeReflected = true }; Vector3 vector4 = triggerBullet.transform.position - ((Vector3)((Time.deltaTime * triggerBullet.BulletTimeScale) * triggerBullet.transform.GetComponent <Rigidbody>().velocity)); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitPoint = vector4, hitDir = triggerBullet.transform.forward }; hit.hitCollision = collsion; Singleton <EventManager> .Instance.FireEvent(hit, MPEventDispatchMode.Normal); } return(false); }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { int num = this._traceBullets.SeekAddPosition <TraceDelay>(); TraceDelay delay = new TraceDelay { traceTimer = this.config.TraceStartDelay, bulletID = bullet.runtimeID }; this._traceBullets[num] = delay; }
public override void Core() { base.Core(); for (int i = 0; i < this._traceBullets.Count; i++) { if (this._traceBullets[i] != null) { TraceDelay delay = this._traceBullets[i]; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(delay.bulletID); if (actor != null) { if (!delay.isStuck) { actor.triggerBullet.SetCollisionEnabled(false); if ((actor.triggerBullet.transform.position.y < 0.03f) && (delay.SpeedY < 0f)) { delay.SpeedY *= -this.config.Elasticity; delay.hitGroundTime++; delay.isTriggered = true; if ((delay.SpeedY < 0.1f) || (delay.hitGroundTime >= 3)) { delay.isStuck = true; delay.SpeedY = 0f; } } actor.triggerBullet.speedAdd = new Vector3(0f, delay.SpeedY, 0f); actor.triggerBullet.SetupTracing(); delay.SpeedY -= (this.config.Gravity * Time.deltaTime) * base.entity.TimeScale; } else { actor.triggerBullet.speedAdd = Vector3.zero; actor.triggerBullet.SetupTracing(actor.triggerBullet.transform.position, 100f, 0f, false); } if (delay.isTriggered) { if (delay.delayTime > 0f) { delay.delayTime -= Time.deltaTime * base.entity.TimeScale; } else { actor.triggerBullet.SetCollisionEnabled(true); if (delay.isStuck) { this._traceBullets[i] = null; } } } Debug.DrawLine(delay.tarPos, actor.triggerBullet.transform.position, Color.blue); } } } }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { int num = this._traceBullets.SeekAddPosition <TraceDelay>(); TraceDelay delay = new TraceDelay { bulletID = bullet.runtimeID, lifeTimer = this.config.LifeTime, holdTimer = this.config.HoldTime, center = base.entity.transform.position, centerDir = base.entity.transform.forward }; this._traceBullets[num] = delay; }
public override void OnAbilityTriggered(EvtAbilityStart evt) { string bulletTypeName = this.config.BulletTypeName; int grenadeAmount = this.config.GrenadeAmount; string hitAnimEventID = this.config.HitAnimEventID; GrenadesMixinArgument abilityArgument = evt.abilityArgument as GrenadesMixinArgument; if (abilityArgument != null) { grenadeAmount = abilityArgument.BulletAmount; if (!string.IsNullOrEmpty(abilityArgument.HitAnimEventID)) { hitAnimEventID = abilityArgument.HitAnimEventID; } } for (int i = 0; i < grenadeAmount; i++) { AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); if ((this.config.BulletEffect != null) && (this.config.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.config.BulletEffect.EffectPattern, bullet.triggerBullet, this.config.BulletEffectGround); } BaseMonoEntity entity = null; Vector3 forward = base.entity.transform.forward; if (evt.otherID != 0) { BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.otherID); if ((actor != null) && (actor.entity != null)) { entity = actor.entity; } } if (entity != null) { bullet.triggerBullet.transform.position = entity.GetAttachPoint("RootNode").position; forward = entity.transform.forward; float angle = ((360 * i) / (this.config.GrenadeAmount + 1)) - 180; forward = (Vector3)(Quaternion.AngleAxis(angle, Vector3.up) * forward); } this.InitBulletDirAndPos(bullet, forward); base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, hitAnimEventID)); } }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { Vector3 forward; BaseMonoEntity attackTarget = base.entity.GetAttackTarget(); if ((attackTarget == null) || !this.config.FaceTarget) { forward = base.entity.transform.forward; } else { forward = attackTarget.GetAttachPoint("RootNode").position - bullet.triggerBullet.transform.position; Quaternion from = Quaternion.LookRotation(base.entity.transform.forward); Quaternion to = Quaternion.LookRotation(forward); forward = (Vector3)(Quaternion.RotateTowards(from, to, 15f) * Vector3.forward); } bullet.triggerBullet.transform.forward = forward; }
public override void Core() { base.Core(); for (int i = 0; i < this._traceBullets.Count; i++) { if (this._traceBullets[i] != null) { TraceDelay delay = this._traceBullets[i]; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(delay.bulletID); if (actor != null) { if (delay.holdTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(false); actor.triggerBullet.SetupTracing(actor.triggerBullet.transform.position, 99f, 0f, false); delay.holdTimer -= Time.deltaTime * base.entity.TimeScale; } else if (delay.lifeTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(true); if ((this._attackTarget != null) && (Vector3.Distance(delay.center, this._attackTarget.transform.position) > this.config.CenterTraceRadial)) { Vector3 vector4 = this._attackTarget.transform.position - delay.center; delay.centerDir = vector4.normalized; } delay.center.y = actor.triggerBullet.transform.position.y; delay.center += (Vector3)(((delay.centerDir * this.config.CenterSpeed) * Time.deltaTime) * base.entity.TimeScale); Vector3 vector6 = actor.triggerBullet.transform.position - delay.center; Vector3 normalized = vector6.normalized; Vector3 vector2 = (Vector3)(Quaternion.AngleAxis(this.config.RadAngle, Vector3.up) * normalized); Vector3 targetPosition = actor.triggerBullet.transform.position + ((Vector3)(vector2 * base.instancedAbility.Evaluate(this.config.BulletSpeed))); actor.triggerBullet.SetupTracing(targetPosition, 99f, 0f, false); delay.lifeTimer -= Time.deltaTime * base.entity.TimeScale; } else { this._traceBullets[i] = null; } } } } }
public override void Core() { base.Core(); for (int i = 0; i < this._traceBullets.Count; i++) { if (this._traceBullets[i] != null) { TraceDelay delay = this._traceBullets[i]; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(delay.bulletID); if (actor != null) { if (this._attackTarget != null) { delay.dummyPos += Vector3.ClampMagnitude(this._attackTarget.transform.position - delay.dummyPos, this.config.TraceSpeed * base.entity.TimeScale); } if (delay.holdTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(false); actor.triggerBullet.SetupTracing(actor.triggerBullet.transform.position, this.config.SteerCoef, 0f, false); actor.triggerBullet.IgnoreTimeScale = this.config.IgnoreTimeScale; delay.holdTimer -= Time.deltaTime * base.entity.TimeScale; } else if (delay.lifeTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(true); Vector3 vector3 = delay.dummyPos - delay.startPos; Vector3 normalized = vector3.normalized; Vector3 targetPosition = actor.triggerBullet.transform.position + ((Vector3)((normalized * base.instancedAbility.Evaluate(this.config.BulletSpeed)) * this.config.LifeTime)); targetPosition.y = 0f; targetPosition += delay.targetOffset; actor.triggerBullet.SetupTracing(targetPosition, this.config.SteerCoef, 0f, false); actor.triggerBullet.IgnoreTimeScale = this.config.IgnoreTimeScale; delay.lifeTimer -= Time.deltaTime * base.entity.TimeScale; } else { this._traceBullets[i] = null; } } } } }
public override void OnAbilityTriggered(EvtAbilityStart evt) { BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar(); if (localAvatar != null) { int count = localAvatar.SubAttackTargetList.Count; for (int i = 0; i < count; i++) { string bulletTypeName = this.config.BulletTypeName; HitExplodeTracingBulletMixinArgument abilityArgument = evt.abilityArgument as HitExplodeTracingBulletMixinArgument; if (abilityArgument != null) { if (abilityArgument.BulletName != null) { bulletTypeName = abilityArgument.BulletName; } if (abilityArgument.RandomBulletNames != null) { bulletTypeName = abilityArgument.RandomBulletNames[UnityEngine.Random.Range(0, abilityArgument.RandomBulletNames.Length)]; } } AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, base.instancedAbility.Evaluate(this.config.BulletPostionLinearSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); if ((this.config.BulletEffect != null) && (this.config.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.config.BulletEffect.EffectPattern, bullet.triggerBullet, this.config.BulletEffectGround); } base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.config.HitAnimEventID)); float angle = (180 / (count + 1)) * (i + 1); float num4 = base.instancedAbility.Evaluate(this.config.BulletPositionRadius); float duration = base.instancedAbility.Evaluate(this.config.BulletPositionDuration); Vector3 vector = Vector3.Cross(Vector3.up, base.entity.transform.forward); vector = (Vector3)(Quaternion.AngleAxis(angle, base.entity.transform.forward) * vector); Vector3 vector2 = (Vector3)(vector.normalized * num4); Vector3 position = localAvatar.SubAttackTargetList[i].transform.position; Vector3 up = Vector3.up; position += up; bullet.triggerBullet.SetupPositioning(bullet.triggerBullet.transform.position, bullet.triggerBullet.transform.position + vector2, duration, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.TracingLerpCoef, this.config.TracingLerpCoefAcc, position, this.config.PassBy); this.InitBulletForward(bullet); } } }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { float num = 10f; if (this._attackTarget != null) { num = Vector3.Distance(this._attackTarget.XZPosition, base.actor.entity.XZPosition); } float t = Mathf.InverseLerp(this.config.ScatterDistanceMax, this.config.ScatterDistanceMin, num); bullet.triggerBullet.transform.forward = base.actor.entity.transform.forward; Vector2 insideUnitCircle = UnityEngine.Random.insideUnitCircle; insideUnitCircle.x *= Mathf.Tan(0.01745329f * Mathf.Lerp(this.config.ScatterAngleMinX, this.config.ScatterAngleMaxX, t)); insideUnitCircle.y *= Mathf.Tan(0.01745329f * Mathf.Lerp(this.config.ScatterAngleMinY, this.config.ScatterAngleMaxY, t)); Transform transform = bullet.triggerBullet.transform; transform.forward += Quaternion.FromToRotation(Vector3.forward, bullet.triggerBullet.transform.forward) * insideUnitCircle; }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { int num = this._traceBullets.SeekAddPosition <TraceDelay>(); bullet.triggerBullet.transform.forward = base.entity.transform.forward; bullet.triggerBullet.SetCollisionEnabled(false); TraceDelay delay = new TraceDelay { bulletID = bullet.runtimeID, delayTime = this.config.DelayTime, tarPos = bullet.triggerBullet.transform.position, SpeedY = 0f, isTriggered = false, isStuck = false, hitGroundTime = 0 }; this._traceBullets[num] = delay; BaseMonoEntity attackTarget = base.entity.GetAttackTarget(); if (attackTarget != null) { Vector3 vector = new Vector3(UnityEngine.Random.Range(-this.config.Offset, this.config.Offset), 0f, UnityEngine.Random.Range(-this.config.Offset, this.config.Offset)); this._traceBullets[num].tarPos = attackTarget.transform.position + vector; Vector3 vector2 = this._traceBullets[num].tarPos - base.entity.transform.position; bullet.triggerBullet.transform.forward = vector2.normalized; } float speed = base.actor.Evaluate(this.config.BulletSpeed); float num3 = Vector3.Distance(this._traceBullets[num].tarPos, base.entity.transform.position); float y = bullet.triggerBullet.transform.position.y; float gravity = this.config.Gravity; while (num3 < ((4.2f * Mathf.Sqrt((2f * y) / gravity)) * speed)) { bullet.triggerBullet.speed *= 0.8f; speed = bullet.triggerBullet.speed; if (speed < 3f) { break; } } this._traceBullets[num].SpeedY = (num3 * gravity) / (6f * speed); }
private BulletInfo CreateOneBullet() { AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(this._bulletName, base.actor, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); Vector3 zero = Vector3.zero; this.InitBulletPosAndForward(bullet, out zero); BulletInfo info = new BulletInfo { bulletID = bullet.runtimeID, backTimer = this.config.BackTime, holdTimer = this.config.HoldTime, lifeTimer = this.config.LifeTime, startPosRelative = zero }; base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.config.HitAnimEventID)); bullet.triggerBullet.acceleration = this.config.Acceleration; bullet.triggerBullet.SetCollisionEnabled(false); return(info); }
public override void Core() { base.Core(); for (int i = 0; i < this._traceBullets.Count; i++) { if (this._traceBullets[i] != null) { TraceDelay delay = this._traceBullets[i]; delay.traceTimer -= Time.deltaTime * base.entity.TimeScale; if (delay.traceTimer <= 0f) { this._traceBullets[i] = null; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(delay.bulletID); if (((actor != null) && (actor.triggerBullet != null)) && actor.triggerBullet.IsActive()) { actor.triggerBullet.SetupTracing(this.CalculateTraceTargetPosition(this.config.BaseOnTarget, this.config.Distance, this.config.Angle), this.config.TracingLerpCoef, this.config.TracingLerpCoefAcc, false); } } } } }
protected virtual void InitBulletForward(AbilityTriggerBullet bullet) { Vector3 forward; BaseMonoEntity attackTarget = base.entity.GetAttackTarget(); if ((attackTarget == null) || !this.baseConfig.FaceTarget) { forward = base.entity.transform.forward; } else { forward = attackTarget.GetAttachPoint("RootNode").position - bullet.triggerBullet.transform.position; Quaternion from = Quaternion.LookRotation(base.entity.transform.forward); Quaternion to = Quaternion.LookRotation(forward); forward = (Vector3)(Quaternion.RotateTowards(from, to, 15f) * Vector3.forward); } if (this.baseConfig.IsFixedHeight) { forward.y = 0f; } bullet.triggerBullet.transform.forward = forward; bullet.triggerBullet.IgnoreTimeScale = this.baseConfig.IgnoreTimeScale; }
private void ClearBullets() { if (this.baseConfig.RemoveClearType != BulletClearBehavior.DoNothing) { foreach (uint num in this._bulletAttackDatas.Keys) { AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(num); if ((actor != null) && actor.IsActive()) { if (this.baseConfig.RemoveClearType == BulletClearBehavior.ClearAndKillAndPlayExplodeEffect) { this.FireTriggerBulletHitExplodeEffect(actor, actor.triggerBullet.transform.position, actor.triggerBullet.transform.forward, false); } if (actor != null) { actor.Kill(); } } } this._bulletAttackDatas.Clear(); } }
protected void FireTriggerBulletHitExplodeEffect(AbilityTriggerBullet bulletActor, Vector3 position, Vector3 forward, bool selfExplode = false) { if (selfExplode && (this.baseConfig.SelfExplodeEffect != null)) { base.FireMixinEffect(this.baseConfig.SelfExplodeEffect, bulletActor.triggerBullet, position, forward, true); } else if ((this.baseConfig.ApplyDistinctHitExplodeEffectPattern && (this.baseConfig.HitExplodeEffectAir != null)) && (this.baseConfig.HitExplodeEffectGround != null)) { float num = base.instancedAbility.Evaluate(this.baseConfig.DistinctHitExplodeHeight); if (bulletActor.triggerBullet.transform.position.y > num) { base.FireMixinEffect(this.baseConfig.HitExplodeEffectAir, bulletActor.triggerBullet, position, forward, true); } else { base.FireMixinEffect(this.baseConfig.HitExplodeEffectGround, bulletActor.triggerBullet, position, forward, true); } } else { base.FireMixinEffect(this.baseConfig.HitExplodeEffect, bulletActor.triggerBullet, position, forward, true); } }
protected virtual bool ListenBulletHit(EvtBulletHit evt) { if (!this._bulletAttackDatas.ContainsKey(evt.targetID)) { return(false); } AttackData attackData = this._bulletAttackDatas[evt.targetID]; attackData.isFromBullet = true; bool flag = this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage; bool flag2 = (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget); bool flag3 = true; bool flag4 = this.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh; BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID); BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor; if (entity is MonoDummyDynamicObject) { flag2 = false; flag = false; flag3 = false; flag4 = false; } else if (evt.hitEnvironment) { flag2 = true; flag4 = false; } else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet)) { Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, this._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal); return(false); } AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID); if (flag2) { if (bulletActor != null) { bulletActor.Kill(); } this._bulletAttackDatas.Remove(evt.targetID); } else { attackData = attackData.Clone(); } if (flag4 && (bulletActor != null)) { bulletActor.triggerBullet.ResetInside(this.baseConfig.ResetTime); } this._evtsLs.Clear(); if (evt.hitEnvironment) { if (!evt.hitGround) { return(true); } EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData) { hitCollision = evt.hitCollision }; this._evtsLs.Add(item); } else { attackData.hitCollision = evt.hitCollision; this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, this.baseConfig.HitAnimEventID, attackData)); } if (flag) { List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(this.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, this.baseConfig.Targetting)); float y = evt.hitCollision.hitPoint.y; for (int j = 0; j < list.Count; j++) { CollisionResult result = list[j]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID)) { result.hitPoint.y = y; AttackData data2 = attackData.Clone(); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitDir = result.hitForward, hitPoint = result.hitPoint }; data2.hitCollision = collsion; this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), this.baseConfig.HitAnimEventID, data2)); } } } if (flag3) { Vector3 hitPoint = evt.hitCollision.hitPoint; if (this.baseConfig.ExplodeEffectGround) { hitPoint.y = 0f; } Vector3 hitDir = evt.hitCollision.hitDir; hitDir.y = 0f; bool selfExplode = evt.selfExplode; if (bulletActor != null) { this.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, selfExplode); } } if ((this.baseConfig.HitExplodeActions.Length > 0) && (!evt.selfExplode || !this.baseConfig.MuteSelfHitExplodeActions)) { for (int k = 0; k < this._evtsLs.Count; k++) { if (base.actor.abilityPlugin != null) { base.actor.abilityPlugin.HandleActionTargetDispatch(this.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(this._evtsLs[k].toID), evt); } } } for (int i = 0; i < this._evtsLs.Count; i++) { EvtHittingOther other2 = this._evtsLs[i]; if (this.baseConfig.IsHitChangeTargetDirection && (other2.attackData.hitEffect >= AttackResult.AnimatorHitEffect.ThrowUp)) { BaseAbilityActor actor2 = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(other2.toID); if (actor2 != null) { actor2.entity.transform.forward = -other2.attackData.hitCollision.hitDir; } } Singleton <EventManager> .Instance.FireEvent(other2, MPEventDispatchMode.Normal); } return(true); }
public override void Core() { base.Core(); if (this._bulletNumCount < this._bulletNum) { this.CreateBullet(); } for (int i = 0; i < this._bulletInfoList.Count; i++) { if (this._bulletInfoList[i] != null) { BulletInfo info = this._bulletInfoList[i]; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(info.bulletID); if (actor != null) { this._attackTarget = base.entity.GetAttackTarget(); if (this._attackTarget == null) { this.SelectATarget(); } if (info.holdTimer > 0f) { actor.triggerBullet.SetupAtReset(); actor.triggerBullet.SetCollisionEnabled(false); info.holdTimer -= Time.deltaTime * base.entity.TimeScale; BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar(); if (localAvatar != null) { actor.triggerBullet.transform.position = localAvatar.XZPosition + info.startPosRelative; } if (this._attackTarget != null) { Vector3 position = this._attackTarget.GetAttachPoint("RootNode").position; actor.triggerBullet.transform.forward = position - actor.triggerBullet.transform.position; } } else if (info.backTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(false); info.backTimer -= Time.deltaTime * base.entity.TimeScale; Transform transform = actor.triggerBullet.transform; transform.position -= (Vector3)(actor.triggerBullet.transform.forward.normalized * Mathf.Lerp(0f, this.config.BackDistance, 1f - (info.backTimer / this.config.BackTime))); if (info.backTimer <= 0f) { this.FireBulletEffectSmoke(actor.triggerBullet); } } else if (info.lifeTimer > 0f) { actor.triggerBullet.SetCollisionEnabled(true); if (this._attackTarget != null) { actor.triggerBullet.SetupTracing(this._attackTarget.GetAttachPoint("RootNode").position, 99f, 0f, false); } else { actor.triggerBullet.SetupLinear(); } info.lifeTimer -= Time.deltaTime * base.entity.TimeScale; } else { this._bulletInfoList[i] = null; } } } } }
protected override bool ListenBulletHit(EvtBulletHit evt) { if (!base._bulletAttackDatas.ContainsKey(evt.targetID)) { return(false); } BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(evt.otherID); if (((identity != null) && !identity.isAuthority) && !identity.remoteMode.IsRemoteReceive()) { return(false); } AttackData attackData = base._bulletAttackDatas[evt.targetID]; attackData.isFromBullet = true; bool flag = base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage; bool flag2 = (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget); bool flag3 = true; bool flag4 = base.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh; BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID); BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor; if ((entity is MonoDummyDynamicObject) || ((identity != null) && !identity.remoteMode.IsRemoteReceive())) { flag2 = false; flag = false; flag3 = false; flag4 = false; } else if (evt.hitEnvironment) { flag2 = true; flag4 = false; } else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet)) { Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, base._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal); return(false); } AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID); if (flag2) { bulletActor.Kill(); base._bulletAttackDatas.Remove(evt.targetID); } else { attackData = attackData.Clone(); } if (flag4) { bulletActor.triggerBullet.ResetInside(base.baseConfig.ResetTime); } base._evtsLs.Clear(); if (evt.hitEnvironment) { if (!evt.hitGround) { return(true); } EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData) { hitCollision = evt.hitCollision }; base._evtsLs.Add(item); } else { attackData.hitCollision = evt.hitCollision; base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, base.baseConfig.HitAnimEventID, attackData)); } if (flag) { List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(base.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, base.baseConfig.Targetting)); float y = evt.hitCollision.hitPoint.y; for (int j = 0; j < list.Count; j++) { CollisionResult result = list[j]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID)) { result.hitPoint.y = y; AttackData data2 = attackData.Clone(); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitDir = result.hitForward, hitPoint = result.hitPoint }; data2.hitCollision = collsion; base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), base.baseConfig.HitAnimEventID, data2)); } } } if (flag3) { Vector3 hitPoint = evt.hitCollision.hitPoint; if (base.baseConfig.ExplodeEffectGround) { hitPoint.y = 0f; } Vector3 hitDir = evt.hitCollision.hitDir; hitDir.y = 0f; base.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, false); } if (base.baseConfig.HitExplodeActions.Length > 0) { for (int k = 0; k < base._evtsLs.Count; k++) { base.actor.abilityPlugin.HandleActionTargetDispatch(base.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(base._evtsLs[k].toID), evt); } } for (int i = 0; i < base._evtsLs.Count; i++) { EvtHittingOther other2 = base._evtsLs[i]; AttackPattern.SendHitEvent(base.actor.runtimeID, other2.toID, other2.animEventID, other2.hitCollision, other2.attackData, false, MPEventDispatchMode.CheckRemoteMode); } return(true); }
public override void Core() { base.Core(); for (int i = 0; i < this._traceBullets.Count; i++) { if (this._traceBullets[i] != null) { TraceDelay delay = this._traceBullets[i]; AbilityTriggerBullet actor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(delay.bulletID); if (actor != null) { BaseMonoEntity subAttackTarget; if (delay.subAttackTarget != null) { subAttackTarget = delay.subAttackTarget; } else { subAttackTarget = this._attackTarget; } if (delay.lineTimer > 0f) { delay.lineTimer -= Time.deltaTime * base.entity.TimeScale; } else if (delay.turnTimer > 0f) { if (Mathf.Approximately(delay.turnTimer, this.config.TraceStartDelay) && (subAttackTarget != null)) { Vector3 position = actor.triggerBullet.transform.position; Vector3 onUnitSphere = UnityEngine.Random.onUnitSphere; Vector2 lhs = new Vector2(onUnitSphere.x, onUnitSphere.z); if (Vector2.Dot(lhs, new Vector2(actor.triggerBullet.transform.forward.x, actor.triggerBullet.transform.forward.z)) < 0f) { lhs = (Vector2)(lhs * -1f); } onUnitSphere = new Vector3(lhs.x, onUnitSphere.y, lhs.y); Vector3 vector4 = (Vector3)(onUnitSphere * Vector3.Distance(actor.triggerBullet.transform.position, subAttackTarget.transform.position)); position += vector4; Mathf.Clamp(position.y, -this.config.RandomHeight, this.config.RandomHeight); actor.triggerBullet.SetupTracing(position, this.config.TracingLerpCoef, 0f, false); } delay.turnTimer -= Time.deltaTime * base.entity.TimeScale; } else { if (subAttackTarget != null) { Vector3 vector5; if (this.config.TraceRootNode) { vector5 = subAttackTarget.GetAttachPoint("RootNode").position; } else { vector5 = subAttackTarget.transform.position; } if (this.config.RandomOffsetDistance > 0f) { Vector3 vector9 = new Vector3(UnityEngine.Random.value - 0.5f, UnityEngine.Random.value - 0.5f); Vector3 vector6 = (Vector3)(vector9.normalized * this.config.RandomOffsetDistance); vector6 += (Vector3)(Vector3.up * UnityEngine.Random.Range(0f, this.config.RandomHeight)); vector5 += vector6; } if (!this.config.TraceY) { vector5.y = actor.triggerBullet.transform.position.y; } actor.triggerBullet.SetupTracing(vector5, this.config.TracingLerpCoef, 0f, this.config.PassBy); } this._traceBullets[i] = null; } } } } }
protected override void InitBulletForward(AbilityTriggerBullet bullet) { }