public void UpdateTankFalling(FixedUpdateEvent evt, FallingTankNode tank)
{
TankFallingComponent tankFalling = tank.tankFalling;
TrackComponent track = tank.track;
RigidbodyComponent rigidbody = tank.rigidbody;
TankCollisionComponent tankCollision = tank.tankCollision;
ChassisConfigComponent chassisConfig = tank.chassisConfig;
Entity tankEntity = tank.Entity;
int trackContacts = this.GetTrackContacts(track);
int collisionContacts = this.GetCollisionContacts(tankCollision);
int num5 = collisionContacts - tankFalling.PreviousCollisionContactsCount;
int deltaTrackContacts = trackContacts - tankFalling.PreviousTrackContactsCount;
Vector3 previousVelocity = tankFalling.PreviousVelocity;
tankFalling.PreviousCollisionContactsCount = collisionContacts;
tankFalling.PreviousTrackContactsCount = trackContacts;
tankFalling.PreviousVelocity = rigidbody.Rigidbody.velocity;
if (deltaTrackContacts > 0)
{
this.ApplyFall(tankEntity, previousVelocity, tankFalling, track, chassisConfig, tankCollision, rigidbody, true);
}
else if ((num5 > 0) && (trackContacts == 0))
{
this.ApplyFall(tankEntity, previousVelocity, tankFalling, track, chassisConfig, tankCollision, rigidbody, false);
}
else
{
this.UpdateGroundedStatus(tankFalling, deltaTrackContacts, collisionContacts, trackContacts);
}
}
private void ApplyMovementForces(ChassisNode node, float dt)
{
TrackComponent track = node.track;
if ((track.LeftTrack.numContacts + track.RightTrack.numContacts) > 0)
{
Vector3 vector;
Vector3 vector2;
float num2;
Rigidbody rigidbody = node.rigidbody.Rigidbody;
ChassisConfigComponent chassisConfig = node.chassisConfig;
this.CalculateNetSurfaceVelocities(node, out vector, out vector2);
float num = this.CalculateSlopeCoefficient(rigidbody.transform.up.y);
rigidbody.SetVelocitySafe(this.CalculateRigidBodyVelocity(rigidbody, vector, (node.speedConfig.SideAcceleration * num) * dt, out num2));
if ((track.LeftTrack.numContacts > 0) || (track.RightTrack.numContacts > 0))
{
Vector3 vector4 = this.CalculateRelativeAngularVelocity(node, dt, num * 1.2f, vector2, num2);
Vector3 normalized = rigidbody.transform.InverseTransformDirection(rigidbody.angularVelocity).normalized;
if ((Mathf.Abs(node.chassis.TurnAxis) > 0f) && (Mathf.Sign(normalized.y) != Mathf.Sign(node.chassis.TurnAxis)))
{
float y = Mathf.Lerp(0f, normalized.y, (0.2f * dt) * 60f);
vector2 -= rigidbody.transform.TransformDirection(new Vector3(0f, y, 0f));
}
rigidbody.SetAngularVelocitySafe(vector2 + vector4);
}
}
}
public void UpdateTankEngine(FixedUpdateEvent evt, TankEngineMovableNode tank)
{
TankEngineComponent tankEngine = tank.tankEngine;
TankEngineConfigComponent tankEngineConfig = tank.tankEngineConfig;
TrackComponent track = tank.track;
ChassisComponent chassis = tank.chassis;
float effectiveMoveAxis = chassis.EffectiveMoveAxis;
float effectiveTurnAxis = chassis.EffectiveTurnAxis;
bool hasCollision = tank.tankCollision.HasCollision;
tankEngine.CollisionTimerSec = (hasCollision == tankEngine.HasValuableCollision) ? 0f : (tankEngine.CollisionTimerSec + evt.DeltaTime);
if (tankEngine.CollisionTimerSec >= tankEngineConfig.EngineCollisionIntervalSec)
{
tankEngine.HasValuableCollision = hasCollision;
}
if (effectiveMoveAxis != 0f)
{
this.UpdateTankEngine(tankEngine, tankEngineConfig, tankEngine.HasValuableCollision, track, evt.DeltaTime, effectiveMoveAxis, tank.speed.Acceleration, tank.speedConfig.ReverseAcceleration, tank.speed.Speed, tankEngine.MovingBorder);
}
else if (effectiveTurnAxis == 0f)
{
tankEngine.Value = 0f;
}
else
{
this.UpdateTankEngine(tankEngine, tankEngineConfig, tankEngine.HasValuableCollision, track, evt.DeltaTime, effectiveTurnAxis, tank.speedConfig.TurnAcceleration, tank.speedConfig.ReverseTurnAcceleration, tank.speed.TurnSpeed, tank.tankEngineConfig.EngineTurningBorder);
}
}
private float CalculateTurnCoefficient(TrackComponent trackComponent)
{
float num = 1f;
if ((trackComponent.LeftTrack.numContacts == 0) || (trackComponent.RightTrack.numContacts == 0))
{
num = 0.5f;
}
return(num);
}
public void InitTankFalling(NodeAddedEvent evt, ActivatedTankNode tank)
{
Entity entity = tank.Entity;
TankFallingComponent component = new TankFallingComponent();
TrackComponent track = tank.track;
TankCollisionComponent tankCollision = tank.tankCollision;
component.PreviousCollisionContactsCount = this.GetCollisionContacts(tankCollision);
component.PreviousTrackContactsCount = this.GetTrackContacts(track);
component.IsGrounded = true;
component.PreviousVelocity = Vector3.zero;
entity.AddComponent(component);
}
public void ApplyStaticFriction(TrackComponent tracks, Rigidbody rigidbody)
{
if ((tracks.RightTrack.numContacts >= (tracks.RightTrack.rays.Length >> 1)) || (tracks.LeftTrack.numContacts >= (tracks.LeftTrack.rays.Length >> 1)))
{
Vector3 up = rigidbody.transform.up;
float num = Vector3.Dot(Physics.gravity, up);
float num2 = 0.7071068f * Physics.gravity.magnitude;
if ((num < -num2) || (num > num2))
{
Vector3 force = ((up * num) - Physics.gravity) * rigidbody.mass;
rigidbody.AddForceSafe(force);
}
}
}
private float CalculateForcePerRay(ChassisNode node, float dt, float forwardRelativeSpeed)
{
ChassisConfigComponent chassisConfig = node.chassisConfig;
ChassisComponent chassis = node.chassis;
float maxSpeed = node.effectiveSpeed.MaxSpeed;
TrackComponent track = node.track;
Rigidbody rigidbody = node.rigidbody.Rigidbody;
float acceleration = node.speed.Acceleration;
float num3 = 0f;
if (chassis.EffectiveMoveAxis == 0f)
{
num3 = (-MathUtil.Sign(forwardRelativeSpeed) * acceleration) * dt;
if (MathUtil.Sign(forwardRelativeSpeed) != MathUtil.Sign(forwardRelativeSpeed + num3))
{
num3 = -forwardRelativeSpeed;
}
}
else
{
if (this.IsReversedMove(chassis.EffectiveMoveAxis, forwardRelativeSpeed))
{
acceleration = node.speedConfig.ReverseAcceleration;
}
num3 = (chassis.EffectiveMoveAxis * acceleration) * dt;
}
float f = Mathf.Clamp(forwardRelativeSpeed + num3, -maxSpeed, maxSpeed);
float num5 = f - forwardRelativeSpeed;
float num6 = 1f;
float num7 = (maxSpeed <= 0f) ? num6 : Mathf.Clamp01(1f - Mathf.Abs((float)(forwardRelativeSpeed / maxSpeed)));
if ((num7 < num6) && ((chassis.EffectiveMoveAxis * MathUtil.Sign(forwardRelativeSpeed)) > 0f))
{
num5 *= num7 / num6;
}
float num8 = num5 / dt;
if ((Mathf.Abs(num8) < 4f) && (Mathf.Abs(f) > (0.5f * maxSpeed)))
{
num8 = MathUtil.SignEpsilon(num8, 0.1f) * 4f;
}
int num10 = track.LeftTrack.numContacts + track.RightTrack.numContacts;
int num11 = 2 * chassisConfig.NumRaysPerTrack;
float num12 = ((num8 * rigidbody.mass) * (num10 + (0.42f * (num11 - track.LeftTrack.numContacts)))) / ((float)num11);
return((num10 <= 0) ? num12 : (num12 / ((float)num10)));
}
private void CalculateNetSurfaceVelocities(ChassisNode node, out Vector3 surfaceVelocity, out Vector3 angularSurfaceVelocity)
{
ChassisConfigComponent chassisConfig = node.chassisConfig;
TrackComponent track = node.track;
Vector3 contactsMidpoint = this.GetContactsMidpoint(chassisConfig, track);
surfaceVelocity = Vector3.zero;
angularSurfaceVelocity = Vector3.zero;
for (int i = 0; i < chassisConfig.NumRaysPerTrack; i++)
{
this.AddSurfaceVelocitiesFromRay(node, track.LeftTrack.rays[i], contactsMidpoint, ref surfaceVelocity, ref angularSurfaceVelocity);
this.AddSurfaceVelocitiesFromRay(node, track.RightTrack.rays[i], contactsMidpoint, ref surfaceVelocity, ref angularSurfaceVelocity);
}
float num2 = track.LeftTrack.numContacts + track.RightTrack.numContacts;
surfaceVelocity = (num2 <= 0f) ? surfaceVelocity : (surfaceVelocity / num2);
angularSurfaceVelocity = (num2 <= 0f) ? angularSurfaceVelocity : (angularSurfaceVelocity / num2);
}
private Vector3 GetContactsMidpoint(ChassisConfigComponent chassisConfig, TrackComponent tracks)
{
Vector3 vector = new Vector3();
for (int i = 0; i < chassisConfig.NumRaysPerTrack; i++)
{
SuspensionRay ray = tracks.LeftTrack.rays[i];
if (ray.hasCollision)
{
vector += ray.rayHit.point;
}
ray = tracks.RightTrack.rays[i];
if (ray.hasCollision)
{
vector += ray.rayHit.point;
}
}
int num2 = tracks.LeftTrack.numContacts + tracks.RightTrack.numContacts;
return((num2 != 0) ? (vector / ((float)num2)) : Vector3.zero);
}
private Vector3 CalculateRelativeAngularVelocity(ChassisNode node, float dt, float slopeCoeff, Vector3 surfaceAngularVelocity, float forwardRelativeSpeed)
{
ChassisConfigComponent chassisConfig = node.chassisConfig;
TrackComponent track = node.track;
Rigidbody rigidbody = node.rigidbody.Rigidbody;
float maxTurnSpeed = node.effectiveSpeed.MaxTurnSpeed * 0.01745329f;
Vector3 up = rigidbody.transform.up;
Vector3 forward = rigidbody.transform.forward;
Vector3 lhs = rigidbody.angularVelocity - surfaceAngularVelocity;
float relativeTurnSpeed = Vector3.Dot(lhs, up);
float forcePerRay = this.CalculateForcePerRay(node, dt, forwardRelativeSpeed);
for (int i = 0; i < chassisConfig.NumRaysPerTrack; i++)
{
this.ApplyForceFromRay(track.LeftTrack.rays[i], rigidbody, forward, forcePerRay);
this.ApplyForceFromRay(track.RightTrack.rays[i], rigidbody, forward, forcePerRay);
}
float num5 = Vector3.Dot(lhs, up);
return(lhs + ((this.RecalculateRelativeTurnSpeed(node, dt, maxTurnSpeed, relativeTurnSpeed, slopeCoeff) - num5) * up));
}
private void CreateTracks(ChassisInitNode node, ChassisComponent chassis)
{
Entity entity = node.Entity;
ChassisConfigComponent chassisConfig = node.chassisConfig;
Rigidbody rigidbody = node.rigidbody.Rigidbody;
BoxCollider boundsCollider = node.tankColliders.BoundsCollider;
float trackLength = boundsCollider.size.z * 0.8f;
float num2 = boundsCollider.size.x - chassisConfig.TrackSeparation;
Vector3 vector3 = boundsCollider.center - new Vector3(0f, boundsCollider.size.y / 2f, 0f);
Vector3 trackCenterPosition = vector3 + new Vector3(-0.5f * num2, chassisConfig.NominalRayLength, 0f);
Vector3 vector6 = vector3 + new Vector3(0.5f * num2, chassisConfig.NominalRayLength, 0f);
float damping = node.damping.Damping;
TrackComponent component = new TrackComponent {
LeftTrack = new Track(rigidbody, chassisConfig.NumRaysPerTrack, trackCenterPosition, trackLength, chassisConfig, chassis, -1, damping),
RightTrack = new Track(rigidbody, chassisConfig.NumRaysPerTrack, vector6, trackLength, chassisConfig, chassis, 1, damping)
};
int layerMask = LayerMasks.VISIBLE_FOR_CHASSIS_SEMI_ACTIVE;
component.LeftTrack.SetRayсastLayerMask(layerMask);
component.RightTrack.SetRayсastLayerMask(layerMask);
entity.AddComponent(component);
}
public static void ApplyVulcanForce(Vector3 force, Rigidbody body, Vector3 pos, TankFallingComponent tankFalling, TrackComponent tracks)
{
body.AddForceAtPositionSafe(force, pos);
if (!tankFalling.IsGrounded && ((tracks.LeftTrack.numContacts + tracks.RightTrack.numContacts) <= 0))
{
body.AddForceSafe(-force);
}
}
private bool UpdateSuspensionContacts(TrackComponent trackComponent, float dt, float updatePeriod)
{
bool flag2 = trackComponent.RightTrack.UpdateSuspensionContacts(dt, updatePeriod);
return(trackComponent.LeftTrack.UpdateSuspensionContacts(dt, updatePeriod) && flag2);
}
private void ApplyFall(Entity tankEntity, Vector3 previousVelocity, TankFallingComponent tankFalling, TrackComponent track, ChassisConfigComponent chassisConfig, TankCollisionComponent tankCollision, RigidbodyComponent rigidbody, bool fallingByTrack)
{
if ((tankFalling != null) && (!tankFalling.IsGrounded && rigidbody.Rigidbody))
{
bool flag;
Vector3 planeNormal = this.GetFallingNrm(fallingByTrack, track, chassisConfig, tankCollision, out flag);
Vector3 vector2 = Vector3.ProjectOnPlane(previousVelocity, planeNormal);
Vector3 position = rigidbody.Rigidbody.transform.position;
TankFallingType type = this.DefineFallingCollisionMode(flag, fallingByTrack, planeNormal);
TankFallEvent eventInstance = new TankFallEvent {
FallingPower = (previousVelocity - vector2).sqrMagnitude,
FallingType = type,
Velocity = previousVelocity
};
if ((type == TankFallingType.SLOPED_STATIC_WITH_COLLISION) && this.CheckTankCollisionNotNull(tankCollision))
{
eventInstance.FallingTransform = tankCollision.Collision.transform;
}
base.ScheduleEvent(eventInstance, tankEntity);
tankFalling.IsGrounded = true;
}
}
private void UpdateTankEngine(TankEngineComponent tankEngine, TankEngineConfigComponent tankEngineConfig, bool hasCollision, TrackComponent track, float dt, float currentAxis, float straightAcceleration, float reverseAcceleration, float maxSpeed, float border)
{
float b = border;
if (((track.LeftTrack.numContacts + track.RightTrack.numContacts) > 0) && hasCollision)
{
b = tankEngineConfig.MaxEngineMovingBorder;
}
float num4 = (b * ((currentAxis <= 0f) ? reverseAcceleration : straightAcceleration)) / maxSpeed;
tankEngine.Value += num4 * dt;
tankEngine.Value = Mathf.Min(tankEngine.Value, b);
}
private Vector3 GetFallingNrm(bool fallingByTrack, TrackComponent track, ChassisConfigComponent chassisConfig, TankCollisionComponent tankCollision, out bool isFallingOnTank)
{
Vector3 zero = Vector3.zero;
isFallingOnTank = false;
if (!fallingByTrack)
{
Collision collision = tankCollision.Collision;
if (!this.CheckTankCollisionNotNull(tankCollision))
{
return(zero.normalized);
}
ContactPoint[] contacts = collision.contacts;
if (contacts == null)
{
return(zero.normalized);
}
int length = contacts.Length;
for (int i = 0; i < length; i++)
{
ContactPoint point = contacts[i];
zero += point.normal;
if (!isFallingOnTank)
{
Collider otherCollider = point.otherCollider;
if (this.ValidateCollider(otherCollider))
{
int layer = otherCollider.gameObject.layer;
isFallingOnTank |= this.CheckTankLayer(layer);
}
}
}
}
else
{
int numRaysPerTrack = chassisConfig.NumRaysPerTrack;
SuspensionRay[] rays = track.LeftTrack.rays;
SuspensionRay[] rayArray2 = track.RightTrack.rays;
for (int i = 0; i < numRaysPerTrack; i++)
{
SuspensionRay ray = rays[i];
SuspensionRay ray2 = rayArray2[i];
this.ApplyTrackRayNormal(ref zero, ray);
this.ApplyTrackRayNormal(ref zero, ray2);
if (!isFallingOnTank)
{
if (ray.hasCollision)
{
if ((ray.rayHit.collider == null) || (ray.rayHit.collider.gameObject == null))
{
return(zero.normalized);
}
if (this.ValidateCollider(ray.rayHit.collider))
{
int layer = ray.rayHit.collider.gameObject.layer;
isFallingOnTank |= this.CheckTankLayer(layer);
}
}
if (ray2.hasCollision)
{
if ((ray2.rayHit.collider == null) || (ray2.rayHit.collider.gameObject == null))
{
return(zero.normalized);
}
if (this.ValidateCollider(ray2.rayHit.collider))
{
int layer = ray2.rayHit.collider.gameObject.layer;
isFallingOnTank |= this.CheckTankLayer(layer);
}
}
}
}
}
return(zero.normalized);
}
private int GetTrackContacts(TrackComponent track) => track.LeftTrack.numContacts + track.RightTrack.numContacts;
