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)
{
}
