// Token: 0x06002DC3 RID: 11715 RVA: 0x000C26E8 File Offset: 0x000C08E8
private void FireRollerProjectile()
{
this.hasFiredRoller = true;
if (this.muzzleflashEffectPrefab)
{
EffectManager.SimpleMuzzleFlash(this.muzzleflashEffectPrefab, base.gameObject, this.muzzleString, false);
}
if (base.isAuthority && this.projectilePrefab != null)
{
float maxDistance = 1000f;
Ray aimRay = base.GetAimRay();
Vector3 forward = aimRay.direction;
Vector3 vector = aimRay.origin;
float magnitude = FireRoller.targetProjectileSpeed;
if (this.muzzleTransform)
{
vector = this.muzzleTransform.position;
RaycastHit raycastHit;
if (Physics.Raycast(aimRay, out raycastHit, maxDistance, LayerIndex.world.mask))
{
float num = magnitude;
Vector3 vector2 = raycastHit.point - vector;
Vector2 vector3 = new Vector2(vector2.x, vector2.z);
float magnitude2 = vector3.magnitude;
float y = Trajectory.CalculateInitialYSpeed(magnitude2 / num, vector2.y);
Vector3 a = new Vector3(vector3.x / magnitude2 * num, y, vector3.y / magnitude2 * num);
magnitude = a.magnitude;
forward = a / magnitude;
}
}
ProjectileManager.instance.FireProjectile(this.projectilePrefab, vector, Util.QuaternionSafeLookRotation(forward), base.gameObject, this.damageStat * this.damageCoefficient, 0f, Util.CheckRoll(this.critStat, base.characterBody.master), DamageColorIndex.Default, null, magnitude);
}
}
// Token: 0x06000312 RID: 786 RVA: 0x0000C688 File Offset: 0x0000A888
private void UpdateTrajectoryInfo()
{
this.aimRay = base.GetAimRay();
RaycastHit raycastHit;
if (Util.CharacterRaycast(base.gameObject, this.aimRay, out raycastHit, this.maxDistance, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal))
{
this.hitPoint = raycastHit.point;
this.hitNormal = raycastHit.normal;
}
else
{
this.hitPoint = this.aimRay.GetPoint(this.maxDistance);
this.hitNormal = -this.aimRay.direction;
}
float num = this.projectileBaseSpeed;
Vector3 vector = this.hitPoint - this.aimRay.origin;
Vector2 vector2 = new Vector2(vector.x, vector.z);
float magnitude = vector2.magnitude;
float y = Trajectory.CalculateInitialYSpeed(magnitude / num, vector.y);
Vector3 a = new Vector3(vector2.x / magnitude * num, y, vector2.y / magnitude * num);
this.speedOverride = a.magnitude;
this.finalRay = new Ray(this.aimRay.origin, a / this.speedOverride);
this.travelTime = Trajectory.CalculateGroundTravelTime(num, magnitude);
}
// Token: 0x06001DF4 RID: 7668 RVA: 0x00080FE0 File Offset: 0x0007F1E0
private void ReconstructPath(Path path, NodeGraph.LinkIndex[] cameFrom, NodeGraph.LinkIndex current, NodeGraph.PathRequest pathRequest)
{
int num = 1 << (int)pathRequest.hullClassification;
path.Clear();
if (current != NodeGraph.LinkIndex.invalid)
{
path.PushWaypointToFront(this.links[current.linkIndex].nodeIndexB, 0f);
}
while (current != NodeGraph.LinkIndex.invalid)
{
NodeGraph.NodeIndex nodeIndexB = this.links[current.linkIndex].nodeIndexB;
float minJumpHeight = 0f;
if ((num & this.links[current.linkIndex].jumpHullMask) != 0 && this.links[current.linkIndex].minJumpHeight > 0f)
{
Vector3 position = this.nodes[this.links[current.linkIndex].nodeIndexA.nodeIndex].position;
Vector3 position2 = this.nodes[this.links[current.linkIndex].nodeIndexB.nodeIndex].position;
minJumpHeight = Trajectory.CalculateApex(Trajectory.CalculateInitialYSpeed(Trajectory.CalculateGroundTravelTime(pathRequest.maxSpeed, NodeGraph.DistanceXZ(position, position2)), position2.y - position.y));
}
path.PushWaypointToFront(nodeIndexB, minJumpHeight);
if (cameFrom[this.links[current.linkIndex].nodeIndexA.nodeIndex] == NodeGraph.LinkIndex.invalid)
{
path.PushWaypointToFront(this.links[current.linkIndex].nodeIndexA, 0f);
}
current = cameFrom[this.links[current.linkIndex].nodeIndexA.nodeIndex];
}
path.status = PathStatus.Valid;
}
public void FixedUpdate()
{
if (!body.outOfCombat)
{
timer += Time.fixedDeltaTime;
if (timer >= interval)
{
timer = 0;
var crit = body.RollCrit();
float initialAngle = UnityEngine.Random.value * 360f;
bool accurateShot = false;
RaycastHit accurateShotRaycast = default(RaycastHit);
if (accurateShotChance > 0f && Util.CheckRoll(accurateShotChance) && body.inputBank && body.inputBank.GetAimRaycast(300f, out accurateShotRaycast))
{
accurateShot = true;
}
for (var i = 0; i < sparksToFire; i++)
{
Vector3 fireOrigin = body.corePosition;
Vector3 direction = Vector3.up;
direction = Quaternion.AngleAxis(UnityEngine.Random.value * coneAngle, Vector3.forward) * direction;
direction = Quaternion.AngleAxis(initialAngle + 360f / sparksToFire * i, Vector3.up) * direction;
float speed = UnityEngine.Random.Range(minSpeed, maxSpeed);
if (accurateShot && i == 0)
{
float accurateShotTime = UnityEngine.Random.Range(0.2f, 0.5f);
var distance = accurateShotRaycast.point - fireOrigin;
direction = new Vector3(
distance.x / accurateShotTime,
Trajectory.CalculateInitialYSpeed(accurateShotTime, distance.y),
distance.z / accurateShotTime
);
speed = direction.magnitude;
}
ProjectileManager.instance.FireProjectile(
sparkProjectilePrefab,
fireOrigin,
Util.QuaternionSafeLookRotation(direction),
body.gameObject,
body.damage * (damage / 100f + damagePerStack / 100f * (float)(stack - 1)),
0f,
crit,
DamageColorIndex.Default,
null,
speed
);
}
}
}
}
// Token: 0x06002FBE RID: 12222 RVA: 0x000CC8C8 File Offset: 0x000CAAC8
private void Fire()
{
Ray aimRay = base.GetAimRay();
Ray ray = new Ray(aimRay.origin, Vector3.up);
BullseyeSearch bullseyeSearch = new BullseyeSearch();
bullseyeSearch.searchOrigin = aimRay.origin;
bullseyeSearch.searchDirection = aimRay.direction;
bullseyeSearch.filterByLoS = false;
bullseyeSearch.teamMaskFilter = TeamMask.allButNeutral;
if (base.teamComponent)
{
bullseyeSearch.teamMaskFilter.RemoveTeam(base.teamComponent.teamIndex);
}
bullseyeSearch.sortMode = BullseyeSearch.SortMode.Angle;
bullseyeSearch.RefreshCandidates();
HurtBox hurtBox = bullseyeSearch.GetResults().FirstOrDefault <HurtBox>();
bool flag = false;
Vector3 a = Vector3.zero;
RaycastHit raycastHit;
if (hurtBox)
{
a = hurtBox.transform.position;
flag = true;
}
else if (Physics.Raycast(aimRay, out raycastHit, 1000f, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore))
{
a = raycastHit.point;
flag = true;
}
float magnitude = FireMortar.projectileVelocity;
if (flag)
{
Vector3 vector = a - ray.origin;
Vector2 a2 = new Vector2(vector.x, vector.z);
float magnitude2 = a2.magnitude;
Vector2 vector2 = a2 / magnitude2;
if (magnitude2 < FireMortar.minimumDistance)
{
magnitude2 = FireMortar.minimumDistance;
}
float y = Trajectory.CalculateInitialYSpeed(FireMortar.timeToTarget, vector.y);
float num = magnitude2 / FireMortar.timeToTarget;
Vector3 direction = new Vector3(vector2.x * num, y, vector2.y * num);
magnitude = direction.magnitude;
ray.direction = direction;
}
for (int i = 0; i < FireMortar.mortarCount; i++)
{
Quaternion rotation = Util.QuaternionSafeLookRotation(ray.direction + ((i != 0) ? (UnityEngine.Random.insideUnitSphere * 0.05f) : Vector3.zero));
ProjectileManager.instance.FireProjectile(FireMortar.mortarProjectilePrefab, ray.origin, rotation, base.gameObject, this.damageStat * FireMortar.mortarDamageCoefficient, 0f, Util.CheckRoll(this.critStat, base.characterBody.master), DamageColorIndex.Default, null, magnitude);
}
}
// Token: 0x060008BD RID: 2237 RVA: 0x0002BE08 File Offset: 0x0002A008
private void FireGrenade(string targetMuzzle)
{
base.PlayCrossfade("Gesture, Bombardment", "FireBombardment", 0.1f);
Util.PlaySound(FireBombardment.shootSoundString, base.gameObject);
this.aimRay = base.GetAimRay();
Vector3 vector = this.aimRay.origin;
if (this.modelTransform)
{
ChildLocator component = this.modelTransform.GetComponent <ChildLocator>();
if (component)
{
Transform transform = component.FindChild(targetMuzzle);
if (transform)
{
vector = transform.position;
}
}
}
base.AddRecoil(-1f * FireBombardment.recoilAmplitude, -2f * FireBombardment.recoilAmplitude, -1f * FireBombardment.recoilAmplitude, 1f * FireBombardment.recoilAmplitude);
if (FireBombardment.effectPrefab)
{
EffectManager.instance.SimpleMuzzleFlash(FireBombardment.effectPrefab, base.gameObject, targetMuzzle, false);
}
if (base.isAuthority)
{
float num = -1f;
RaycastHit raycastHit;
if (Util.CharacterRaycast(base.gameObject, this.aimRay, out raycastHit, float.PositiveInfinity, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore))
{
Vector3 point = raycastHit.point;
float velocity = FireBombardment.projectilePrefab.GetComponent <ProjectileSimple>().velocity;
Vector3 vector2 = point - vector;
Vector2 vector3 = new Vector2(vector2.x, vector2.z);
float magnitude = vector3.magnitude;
float y = Trajectory.CalculateInitialYSpeed(magnitude / velocity, vector2.y);
Vector3 a = new Vector3(vector3.x / magnitude * velocity, y, vector3.y / magnitude * velocity);
num = a.magnitude;
this.aimRay.direction = a / num;
}
float x = UnityEngine.Random.Range(0f, base.characterBody.spreadBloomAngle);
float z = UnityEngine.Random.Range(0f, 360f);
Vector3 up = Vector3.up;
Vector3 axis = Vector3.Cross(up, this.aimRay.direction);
Vector3 vector4 = Quaternion.Euler(0f, 0f, z) * (Quaternion.Euler(x, 0f, 0f) * Vector3.forward);
float y2 = vector4.y;
vector4.y = 0f;
float angle = Mathf.Atan2(vector4.z, vector4.x) * 57.29578f - 90f;
float angle2 = Mathf.Atan2(y2, vector4.magnitude) * 57.29578f;
Vector3 forward = Quaternion.AngleAxis(angle, up) * (Quaternion.AngleAxis(angle2, axis) * this.aimRay.direction);
ProjectileManager.instance.FireProjectile(FireBombardment.projectilePrefab, vector, Util.QuaternionSafeLookRotation(forward), base.gameObject, this.damageStat * FireBombardment.damageCoefficient, 0f, Util.CheckRoll(this.critStat, base.characterBody.master), DamageColorIndex.Default, null, num);
}
base.characterBody.AddSpreadBloom(FireBombardment.spreadBloomValue);
}
// Token: 0x06002964 RID: 10596 RVA: 0x000AE168 File Offset: 0x000AC368
protected virtual void UpdateTrajectoryInfo(out AimThrowableBase.TrajectoryInfo dest)
{
dest = default(AimThrowableBase.TrajectoryInfo);
Ray aimRay = base.GetAimRay();
RaycastHit raycastHit = default(RaycastHit);
bool flag = false;
if (this.rayRadius > 0f && Util.CharacterSpherecast(base.gameObject, aimRay, this.rayRadius, out raycastHit, this.maxDistance, LayerIndex.CommonMasks.bullet, QueryTriggerInteraction.UseGlobal) && raycastHit.collider.GetComponent <HurtBox>())
{
flag = true;
}
if (!flag)
{
flag = Util.CharacterRaycast(base.gameObject, aimRay, out raycastHit, this.maxDistance, LayerIndex.CommonMasks.bullet, QueryTriggerInteraction.UseGlobal);
}
if (flag)
{
dest.hitPoint = raycastHit.point;
dest.hitNormal = raycastHit.normal;
}
else
{
dest.hitPoint = aimRay.GetPoint(this.maxDistance);
dest.hitNormal = -aimRay.direction;
}
Vector3 vector = dest.hitPoint - aimRay.origin;
if (this.useGravity)
{
float num = this.projectileBaseSpeed;
Vector2 vector2 = new Vector2(vector.x, vector.z);
float magnitude = vector2.magnitude;
float y = Trajectory.CalculateInitialYSpeed(magnitude / num, vector.y);
Vector3 a = new Vector3(vector2.x / magnitude * num, y, vector2.y / magnitude * num);
dest.speedOverride = a.magnitude;
dest.finalRay = new Ray(aimRay.origin, a / dest.speedOverride);
dest.travelTime = Trajectory.CalculateGroundTravelTime(num, magnitude);
return;
}
dest.speedOverride = this.projectileBaseSpeed;
dest.finalRay = aimRay;
dest.travelTime = this.projectileBaseSpeed / vector.magnitude;
}
// Token: 0x06001D93 RID: 7571 RVA: 0x0008A328 File Offset: 0x00088528
public float JumpTest(Vector3 startCenterOfCapsulePos, Vector3 endCenterOfCapsulePos, float hSpeed)
{
float y = Trajectory.CalculateInitialYSpeed(Trajectory.CalculateGroundTravelTime(hSpeed, MapNode.MoveProbe.DistanceXZ(startCenterOfCapsulePos, endCenterOfCapsulePos)), endCenterOfCapsulePos.y - startCenterOfCapsulePos.y);
this.testCharacterController.Move(Vector3.zero);
Vector3 a = endCenterOfCapsulePos - startCenterOfCapsulePos;
a.y = 0f;
a.Normalize();
a *= hSpeed;
a.y = y;
float num = MapNode.MoveProbe.DistanceXZ(startCenterOfCapsulePos, endCenterOfCapsulePos);
this.testCharacterController.transform.position = startCenterOfCapsulePos;
int num2 = Mathf.CeilToInt(num * 1.5f / hSpeed / this.testTimeStep);
float num3 = float.NegativeInfinity;
Vector3 rhs = this.testCharacterController.transform.position;
for (int i = 0; i < num2; i++)
{
Vector3 vector = endCenterOfCapsulePos - this.testCharacterController.transform.position;
if (vector.sqrMagnitude <= 4f)
{
return(num3 - startCenterOfCapsulePos.y);
}
num3 = Mathf.Max(this.testCharacterController.transform.position.y, num3);
Vector3 vector2 = vector;
vector2.y = 0f;
vector2.Normalize();
a.x = vector2.x * hSpeed;
a.z = vector2.z * hSpeed;
a += Physics.gravity * this.testTimeStep;
this.testCharacterController.Move(a * this.testTimeStep);
Vector3 position = this.testCharacterController.transform.position;
if (position == rhs)
{
return(0f);
}
rhs = position;
}
return(0f);
}
// Token: 0x06002C8E RID: 11406 RVA: 0x000BBE68 File Offset: 0x000BA068
private void Fire()
{
Ray aimRay = base.GetAimRay();
Ray ray = aimRay;
Ray ray2 = aimRay;
Vector3 point = aimRay.GetPoint(ThrowSack.minimumDistance);
bool flag = false;
RaycastHit raycastHit;
if (Util.CharacterRaycast(base.gameObject, ray, out raycastHit, 500f, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore))
{
point = raycastHit.point;
flag = true;
}
float magnitude = ThrowSack.projectileVelocity;
if (flag)
{
Vector3 vector = point - ray2.origin;
Vector2 a = new Vector2(vector.x, vector.z);
float magnitude2 = a.magnitude;
Vector2 vector2 = a / magnitude2;
if (magnitude2 < ThrowSack.minimumDistance)
{
magnitude2 = ThrowSack.minimumDistance;
}
float y = Trajectory.CalculateInitialYSpeed(ThrowSack.timeToTarget, vector.y);
float num = magnitude2 / ThrowSack.timeToTarget;
Vector3 direction = new Vector3(vector2.x * num, y, vector2.y * num);
magnitude = direction.magnitude;
ray2.direction = direction;
}
for (int i = 0; i < ThrowSack.projectileCount; i++)
{
Quaternion rotation = Util.QuaternionSafeLookRotation(Util.ApplySpread(ray2.direction, ThrowSack.minSpread, ThrowSack.maxSpread, 1f, 1f, 0f, 0f));
ProjectileManager.instance.FireProjectile(ThrowSack.projectilePrefab, ray2.origin, rotation, base.gameObject, this.damageStat * ThrowSack.damageCoefficient, 0f, Util.CheckRoll(this.critStat, base.characterBody.master), DamageColorIndex.Default, null, magnitude);
}
}
// Token: 0x06000914 RID: 2324 RVA: 0x0002D960 File Offset: 0x0002BB60
public override void OnEnter()
{
base.OnEnter();
string muzzleName = "Mouth";
this.duration = FireSpit.baseDuration / this.attackSpeedStat;
if (FireSpit.effectPrefab)
{
EffectManager.instance.SimpleMuzzleFlash(FireSpit.effectPrefab, base.gameObject, muzzleName, false);
}
base.PlayCrossfade("Gesture", "FireSpit", "FireSpit.playbackRate", this.duration, 0.1f);
this.aimRay = base.GetAimRay();
float magnitude = FireSpit.projectileHSpeed;
Ray ray = this.aimRay;
ray.origin = this.aimRay.GetPoint(6f);
RaycastHit raycastHit;
if (Util.CharacterRaycast(base.gameObject, ray, out raycastHit, float.PositiveInfinity, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore))
{
float num = magnitude;
Vector3 vector = raycastHit.point - this.aimRay.origin;
Vector2 vector2 = new Vector2(vector.x, vector.z);
float magnitude2 = vector2.magnitude;
float y = Trajectory.CalculateInitialYSpeed(magnitude2 / num, vector.y);
Vector3 a = new Vector3(vector2.x / magnitude2 * num, y, vector2.y / magnitude2 * num);
magnitude = a.magnitude;
this.aimRay.direction = a / magnitude;
}
EffectManager.instance.SimpleMuzzleFlash(FireSpit.effectPrefab, base.gameObject, muzzleName, false);
if (base.isAuthority)
{
for (int i = 0; i < FireSpit.projectileCount; i++)
{
this.FireBlob(this.aimRay, 0f, ((float)FireSpit.projectileCount / 2f - (float)i) * FireSpit.yawSpread, magnitude);
}
}
}
private void UpdateTrajInfo(out TrajectoryInfo traj)
{
traj = default(TrajectoryInfo);
Ray aimRay = base.GetAimRay();
RaycastHit rHit = default(RaycastHit);
Vector3 direction = aimRay.direction;
direction.y = Mathf.Max(direction.y, EntityStates.Croco.BaseLeap.minimumY);
Vector3 a = direction.normalized * EntityStates.Croco.BaseLeap.aimVelocity * this.moveSpeedStat;
Vector3 b = Vector3.up * EntityStates.Croco.BaseLeap.upwardVelocity;
Vector3 b2 = new Vector3(direction.x, 0f, direction.z).normalized *EntityStates.Croco.BaseLeap.forwardVelocity;
Vector3 velocity = a + b + b2;
Vector3 tempVelocity = velocity;
Ray r = new Ray(aimRay.origin, velocity);
Single time = Trajectory.CalculateFlightDuration(velocity.y);
Single timeStep = time / 25f;
Vector3 oldPos = aimRay.origin;
Boolean hit = false;
List <Vector3> vecs = new List <Vector3>(100);
for (Int32 i = 0; i < 100; i++)
{
Vector3 pos = Trajectory.CalculatePositionAtTime(r.origin, tempVelocity, timeStep * i, Physics.gravity.y);
tempVelocity *= Mathf.Exp(timeStep * -0.4f);
hit = Physics.SphereCast(oldPos, 0.2f, (pos - oldPos), out rHit, (pos - oldPos).magnitude, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
if (hit)
{
break;
}
oldPos = pos;
vecs.Add(pos);
}
arcLineRender.positionCount = vecs.Count;
arcLineRender.SetPositions(vecs.ToArray());
if (hit)
{
traj.hitPoint = rHit.point;
traj.hitNormal = rHit.normal;
}
else
{
traj.hitPoint = oldPos;
traj.hitNormal = Vector3.up;
}
Vector3 diff = traj.hitPoint - aimRay.origin;
if (useGravity)
{
Single speed = velocity.magnitude;
Vector2 flatDiff = new Vector2(diff.x, diff.z);
Single flatDist = flatDiff.magnitude;
Single yStart = Trajectory.CalculateInitialYSpeed(flatDist / speed, diff.y);
Vector3 speedVec = new Vector3(flatDiff.x / flatDist * speed, yStart, flatDiff.y / flatDist * speed);
traj.speedOverride = speedVec.magnitude;
traj.finalRay = new Ray(aimRay.origin, speedVec / traj.speedOverride);
traj.travelTime = Trajectory.CalculateGroundTravelTime(speed, flatDist);
return;
}
traj.speedOverride = baseSpeed;
traj.finalRay = aimRay;
traj.travelTime = baseSpeed / diff.magnitude;
}
private void FireGrenade(string targetMuzzle)
{
Ray aimRay = base.GetAimRay();
Ray ray = new Ray(aimRay.origin, Vector3.up);
Transform transform = base.FindModelChild(targetMuzzle);
if (transform)
{
ray.origin = transform.position;
}
BullseyeSearch bullseyeSearch = new BullseyeSearch();
bullseyeSearch.searchOrigin = aimRay.origin;
bullseyeSearch.searchDirection = aimRay.direction;
bullseyeSearch.filterByLoS = false;
bullseyeSearch.teamMaskFilter = TeamMask.allButNeutral;
if (base.teamComponent)
{
bullseyeSearch.teamMaskFilter.RemoveTeam(base.teamComponent.teamIndex);
}
bullseyeSearch.sortMode = BullseyeSearch.SortMode.Angle;
bullseyeSearch.RefreshCandidates();
HurtBox hurtBox = bullseyeSearch.GetResults().FirstOrDefault <HurtBox>();
bool flag = false;
Vector3 a = Vector3.zero;
RaycastHit raycastHit;
if (hurtBox)
{
a = hurtBox.transform.position;
flag = true;
}
else if (Physics.Raycast(aimRay, out raycastHit, 1000f, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore))
{
a = raycastHit.point;
flag = true;
}
float magnitude = SporeGrenade.projectileVelocity;
if (flag)
{
Vector3 vector = a - ray.origin;
Vector2 a2 = new Vector2(vector.x, vector.z);
float magnitude2 = a2.magnitude;
Vector2 vector2 = a2 / magnitude2;
if (magnitude2 < SporeGrenade.minimumDistance)
{
magnitude2 = SporeGrenade.minimumDistance;
}
if (magnitude2 > SporeGrenade.maximumDistance)
{
magnitude2 = SporeGrenade.maximumDistance;
}
float y = Trajectory.CalculateInitialYSpeed(SporeGrenade.timeToTarget, vector.y);
float num = magnitude2 / SporeGrenade.timeToTarget;
Vector3 direction = new Vector3(vector2.x * num, y, vector2.y * num);
magnitude = direction.magnitude;
ray.direction = direction;
}
for (float num = 0f; num < 9f; num += 1f)
{
float num2 = 6.2831855f;
Vector3 forward = new Vector3(Mathf.Cos(num / 9f * num2), 0f, Mathf.Sin(num / 9f * num2));
ProjectileManager.instance.FireProjectile(SporeGrenade.projectilePrefab, ray.origin, Quaternion.LookRotation(forward), base.gameObject, this.damageStat * SporeGrenade.damageCoefficient, 0f, base.RollCrit(), DamageColorIndex.Default, null, magnitude - 10);
}
}
// Token: 0x06001DF2 RID: 7666 RVA: 0x00080B04 File Offset: 0x0007ED04
public PathTask ComputePath(NodeGraph.PathRequest pathRequest)
{
PathTask pathTask = new PathTask(pathRequest.path);
pathTask.status = PathTask.TaskStatus.Running;
NodeGraph.NodeIndex nodeIndex = this.FindClosestNode(pathRequest.startPos, pathRequest.hullClassification);
NodeGraph.NodeIndex nodeIndex2 = this.FindClosestNode(pathRequest.endPos, pathRequest.hullClassification);
if (nodeIndex.nodeIndex == NodeGraph.NodeIndex.invalid.nodeIndex || nodeIndex2.nodeIndex == NodeGraph.NodeIndex.invalid.nodeIndex)
{
pathRequest.path.Clear();
pathTask.status = PathTask.TaskStatus.Complete;
return(pathTask);
}
int num = 1 << (int)pathRequest.hullClassification;
bool[] array = new bool[this.nodes.Length];
bool[] array2 = new bool[this.nodes.Length];
array2[nodeIndex.nodeIndex] = true;
int i = 1;
NodeGraph.NodeIndex[] array3 = new NodeGraph.NodeIndex[this.nodes.Length];
array3[0] = nodeIndex;
NodeGraph.LinkIndex[] array4 = new NodeGraph.LinkIndex[this.nodes.Length];
for (int j = 0; j < array4.Length; j++)
{
array4[j] = NodeGraph.LinkIndex.invalid;
}
float[] array5 = new float[this.nodes.Length];
for (int k = 0; k < array5.Length; k++)
{
array5[k] = float.PositiveInfinity;
}
array5[nodeIndex.nodeIndex] = 0f;
float[] array6 = new float[this.nodes.Length];
for (int l = 0; l < array6.Length; l++)
{
array6[l] = float.PositiveInfinity;
}
array6[nodeIndex.nodeIndex] = this.HeuristicCostEstimate(pathRequest.startPos, pathRequest.endPos);
while (i > 0)
{
NodeGraph.NodeIndex invalid = NodeGraph.NodeIndex.invalid;
float num2 = float.PositiveInfinity;
for (int m = 0; m < i; m++)
{
int nodeIndex3 = array3[m].nodeIndex;
if (array6[nodeIndex3] <= num2)
{
num2 = array6[nodeIndex3];
invalid = new NodeGraph.NodeIndex(nodeIndex3);
}
}
if (invalid.nodeIndex == nodeIndex2.nodeIndex)
{
this.ReconstructPath(pathRequest.path, array4, array4[invalid.nodeIndex], pathRequest);
pathTask.status = PathTask.TaskStatus.Complete;
return(pathTask);
}
array2[invalid.nodeIndex] = false;
NodeGraph.ArrayRemoveNodeIndex(array3, invalid, i);
i--;
array[invalid.nodeIndex] = true;
NodeGraph.LinkListIndex linkListIndex = this.nodes[invalid.nodeIndex].linkListIndex;
NodeGraph.LinkIndex linkIndex = new NodeGraph.LinkIndex
{
linkIndex = linkListIndex.index
};
NodeGraph.LinkIndex linkIndex2 = new NodeGraph.LinkIndex
{
linkIndex = linkListIndex.index + (int)linkListIndex.size
};
while (linkIndex.linkIndex < linkIndex2.linkIndex)
{
NodeGraph.Link link = this.links[linkIndex.linkIndex];
NodeGraph.NodeIndex nodeIndexB = link.nodeIndexB;
if (!array[nodeIndexB.nodeIndex])
{
if ((num & link.jumpHullMask) != 0 && this.links[linkIndex.linkIndex].minJumpHeight > 0f)
{
Vector3 position = this.nodes[link.nodeIndexA.nodeIndex].position;
Vector3 position2 = this.nodes[link.nodeIndexB.nodeIndex].position;
if (Trajectory.CalculateApex(Trajectory.CalculateInitialYSpeed(Trajectory.CalculateGroundTravelTime(pathRequest.maxSpeed, NodeGraph.DistanceXZ(position, position2)), position2.y - position.y)) > pathRequest.maxJumpHeight)
{
goto IL_41A;
}
}
if ((link.hullMask & num) != 0 && (link.gateIndex == 0 || this.openGates[(int)link.gateIndex]))
{
float num3 = array5[invalid.nodeIndex] + link.distanceScore;
if (!array2[nodeIndexB.nodeIndex])
{
array2[nodeIndexB.nodeIndex] = true;
array3[i] = nodeIndexB;
i++;
}
else if (num3 >= array5[nodeIndexB.nodeIndex])
{
goto IL_41A;
}
array4[nodeIndexB.nodeIndex] = linkIndex;
array5[nodeIndexB.nodeIndex] = num3;
array6[nodeIndexB.nodeIndex] = array5[nodeIndexB.nodeIndex] + this.HeuristicCostEstimate(this.nodes[nodeIndexB.nodeIndex].position, this.nodes[nodeIndex2.nodeIndex].position);
}
}
IL_41A:
linkIndex.linkIndex++;
}
}
pathRequest.path.Clear();
pathTask.status = PathTask.TaskStatus.Complete;
return(pathTask);
}
