BallisticNG Physics

// This source file requires other source files in order to work, I have uploaded this at this time for people to see how everything is done.
// Keep an eye on https://github.com/bigsnake09/BallisticNG in the future for the full source code.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class ShipSimulator : MonoBehaviour {

    // References
    public EventManager eventMan;
    public ShipSettings settings;

    public ShipController shipController;
    public Rigidbody shipBody;

    public GameObject shipAxis;
    public GameObject shipCamera;
    public GameObject shipCollder;

    // Event Settings
    public GlobalSettings.ESpeedClasses eventClass;
    public bool isShipRespawning;
    public Vector3 respawnPoint;

    // Gravity
    private Vector3 shipGravity;
    public bool shipGrounded;
    private float fallingDamper;
    private float groundDistance;

    private float airResistance;
    private float angularResistance;

    // Engine
    private float engineGain;
    private float engineFalloff;
    private float engineAcceleration;
    private float engineThrust;
    public float engineSpeed;
    public bool wallSurfing;

    private float enginePitchAmount;

    private float brakesAmount;
    private float brakesGain;
    private float brakesFalloff;
    public bool shipBraking;

    private Vector3 speedDirection;
    private float shipBoostTimer;
    public bool isBoosting;
    public bool boostingOverride;
    private bool hitPad;

    // Turning
    public float turnAmount;
    private float turnGain;
    private float turnFalloff;
    private float airbrakeAmount;
    private float airbrakeGain;
    private float airbrakeFalloff;
    private float airbrakeResistance;

    private float airbrakeLeftRaise;
    private float airbrakeRightRaise;
    private float airbrakeSlip;
    private float airbrakeDrag;

    // Banking
    private float bankAmount;
    private float bankGain;
    private float bankFalloff;
    private float bankAirbrake;

    private float bankVelocity;

    // Anti-Band
    private bool turnAntiBand;
    private bool airbrakeAntiBand;

    // Camera
    private int cameraMode;

    private Vector3 cameraOffset;
    private float cameraAccelLag;
    private float cameraFallLag;
    private float cameraInputAmount;

    private float cameraMoveGain;
    private float cameraMoveFalloff;
    private float cameraFallingOffset;
    private float cameraTurningOffset;
    private float cameraTurningHeight;
    private float cameraFallHelper;
    private float cameraTurnAmount;

    private float cameraPitchMod;
    private float cameraWantedPitch;

    private float cameraFoV;
    private float cameraWallSurfFOV;

    private float cameraBoostFoV;
    private float cameraBoostLength;

    private float cameraMovementLength;

    // Animations
    private float shipHoverAnimTimer;
    private float shipHoverAnimSpeed = 1.0f;
    private float shipHoverAnimAmount = 0.2f;
    private Vector3 shipHoverAnimOffset;
    private Vector3 shipHoverCameraAnimOffset;

    public bool isColliding;

    // Barrel Roll
    private float shipBRProgress;
    private float shipBRActual;
    private float shipBRTimer;
    private float shipBRLastValue;
    public float shipBRBoostTimer;
    private float shipBRState;
    private float shipBRGain;

    private bool shipHasBR;
    private bool shipCanBR;
    private bool shipBRSuccess;

    public float shipIntegrity = 100;

    void Update()
    {
        // Get the current speed class
        eventClass = EventSettings.setupSpeedClass;
    }

    void FixedUpdate()
    {
        if (isShipRespawning)
        {
            // Disable the ship collider
            shipCollder.SetActive(false);

            // Move ship back to respawn point
            transform.position = Vector3.Lerp(transform.position, respawnPoint, Time.deltaTime * 5);
            float distanceToRespawn = Vector3.Distance(transform.position, respawnPoint);
            if (distanceToRespawn < 10)
            {
                isShipRespawning = false;
            }

            // Reset engine
            engineThrust = 0;
            engineAcceleration = 0;
            shipBRSuccess = false;
        } else
        {
            // If the ship collider is disable then enable it
            if (!shipCollder.activeSelf)
                shipCollder.SetActive(true);

            if (!shipController.manager.eventPaused)
            {
                ShipGravity();
                ShipDrag();
                ShipAcceleration();
                ShipHandling();
                ShipAnimations();
                ShipBarrelRolls();
            }
        }
        if (shipCamera != null)
        {
            UpdateShipCamera();
        }

        // Ship Integrity
        if (shipIntegrity < 0)
        {

        }

        shipIntegrity += Time.deltaTime * 3;
        if (shipIntegrity > 100)
            shipIntegrity = 100;
    }

    private void ShipGravity()
    {
        // Apply Gravity
        switch(eventClass)
        {
        case GlobalSettings.ESpeedClasses.Venom:
            if (shipGrounded)
            {
                shipGravity = -transform.up * settings.shipGravity_D * 0.6f;
            } else
            {
                shipGravity = Vector3.down * settings.shipGravity_D;
            }
            break;
        case GlobalSettings.ESpeedClasses.Flash:
            if (shipGrounded)
            {
                shipGravity = -transform.up * settings.shipGravity_C * 0.6f;
            } else
            {
                shipGravity = Vector3.down * settings.shipGravity_C;
            }
            break;
        case GlobalSettings.ESpeedClasses.Rapier:
            if (shipGrounded)
            {
                shipGravity = -transform.up * settings.shipGravity_B * 0.6f;
            } else
            {
                shipGravity = Vector3.down * settings.shipGravity_B;
            }
            break;
        case GlobalSettings.ESpeedClasses.Phantom:
            if (shipGrounded)
            {
                shipGravity = -transform.up * settings.shipGravity_A * 0.6f;
            } else
            {
                shipGravity = Vector3.down * settings.shipGravity_A;
            }
            break;
        }
        shipBody.AddForce(shipGravity, ForceMode.Acceleration);

        // Hover
        List<Vector3> HoverPoints = new List<Vector3>()
        {
            transform.TransformPoint(-settings.shipSize.x * 0.5f, 0.0f, settings.shipSize.z * 0.5f), // FL
            transform.TransformPoint(settings.shipSize.x * 0.5f, 0.0f, settings.shipSize.z * 0.5f), // FR
            transform.TransformPoint(settings.shipSize.x * 0.5f, 0.0f, -settings.shipSize.z * 0.5f), // BR
            transform.TransformPoint(-settings.shipSize.x * 0.5f, 0.0f, -settings.shipSize.z * 0.5f), // BL
        };

        // Falling Damper
        if (shipGrounded)
        {
            fallingDamper = Mathf.Lerp(fallingDamper, 0.0f, Time.deltaTime);
        } else
        {
            fallingDamper = Mathf.Lerp (fallingDamper, 0.1f, Time.deltaTime);
        }

        // Run through each point and make ship hover
        shipGrounded = false;
        for (int i = 0; i < HoverPoints.Count; i++)
        {
            int Mask = 1 << LayerMask.NameToLayer("TrackFloor");
            RaycastHit hit;
            if (Physics.Raycast(HoverPoints[i], -transform.up, out hit, settings.shipRideHeight, Mask))
            {
                shipGrounded = true;

                float hoverForce = settings.shipRideHeight - hit.distance;
                Vector3 spring = HoverPoints[i] - hit.point;
                float length = spring.magnitude;
                float displacement = length - settings.shipRideHeight;

                Vector3 springN = spring / length;
                float compression = ((settings.shipRideHeight / hit.distance) - 1) * -1;
                Vector3 restoreForce = springN * (displacement * (hoverForce * (-10 + (compression * 3))));
                float force = restoreForce.y;
                force -= shipBody.GetPointVelocity(HoverPoints[i]).y * ((0.3f) + fallingDamper + (enginePitchAmount * 0.05f));
                shipBody.AddForceAtPosition(transform.up * force, HoverPoints[i], ForceMode.Acceleration);
                groundDistance = hit.distance;
            }
        }

        RaycastHit centreHit;
        // Raycast down
        if (!shipController.isAI)
        {
            if (Physics.Raycast(transform.position, -transform.up, out centreHit, settings.shipRideHeight, 1 << LayerMask.NameToLayer("TrackFloor")))
            {
                // Use a dot product to find out how much we need to rotate the ship to get it to face down
                Vector3 trackRot = transform.right - (Vector3.Dot(transform.forward, centreHit.normal) * centreHit.normal);
                // Use the track rotation to calculate how much we are going to rotate the ship
                float rotAmount = (trackRot.x * trackRot.z) * (Mathf.Clamp(Mathf.Abs(trackRot.y), 0.0f, 0.1f) * 10);
                // Increase the rotation amount as the ship speeds up
                float rotForce = 20 + (transform.InverseTransformDirection(shipBody.velocity).z * Time.deltaTime) * 3;
                // Apply the rotation
                transform.Rotate(Vector3.up * (rotAmount * Time.deltaTime) * rotForce);

                // Apply gravity force
                shipBody.AddForce(new Vector3(centreHit.normal.x, 0, centreHit.normal.z) * (Mathf.Abs(trackRot.x)) * 22);
            }
        }

        // Weapon and Speed
        int padMask = 1 << LayerMask.NameToLayer("TrackSpeed") | 1 << LayerMask.NameToLayer("TrackWeapon");
        if (Physics.Raycast(transform.position, -transform.up, out centreHit, settings.shipRideHeight + 2, padMask))
        {
            if (centreHit.collider.gameObject.layer == LayerMask.NameToLayer("TrackSpeed"))
            {
                speedDirection = centreHit.collider.gameObject.transform.forward * 800;
                shipBoostTimer = 0.27f;
                isBoosting = true;

                if (!hitPad)
                {
                    hitPad = true;
                    AudioLibrary.Create3DOneShot("Boost", 1.0f, 1.0f, transform, Vector3.zero, 400.0f, 500.0f, "Audio/Ships/Boost", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                }
            }
        } else
        {
            hitPad = false;
        }

        // Apply boost force
        if (shipBoostTimer > 0)
        {
            shipBoostTimer -= Time.deltaTime;
            shipBody.AddForce(speedDirection, ForceMode.Acceleration);
        } else
        {
            isBoosting = false;
            hitPad = false;
        }

        // Boost Override
        if (boostingOverride)
        {
            isBoosting = true;
        }
        boostingOverride = false;

        // Pitching
        if (shipController.axisPitch != 0)
        {
            enginePitchAmount = Mathf.Lerp(enginePitchAmount, shipController.axisPitch * 5, Time.deltaTime * 4);
        } else
        {
            enginePitchAmount = Mathf.Lerp(enginePitchAmount, 0, Time.deltaTime * 4);
        }

        if (shipGrounded)
        {
            if (enginePitchAmount >= 0)
            {
                shipBody.AddTorque(transform.right * (enginePitchAmount * 80));
            } else
            {
                shipBody.AddTorque(transform.right * (enginePitchAmount * 70));
            }
        } else
        {
            if (enginePitchAmount >= 0)
            {
                shipBody.AddTorque(transform.right * (enginePitchAmount * 45));
                transform.Rotate(Vector3.right * 0.03f);
            }
        }
    }

    private void ShipAcceleration()
    {
        float topThrust = 0;
        float topAccel = 0;
        switch(eventClass)
        {
        case GlobalSettings.ESpeedClasses.Venom:
            topThrust = settings.engineAmountVenom;
            topAccel = settings.engineAccelerationVenom;
            break;
        case GlobalSettings.ESpeedClasses.Flash:
            topThrust = settings.engineAmountFlash;
            topAccel = settings.engineAccelerationFlash;
            break;
        case GlobalSettings.ESpeedClasses.Rapier:
            topThrust = settings.engineAmountRapier;
            topAccel = settings.engineAccelerationRapier;
            break;
        case GlobalSettings.ESpeedClasses.Phantom:
            topThrust = settings.engineAmountPhantom;
            topAccel = settings.engineAccelerationPhantom;
            break;
        }

        if (shipController.isThrusting)
        {
            engineGain = Mathf.Lerp(engineGain, (settings.engineGain * 0.1f) * Time.deltaTime, Time.deltaTime * 10);
            engineFalloff = 0;
            engineAcceleration = Mathf.Lerp(engineAcceleration, topAccel, Time.deltaTime * engineGain);
            engineThrust = Mathf.Lerp (engineThrust, topThrust + (enginePitchAmount * 25.0f), Time.deltaTime * (engineAcceleration * 0.1f));
        } else
        {
            engineFalloff = Mathf.Lerp(engineFalloff, settings.engineFalloff * Time.deltaTime, Time.deltaTime);
            engineGain = 0;
            engineAcceleration = Mathf.Lerp(engineAcceleration, 0.0f, Time.deltaTime * engineFalloff);
            engineThrust = Mathf.Lerp (engineThrust, 0.0f, Time.deltaTime * engineFalloff);
        }
        shipBody.AddRelativeForce(Vector3.forward * engineThrust);

        // Set the actual speed
        engineSpeed = Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).z);
    }

    private void ShipDrag()
    {
        // Airbrake Resistance
        if (shipController.axisLA != 0 || shipController.axisRA != 0)
        {
            float abi = Mathf.Abs(shipController.axisLA + shipController.axisRA);
            abi = Mathf.Clamp(abi, 0.0f, 1.0f);
            airbrakeResistance = Mathf.Lerp(airbrakeResistance, Mathf.Abs(airbrakeAmount) * abi, Time.deltaTime *
                                            (Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).x) * Time.deltaTime) * 0.15f); //0.07
        } else
        {
            airbrakeResistance = Mathf.Lerp(airbrakeResistance, 0.0f, Time.deltaTime * 4.5f);
        }

        // Air resistance
        if (shipGrounded)
        {
            airResistance = Mathf.Lerp(airResistance, 0.0f, Time.deltaTime * 4.5f);
            angularResistance = Mathf.Lerp (angularResistance, 0.0f, Time.deltaTime * 4.5f);
        } else
        {
            airResistance = Mathf.Lerp(airResistance, 0.4f, Time.deltaTime * (0.02f + (enginePitchAmount * 0.003f)));

            float ang = transform.InverseTransformDirection(shipBody.angularVelocity).x;
            ang = Mathf.Clamp(ang, 0.0f, 1.0f);
            angularResistance = Mathf.Lerp (angularResistance, 0.0f, Time.deltaTime * 0.05f);
        }

        // Brakes
        if (shipController.axisRA != 0 && shipController.axisLA != 0)
        {
            shipBraking = true;
            brakesFalloff = 0;
            brakesGain = Mathf.Lerp(brakesGain, Time.deltaTime * 40, Time.deltaTime);
            brakesAmount = Mathf.Lerp(brakesAmount, Time.deltaTime * 100, Time.deltaTime * brakesGain);
        } else
        {
            shipBraking = false;
            brakesGain = 0;
            brakesFalloff = Mathf.Lerp(brakesFalloff, 100.0f, Time.deltaTime);
            brakesAmount = Mathf.Lerp(brakesAmount, 0.0f, Time.deltaTime * brakesFalloff);
        }

        // Forward Resistance
        Vector3 LocalVelocity = transform.InverseTransformDirection(shipBody.velocity);
        float forwardVelocity = Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).z);
        LocalVelocity.z *= 1 - (0.0015f + ((forwardVelocity * Time.deltaTime) * 0.007f));
        LocalVelocity.z *= 1 - (airbrakeResistance + airResistance + angularResistance + brakesAmount);
        LocalVelocity.y *= 1 - (0.001f);
        Vector3 WorldVelocity = transform.TransformDirection(LocalVelocity);
        shipBody.velocity = WorldVelocity;

        // Slide resistance

        float gripAmount = settings.shipGrip_A;
        switch(eventClass)
        {
        case GlobalSettings.ESpeedClasses.Venom:
            if (shipGrounded)
            {
                gripAmount = settings.shipGrip_D;
            } else
            {
                gripAmount = settings.shipGrip_D * 0.8f;
            }
            break;
        case GlobalSettings.ESpeedClasses.Flash:
            if (shipGrounded)
            {
                gripAmount = settings.shipGrip_C;
            } else
            {
                gripAmount = settings.shipGrip_C * 0.8f;
            }
            break;
        case GlobalSettings.ESpeedClasses.Rapier:
            if (shipGrounded)
            {
                gripAmount = settings.shipGrip_B;
            } else
            {
                gripAmount = settings.shipGrip_B * 0.8f;
            }
            break;
        case GlobalSettings.ESpeedClasses.Phantom:
            if (shipGrounded)
            {
                gripAmount = settings.shipGrip_A;
            } else
            {
                gripAmount = settings.shipGrip_A * 0.8f;
            }
            break;
        }
        if (shipGrounded)
        {
            gripAmount -= enginePitchAmount * 0.4f;
        }
        if (shipController.axisLA != 0 || shipController.axisRA != 0)
        {
            airbrakeSlip = Mathf.Lerp (airbrakeSlip, Mathf.Abs(airbrakeAmount * settings.shipSlipAmount), Time.deltaTime * settings.shipSlipGain);
        } else
        {
            airbrakeSlip = Mathf.Lerp (airbrakeSlip, 0.0f, Time.deltaTime * settings.shipSlipFalloff);
        }
        gripAmount -= Mathf.Abs(airbrakeAmount * airbrakeSlip);
        if (gripAmount < 0)
            gripAmount = 0;


        float gripForce = -transform.InverseTransformDirection(shipBody.velocity).x;
        gripForce -= airbrakeAmount * settings.shipSlipAmount;
        shipBody.AddForce(transform.right * gripForce);

        Vector3 GripVelocity = shipBody.velocity;
        GripVelocity.y = 0;

        float slipAmount = Vector3.Dot(transform.right, GripVelocity);
        Vector3 antiSlip = transform.right * (-slipAmount * gripAmount);
        shipBody.AddForce(antiSlip, ForceMode.Acceleration);


    }

    private void ShipHandling()
    {
        // Get the airbrake input
        float airbrakeInput = shipController.axisLA + shipController.axisRA;

        // Stop reverse input from being given while gain is still above zero
        if ((shipController.axisSteer > 0 && turnAmount < 0) || (shipController.axisSteer < 0 && turnAmount > 0))
        {
            if (!turnAntiBand)
            {
                bankGain = 0;
                turnGain = 0;
                turnAntiBand = true;
            }
        } else
        {
            turnAntiBand = false;
        }

        if ((airbrakeInput > 0 && airbrakeAmount < 0) || (airbrakeInput < 0 && airbrakeAmount > 0))
        {
            if (!airbrakeAntiBand)
            {
                airbrakeGain = 0;
                airbrakeAntiBand = true;
            }
        } else
        {
            airbrakeAntiBand = false;
        }

        // Ship turning
        if (shipController.axisSteer != 0)
        {
            // Calculate Turn Amount
            float cta = settings.turnAmount * Time.deltaTime * Mathf.PI * 7.7f * 2;
            if (Mathf.Abs(turnAmount) > (Mathf.Abs(cta) / 2))
            {
                turnGain = Mathf.Lerp(turnGain, settings.turnGain * 0.01f, Time.deltaTime * 2);
            } else
            {
                turnGain = Mathf.Lerp(turnGain, settings.turnGain * 0.01f, Time.deltaTime * 1.2f);
            }
            turnFalloff = 0;
            turnAmount = Mathf.Lerp(turnAmount, shipController.axisSteer * cta, Time.deltaTime * turnGain);

            bankGain = Mathf.Lerp(bankGain, 8.0f, Time.deltaTime * 1.5f);
            bankFalloff = 0;
            bankVelocity = Mathf.Lerp(bankVelocity, shipController.axisSteer * 45.0f, Time.deltaTime * bankGain);
        } else
        {
            turnFalloff = Mathf.Lerp(turnFalloff, settings.turnFalloff * 0.01f, Time.deltaTime * 4);
            turnGain = 0;
            turnAmount = Mathf.Lerp(turnAmount, 0.0f, Time.deltaTime * turnFalloff);

            bankFalloff = Mathf.Lerp(bankFalloff, 10.0f, Time.deltaTime * 1.4f);
            bankGain = 0;
            bankVelocity = Mathf.Lerp(bankVelocity, 0.0f, Time.deltaTime * bankFalloff);
        }
        bankAmount = Mathf.Lerp(bankAmount, bankVelocity, Time.deltaTime * 10);

        // Calculated turn air brake
        float ctab = settings.airbrakeAmount * Time.deltaTime * Mathf.PI * 1.8f;

        // Airbrake Amount
        float aba = ((transform.InverseTransformDirection(shipBody.velocity).z) * Time.deltaTime) * ctab;

        if (airbrakeInput != 0)
        {
            airbrakeGain = Mathf.Lerp(airbrakeGain, settings.airbrakeGain * 0.01f, Time.deltaTime * 8);
            airbrakeFalloff = 0;
            airbrakeAmount = Mathf.Lerp(airbrakeAmount, airbrakeInput * aba, Time.deltaTime * (airbrakeGain + Mathf.Abs(turnAmount * settings.airbrakeTurnMultiplier)));

            bankAirbrake = Mathf.Lerp(bankAirbrake, -airbrakeInput * 10.0f, Time.deltaTime * 2);
        } else
        {
            airbrakeFalloff = Mathf.Lerp(airbrakeFalloff, settings.airbrakeFalloff * 0.01f, Time.deltaTime * 8);
            airbrakeGain = 0;
            airbrakeAmount = Mathf.Lerp(airbrakeAmount, 0.0f, Time.deltaTime * airbrakeFalloff);

            bankAirbrake = Mathf.Lerp(bankAirbrake, 0.0f, Time.deltaTime * 2);
        }


        // Apply rotation
        transform.Rotate(Vector3.up * (turnAmount + airbrakeAmount));

        // Apply banking
        shipAxis.transform.localRotation = Quaternion.Euler(0,0, -bankAmount + bankAirbrake + shipBRActual);

        // Airbrake rotation
        if (shipController.axisLA != 0)
        {
            airbrakeLeftRaise = Mathf.Lerp(airbrakeLeftRaise, -shipController.axisLA * settings.shipAirbrakeAngle, Time.deltaTime * 5);
        } else
        {
            airbrakeLeftRaise = Mathf.Lerp(airbrakeLeftRaise, 0.0f, Time.deltaTime * 4);
        }

        if (shipController.axisRA != 0)
        {
            airbrakeRightRaise = Mathf.Lerp(airbrakeRightRaise, shipController.axisRA * settings.shipAirbrakeAngle, Time.deltaTime * 5);
        } else
        {
            airbrakeRightRaise = Mathf.Lerp(airbrakeRightRaise, 0.0f, Time.deltaTime * 4);
        }

        // Apply rotation
        if (settings.shipRefAirbrakeRotationMode == 0)
        {
            Vector3 Rot = settings.shipRefLeftAirbrake.transform.localEulerAngles;
            settings.shipRefLeftAirbrake.transform.localRotation = Quaternion.Euler (airbrakeLeftRaise,Rot.y , Rot.z);
            Rot = settings.shipRefRightAirbrake.transform.localEulerAngles;
            settings.shipRefRightAirbrake.transform.localRotation = Quaternion.Euler (airbrakeRightRaise,Rot.y , Rot.z);
        } else
        {
            Vector3 Rot = settings.shipRefLeftAirbrake.transform.localEulerAngles;
            settings.shipRefLeftAirbrake.transform.localRotation = Quaternion.Euler (Rot.x ,Rot.y , -airbrakeLeftRaise);
            Rot = settings.shipRefRightAirbrake.transform.localEulerAngles;
            settings.shipRefRightAirbrake.transform.localRotation = Quaternion.Euler (Rot.x,Rot.y , airbrakeRightRaise);
        }


    }
    public void UpdateCameraMode()
    {
        cameraMode ++;
        if (cameraMode > 2)
            cameraMode = 0;
    }

    private void UpdateShipCamera()
    {
        if (cameraMode == 0)
        {
            shipAxis.SetActive(true);
            // Update X Offset
            cameraInputAmount = Mathf.Lerp (cameraInputAmount, -transform.InverseTransformDirection(shipBody.velocity).x, Time.deltaTime * settings.cameraSpeed);
            if (settings.cameraTurnDamp == 0)
            {
                cameraTurnAmount = turnAmount;
            }
            else
            {
                cameraTurnAmount = Mathf.Lerp(cameraTurnAmount, turnAmount, Time.deltaTime * (settings.cameraTurnDamp));
            }
            cameraOffset.x = Mathf.Lerp(cameraOffset.x, cameraInputAmount * 0.012f + ((cameraTurnAmount * settings.cameraTurnSensitivity) + airbrakeAmount), Time.deltaTime * (settings.cameraSpeed * 0.8f));

            // Update Y Offset
            cameraFallHelper = Mathf.Lerp (cameraFallHelper,((settings.cameraClosePos.y - cameraTurningHeight )- shipCamera.transform.localPosition.y), Time.deltaTime * (settings.cameraSpeed * 0.1f));
            cameraFallHelper = Mathf.Clamp(cameraFallHelper, 0f, 0.03f);
            cameraFallLag = Mathf.Lerp
                (
                    cameraFallLag,
                    transform.InverseTransformDirection(shipBody.velocity).y * (0.05f - cameraFallHelper),
                    Time.deltaTime * settings.cameraSpeed
                );
            cameraTurningHeight = Mathf.Lerp(cameraTurningHeight, (Mathf.Abs(cameraOffset.x) * 0.3f), Time.deltaTime * (settings.cameraSpeed * 0.5f));
            cameraOffset.y = settings.cameraClosePos.y - cameraFallLag + (cameraBoostLength * 0.7f);

            // Update Z Offset
            if (shipGrounded)
            {
                cameraFallingOffset = Mathf.Lerp(cameraFallingOffset, 0.0f, Time.deltaTime * 2.0f);
            } else
            {
                cameraFallingOffset = Mathf.Lerp(cameraFallingOffset, -2, Time.deltaTime * 0.05f);
            }
            cameraAccelLag = Mathf.Lerp(cameraAccelLag, -(transform.InverseTransformDirection(shipBody.velocity).z * Time.deltaTime) * 0.25f, Time.deltaTime * settings.cameraSpeed);
            cameraTurningOffset = Mathf.Lerp(cameraTurningOffset, (Mathf.Abs(cameraOffset.x) * 0.2f), Time.deltaTime * (settings.cameraSpeed * 0.2f));
            cameraOffset.z = settings.cameraClosePos.z + cameraAccelLag + cameraTurningOffset - cameraBoostLength;

            // Update movement length
            if (shipController.isThrusting)
            {
                cameraMovementLength = Mathf.Lerp(cameraMovementLength, 6.5f, Time.deltaTime * 3);
            } else
            {
                if ((shipController.axisLA != 0 || shipController.axisRA != 0) && transform.InverseTransformDirection(shipBody.velocity).z > 10)
                {
                    cameraMovementLength = Mathf.Lerp(cameraMovementLength, -7.5f, Time.deltaTime * 3);
                } else
                {
                    cameraMovementLength = Mathf.Lerp(cameraMovementLength, 0.0f, Time.deltaTime * 3);
                }
            }

            // Update Position
            shipCamera.transform.parent = transform;
            shipCamera.transform.localPosition = cameraOffset + (-shipHoverCameraAnimOffset * 0.4f);

            // Update Rotation
            float pitchModUpdateRate = Mathf.Abs(transform.InverseTransformDirection(shipBody.angularVelocity).x) * 0.5f;
            pitchModUpdateRate = Mathf.Clamp(pitchModUpdateRate, 0.1f, Mathf.Infinity);
            float pitchModAmount = transform.InverseTransformDirection(shipBody.velocity).z * 0.04f;
            pitchModAmount = Mathf.Clamp(pitchModAmount, 0.0f, 16.0f);
            cameraPitchMod = Mathf.Lerp(cameraPitchMod, transform.InverseTransformDirection(shipBody.angularVelocity).x * pitchModAmount, Time.deltaTime * settings.cameraSpeed);

            Vector3 lookAtLocal = transform.TransformPoint(0, -4, 25 + cameraPitchMod + cameraMovementLength);
            shipCamera.transform.rotation = Quaternion.LookRotation(lookAtLocal - shipCamera.transform.position, transform.up);
        } else if (cameraMode == 2)
        {
            shipAxis.SetActive(false);
            shipCamera.transform.parent = transform;
            shipCamera.transform.localPosition = Vector3.zero;
            shipCamera.transform.localRotation = Quaternion.Euler(0,0, -bankAmount * 1.3f);
        } else if (cameraMode == 1)
        {
            shipAxis.SetActive(true);
            shipCamera.transform.parent = transform;

            int nextGate = Mathf.RoundToInt(Mathf.Repeat(shipController.manGate + 1, shipController.nodes.logicNodes.Count));
            Vector3 currentGate = transform.InverseTransformPoint(shipController.nodes.logicNodes[nextGate].transform.position);
            currentGate = shipController.nodes.logicNodes[nextGate].transform.InverseTransformPoint(shipCamera.transform.position);
            cameraOffset = Vector3.Lerp(cameraOffset, currentGate, Time.deltaTime * (settings.cameraSpeed * 0.4f));

            float vel = Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).x);
            cameraFallHelper = Mathf.Lerp(cameraFallHelper, airbrakeAmount * 5, Time.deltaTime * (settings.cameraSpeed * 0.3f));
            cameraTurningOffset = Mathf.Lerp(cameraTurningOffset, (Mathf.Abs(cameraFallHelper) * 1) + (Mathf.Abs(cameraOffset.x) * 0.02f), Time.deltaTime * (settings.cameraSpeed * 0.2f));
            cameraTurningHeight = Mathf.Lerp(cameraTurningHeight, (Mathf.Abs(cameraFallHelper) * 1) + (Mathf.Abs(cameraOffset.x) * 0.07f), Time.deltaTime * (settings.cameraSpeed * 0.3f));
            cameraInputAmount = Mathf.Lerp(cameraInputAmount, -cameraOffset.x * 0.1f, Time.deltaTime * (settings.cameraSpeed * 0.2f));

            shipCamera.transform.localPosition = new Vector3(cameraInputAmount + cameraFallHelper, (settings.cameraClosePos.y * 0.8f) + cameraTurningHeight, (settings.cameraClosePos.z * 1.1f) + cameraTurningOffset);

            Vector3 lookAtLocal = transform.TransformPoint(0, -4, 25);
            shipCamera.transform.rotation = Quaternion.LookRotation(lookAtLocal - shipCamera.transform.position, transform.up);

        }

        // Update camera Fov
        float fovVel = ((Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).z) * Time.deltaTime) * 10);
        cameraFoV = Mathf.Lerp(cameraFoV, settings.cameraFoV + fovVel, Time.deltaTime * settings.cameraSpeed);
        if (cameraFoV < 60)
            cameraFoV = 60;

        if (isBoosting)
        {
            cameraBoostFoV = Mathf.Lerp(cameraBoostFoV, 10, Time.deltaTime * 16);
            cameraBoostLength = Mathf.Lerp(cameraBoostLength, 0.1f, Time.deltaTime * 16);
        } else
        {
            cameraBoostFoV = Mathf.Lerp(cameraBoostFoV, 0.0f, Time.deltaTime * 3);
            cameraBoostLength = Mathf.Lerp(cameraBoostLength, 0.0f, Time.deltaTime * 4);
        }
        shipCamera.GetComponent<Camera>().fieldOfView = cameraFoV + cameraBoostFoV;

    }

    private void ShipAnimations()
    {
        if (Mathf.Abs(transform.InverseTransformDirection(shipBody.velocity).z) < 100 && shipGrounded)
        {
            // Anim Settings
            shipHoverAnimSpeed = 0.5f;
            shipHoverAnimAmount = 0.2f;

            shipHoverAnimTimer += Time.deltaTime * shipHoverAnimSpeed;
            shipHoverAnimOffset.x = (Mathf.Sin(shipHoverAnimTimer * 1.5f) * (shipHoverAnimAmount * Mathf.Sin(shipHoverAnimTimer)));
            shipHoverAnimOffset.y = (Mathf.Cos(shipHoverAnimTimer * 4) * (shipHoverAnimAmount / 5));

            shipHoverCameraAnimOffset.x = (Mathf.Sin(shipHoverAnimTimer * 6) * (shipHoverAnimAmount / 2));
            shipHoverCameraAnimOffset.y = (Mathf.Cos(shipHoverAnimTimer * 3) * (shipHoverAnimAmount / 2));

        } else
        {
            shipHoverAnimTimer = 0;
            shipHoverAnimOffset = Vector3.Lerp(shipHoverAnimOffset, Vector3.zero, Time.deltaTime);
            shipHoverCameraAnimOffset = Vector3.Lerp(shipHoverAnimOffset, Vector3.zero, Time.deltaTime);
        }

        // Apply Hover Anim Offset
        shipAxis.transform.localPosition = shipHoverAnimOffset;
    }

    private void ShipBarrelRolls()
    {
        if (shipBRBoostTimer > 0)
        {
            shipBRBoostTimer -= Time.deltaTime;
        }

        /* Ground vs Airborne setup */
        if (shipGrounded)
        {
            shipBRProgress = Mathf.LerpAngle(shipBRProgress, 0.0f, Time.deltaTime * 10.0f);
            shipBRGain = 0;
            shipBRActual = shipBRProgress;
            if (shipBRSuccess && shipController.performedBarrelRolls < EventSettings.setupMaxBarrelRolls + 1)
            {
                AudioLibrary.Create3DOneShot("BR", 1.0f, 1.0f, transform, Vector3.zero, 500.0f, 400.0f, "Audio/Ships/Turbo", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                shipBRBoostTimer = 0.24f;
                shipBRSuccess = false;
            }
            shipBRLastValue = 0;
            shipBRState =0;
            shipCanBR = false;
            shipHasBR = false;
        } else
        {
            shipCanBR = true;
        }

        if (shipCanBR)
        {
            shipBRTimer -= Time.deltaTime;
            if (shipBRTimer < 0)
            {
                shipBRLastValue = 0;
                shipBRState = 0;
                shipBRTimer = 0;
                if (!shipHasBR)
                {
                    shipBRSuccess = false;
                }
            }

            if (!shipHasBR)
            {
                shipBRProgress = 0;
                shipBRGain = 0;

                /*LRL */
                if (shipController.axisSteer < 0 && shipBRState == 0)
                {
                    shipBRLastValue = -1;
                    shipBRTimer = 0.2f;
                    shipBRState++;
                }

                if (shipController.axisSteer > 0 && shipBRLastValue == -1 && shipBRState == 1 && shipBRTimer > 0)
                {
                    shipBRLastValue = 1;
                    shipBRTimer = 0.2f;
                    shipBRState++;
                }

                if (shipController.axisSteer < 0 && shipBRLastValue == 1 && shipBRState == 2 && shipBRTimer > 0)
                {
                    shipHasBR = true;
                    if (shipController.performedBarrelRolls < EventSettings.setupMaxBarrelRolls)
                    {
                        AudioLibrary.Create3DOneShot("BR", 1.0f, 1.0f, transform, Vector3.zero, 500.0f, 400.0f, "Audio/Ships/Roll", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                        shipIntegrity -= 15;
                    } else
                    {
                        AudioLibrary.Create3DOneShot("BR", 0.4f, 1.0f, transform, Vector3.zero, 500.0f, 400.0f, "Audio/Ships/Roll", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                    }

                    shipController.performedBarrelRolls ++;
                }

                /*RLR */
                if (shipController.axisSteer > 0 && shipBRState == 0)
                {
                    shipBRLastValue = 1;
                    shipBRTimer = 0.2f;
                    shipBRState++;
                }

                if (shipController.axisSteer < 0 && shipBRLastValue == 1 && shipBRState == 1 && shipBRTimer > 0)
                {
                    shipBRLastValue = -1;
                    shipBRTimer = 0.2f;
                    shipBRState++;
                }

                if (shipController.axisSteer > 0 && shipBRLastValue == -1 && shipBRState == 2 && shipBRTimer > 0)
                {
                    shipHasBR = true;
                    if (shipController.performedBarrelRolls < EventSettings.setupMaxBarrelRolls)
                    {
                        AudioLibrary.Create3DOneShot("BR", 1.0f, 1.0f, transform, Vector3.zero, 500.0f, 400.0f, "Audio/Ships/Roll", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                        shipIntegrity -= 15;
                    } else
                    {
                        AudioLibrary.Create3DOneShot("BR", 0.4f, 1.0f, transform, Vector3.zero, 500.0f, 400.0f, "Audio/Ships/Roll", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
                    }

                    shipController.performedBarrelRolls ++;
                }
            } else
            {
                shipBRState = 0;
                shipBRLastValue = 0;
                if (shipBRProgress < 260)
                {
                    shipBRGain = Mathf.Lerp(shipBRGain, 1000, Time.deltaTime * 10);
                } else
                {
                    shipBRGain = Mathf.Lerp(shipBRGain, 200, Time.deltaTime * 10);
                }
                shipBRProgress = Mathf.MoveTowards(shipBRProgress, 360, Time.deltaTime * shipBRGain);
                if (shipBRProgress > 250)
                {
                    shipBRSuccess = true;
                    shipCanBR = false;
                }

                if (shipBRProgress > 360)
                    shipBRProgress = 360;

                if (shipBRLastValue == 1)
                {
                    shipBRActual = shipBRProgress;
                } else
                {
                    shipBRActual = -shipBRProgress;
                }
            }
        } else
        {
            shipBRLastValue = 0;
            shipBRTimer = 0;
            shipBRSuccess = false;
            shipHasBR = false;
            shipBRState = 0;
        }
    }

    private void OnCollisionEnter(Collision other)
    {
        if (other.gameObject.layer == LayerMask.NameToLayer("TrackWall"))
        {
            float hitDot = Vector3.Dot(other.contacts[0].normal, transform.forward);
            Vector3 collisionVelocity = transform.InverseTransformDirection(shipBody.GetPointVelocity(other.contacts[0].point));
            if (Mathf.Abs(collisionVelocity.x) >= 65 && hitDot > 0)
            {
                AudioLibrary.Create3DOneShot("WallCollision", 1.0f, Random.Range(0.8f, 1.1f), transform, Vector3.zero, 400.0f, 500.0f, "Audio/Ships/CollisionWall", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
            } else if (Mathf.Abs(collisionVelocity.x) >= 65)
            {
                AudioLibrary.Create3DOneShot("WallCollision", 1.0f, Random.Range(0.8f, 1.1f), transform, Vector3.zero, 400.0f, 500.0f, "Audio/Ships/CollisionWall", shipController.manager.mixer, GlobalSettings.EAudioGroups.SFX);
            }
        }

    }

    private void OnCollisionStay(Collision other)
    {
        if (other.gameObject.layer == LayerMask.NameToLayer("TrackWall"))
        {
            // Stop physics rotation
            shipBody.angularVelocity = Vector3.zero;

            isColliding = true;
            float hitDot = Vector3.Dot(other.contacts[0].normal, transform.forward);
            if (hitDot < 0.1f)
            {
                if (engineThrust > 100)
                {
                    engineThrust *= (0.95f);
                }
                if (engineAcceleration > 5)
                {
                    engineAcceleration *= 0.98f;
                }
                wallSurfing = false;

                if (hitDot < -0.8f)
                {
                    engineThrust = 0;
                    engineAcceleration = 0;
                }
            }
            Vector3 collisionVector = transform.InverseTransformPoint(other.contacts[0].point);
            if (hitDot < 0)
                transform.Rotate(Vector3.up * ((hitDot * 0.3f) * (collisionVector.x * 0.2f)));
        }
    }

    void OnCollisionExit(Collision other)
    {
        wallSurfing = false;
        isColliding = false;
    }
}