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;