void SteeringForce()
    {
        Axle axle = frontAxle;

        if (axle.leftWheel.isGrounded)
        {
            rb.AddForceAtPosition(transform.right * steeringPower * Time.deltaTime * inputs.steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.leftWheel)), ForceMode.Acceleration);
        }

        if (axle.rightWheel.isGrounded)
        {
            rb.AddForceAtPosition(transform.right * steeringPower * Time.deltaTime * inputs.steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.rightWheel)), ForceMode.Acceleration);
        }

        if (tankSteering)
        {
            axle = rearAxle;

            if (axle.leftWheel.isGrounded)
            {
                rb.AddForceAtPosition(-transform.right * steeringPower * Time.deltaTime * inputs.steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.leftWheel)), ForceMode.Acceleration);
            }

            if (axle.rightWheel.isGrounded)
            {
                rb.AddForceAtPosition(-transform.right * steeringPower * Time.deltaTime * inputs.steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.rightWheel)), ForceMode.Acceleration);
            }
        }
    }
Beispiel #2
0
    private void AntiRoll(Axle axle)
    {
        // Handle AntiRoll
        bool     leftHit, rightHit;
        float    leftTravel = 1f, rightTravel = 1f;
        float    antirollForce;
        WheelHit hit;

        leftHit = axle.leftWheel.GetGroundHit(out hit);
        if (leftHit)
        {
            leftTravel = (-axle.leftWheel.transform.InverseTransformPoint(hit.point).y - axle.leftWheel.radius) / axle.leftWheel.suspensionDistance;
        }
        rightHit = axle.rightWheel.GetGroundHit(out hit);
        if (rightHit)
        {
            rightTravel = (-axle.rightWheel.transform.InverseTransformPoint(hit.point).y - axle.rightWheel.radius) / axle.rightWheel.suspensionDistance;
        }
        antirollForce = (leftTravel - rightTravel) * axle.antirollStiffness;

        if (leftHit)
        {
            car_rb.AddForceAtPosition(transform.up * -antirollForce, axle.leftWheel.transform.position);
        }
        if (rightHit)
        {
            car_rb.AddForceAtPosition(transform.up * antirollForce, axle.rightWheel.transform.position);
        }
    }
Beispiel #3
0
 public TPM(Axle _axelLoc, string _StemID, string _PSI, Esys.IO.TypeOfStem _StemType)
 {
     axelLoc = _axelLoc;
     StemID = _StemID;
     PSI = _PSI;
     StemType = _StemType;
 }
Beispiel #4
0
    void CalculateWheelRotationFromSpeed(Axle axle, WheelData data, Vector3 wsPos)
    {
        if (rb == null)
        {
            data.visualRotationRad = 0.0f;
            return;
        }

        Quaternion localWheelRot = Quaternion.Euler(new Vector3(0.0f, data.yawRad * Mathf.Rad2Deg, 0.0f));
        Quaternion wsWheelRot    = transform.rotation * localWheelRot;

        Vector3 wsWheelForward   = wsWheelRot * Vector3.forward;
        Vector3 velocityQueryPos = data.isOnGround ? data.touchPoint.point : wsPos;
        Vector3 wheelVelocity    = rb.GetPointVelocity(velocityQueryPos);
        // Longitudinal speed (meters/sec)
        float tireLongSpeed = Vector3.Dot(wheelVelocity, wsWheelForward);

        // Circle length = 2 * PI * R
        float wheelLengthMeters = 2 * Mathf.PI * axle.radius;

        // Wheel "Revolutions per second";
        float rps = tireLongSpeed / wheelLengthMeters;

        float deltaRot = Mathf.PI * 2.0f * rps * Time.deltaTime;

        data.visualRotationRad += deltaRot;
    }
    private void Start()
    {
        _style.fontSize         = 19;
        _style.normal.textColor = Color.magenta;

        //Use player prefs to setup car values according to their choice in the main menu
        _maxMotorTorque   = Mathf.RoundToInt(_maxMotorTorque * PlayerPrefs.GetFloat("Torque setting"));
        _maxSteeringAngle = Mathf.RoundToInt(_maxSteeringAngle * PlayerPrefs.GetFloat("Angle setting"));

        Transform wheelsList = gameObject.transform.Find("Wheels");

        _axles[0] = new Axle
        {
            LeftWheel  = wheelsList.Find("Front Left").GetComponent <WheelCollider>(),
            RightWheel = wheelsList.Find("Front Right").GetComponent <WheelCollider>(),
            Motor      = true,
            Steering   = true
        };

        _axles[1] = new Axle
        {
            LeftWheel  = wheelsList.Find("Back Left").GetComponent <WheelCollider>(),
            RightWheel = wheelsList.Find("Back Right").GetComponent <WheelCollider>()
        };

        _rb = GetComponent <Rigidbody>();
    }
Beispiel #6
0
        private static Truck CreateDummyTruck()
        {
            var frontAxle = new Axle(0, 5000, 20000);
            var rearAxle  = new Axle(500, 8000, 30000);

            return(new Truck(frontAxle, rearAxle, containerWidth,
                             containerHeight, containerDepth, containerOffset));
        }
Beispiel #7
0
 internal Bogie(Train train, Car car)
 {
     baseTrain   = train;
     baseCar     = car;
     CarSections = new CarSection[] { };
     FrontAxle   = new Axle(train, car);
     RearAxle    = new Axle(train, car);
 }
Beispiel #8
0
 public Bogie(AbstractTrain train, CarBase car)
 {
     baseTrain   = train;
     baseCar     = car;
     CarSections = new CarSection[] { };
     FrontAxle   = new Axle(TrainManagerBase.currentHost, train, car);
     RearAxle    = new Axle(TrainManagerBase.currentHost, train, car);
 }
Beispiel #9
0
 internal Bogie(Train train, Car car)
 {
     baseTrain   = train;
     baseCar     = car;
     CarSections = new CarSection[] { };
     FrontAxle   = new Axle(Program.CurrentHost, train, car);
     RearAxle    = new Axle(Program.CurrentHost, train, car);
 }
Beispiel #10
0
    //-=-------------------------------------------------

    public void ControlCar()
    {
        float motor = maxMotorTorque * Input.GetAxis("Vertical");

        float steer = maxSteeringAngle * Input.GetAxis("Horizontal");

        //if(R.velocity.magnitude>

        SPD.S = (int)(R.velocity.magnitude);

        Debug.Log("speed=" + R.velocity.magnitude + " torque= L=" + axlelist [0].LeftWheel.motorTorque + "  R =" + axlelist [0].RightWheel.motorTorque);

        for (int i = 0; i < axlelist.Length; i++)
        {
            Axle A = axlelist [i];

            if (A.steering)
            {
                A.LeftWheel.steerAngle  = steer;
                A.RightWheel.steerAngle = steer;
            }

            A.LeftWheel.brakeTorque  = 0;
            A.RightWheel.brakeTorque = 0;


            if (A.Motor)
            {
                A.LeftWheel.motorTorque  = motor;
                A.RightWheel.motorTorque = motor;

                if (A.LeftWheel.rpm > 1500)
                {
                    A.LeftWheel.motorTorque = 0;
                }
                if (A.RightWheel.rpm > 1500)
                {
                    A.RightWheel.motorTorque = 0;
                }
            }

            DoRollBar(A.LeftWheel, A.RightWheel);

            // left wheel graphic
            ApplyGraphictoWheel(A.LeftWheel);
            //right wheel graphic
            ApplyGraphictoWheel(A.RightWheel);
        }

        if (Input.GetKey(KeyCode.Space))
        {
            //brake

            Break();
            Debug.Log("break motortorque=" + axlelist[0].LeftWheel.motorTorque);
        }
    }
        public static Instance Generate(int itemsAmount = 10, int width = 200, int height = 300, int depth = 500)
        {
            var items = GenerateItems(itemsAmount, width, height, depth);

            var frontAxle       = new Axle(200, 5000, 20000);
            var rearAxle        = new Axle(700, 8000, 30000);
            var containerOffset = 200;

            return(new Instance(items, new Truck(frontAxle, rearAxle, width, height, depth, containerOffset)));
        }
Beispiel #12
0
    void CalculateAxleForces(Axle axle, int totalWheelsCount, int numberOfPoweredWheels)
    {
        Vector3 wsDownDirection = transform.TransformDirection(Vector3.down);

        // Debug.Log(string.Format("方向在经过从本地到世界后为wsD {0}", wsDownDirection));
        wsDownDirection.Normalize();
        // Debug.Log(string.Format("归一化了以后wsD {0}", wsDownDirection));

        Vector3 localL = new Vector3(axle.width * -0.5f, axle.offset.y, axle.offset.x);
        Vector3 localR = new Vector3(axle.width * 0.5f, axle.offset.y, axle.offset.x);
        // Debug.Log(string.Format("本地左{0}本地右{1}", localL,localR));

        Vector3 wsL = transform.TransformPoint(localL);
        Vector3 wsR = transform.TransformPoint(localR);

        // For each wheel
        for (int wheelIndex = 0; wheelIndex < 2; wheelIndex++)
        {
            WheelData wheelData = (wheelIndex == WHEEL_LEFT_INDEX) ? axle.wheelDataL : axle.wheelDataR;
            Vector3   wsFrom    = (wheelIndex == WHEEL_LEFT_INDEX) ? wsL : wsR;

            // Debug.Log(string.Format("wsDownDirection {0}", wsDownDirection));


            CalculateWheelForces(axle, wsDownDirection, wheelData, wsFrom, wheelIndex, totalWheelsCount, numberOfPoweredWheels);
        }

        // http://projects.edy.es/trac/edy_vehicle-physics/wiki/TheStabilizerBars
        // Apply "stablizier bar" forces
        float travelL = 1.0f - Mathf.Clamp01(axle.wheelDataL.compression);
        float travelR = 1.0f - Mathf.Clamp01(axle.wheelDataR.compression);

        float antiRollForce = (travelL - travelR) * axle.antiRollForce;

        if (axle.wheelDataL.isOnGround)
        {
            // Debug.Log(string.Format("左轮这里有施加平衡力,"));
            AddForceAtPosition(wsDownDirection * antiRollForce, axle.wheelDataL.touchPoint.point);

            if (debugDraw)
            {
                Debug.DrawRay(axle.wheelDataL.touchPoint.point, wsDownDirection * antiRollForce, Color.magenta);
            }
        }

        if (axle.wheelDataR.isOnGround)
        {
            // Debug.Log(string.Format("右轮这里有施加平衡力,"));
            AddForceAtPosition(wsDownDirection * -antiRollForce, axle.wheelDataR.touchPoint.point);
            if (debugDraw)
            {
                // Debug.DrawRay(axle.wheelDataR.touchPoint.point, wsDownDirection * -antiRollForce, Color.magenta);
            }
        }
    }
    void CalculateAckermannSteering()
    {
        // Copy desired steering
        for (int axleIndex = 0; axleIndex < axles.Length; axleIndex++)
        {
            float steerAngleRad = axles[axleIndex].steerAngle * Mathf.Deg2Rad;

            axles[axleIndex].wheelDataL.yawRad = steerAngleRad;
            axles[axleIndex].wheelDataR.yawRad = steerAngleRad;
        }

        if (axles.Length != 2)
        {
            Debug.LogWarning("Ackermann work only for 2 axle vehicles.");
            return;
        }

        Axle frontAxle = axles[0];
        Axle rearAxle  = axles[1];

        if (Mathf.Abs(rearAxle.steerAngle) > 0.0001f)
        {
            Debug.LogWarning("Ackermann work only for vehicles with forward steering axle.");
            return;
        }

        // Calculate our chassis (remove scale)
        Vector3 axleDiff       = transform.TransformPoint(new Vector3(0.0f, frontAxle.offset.y, frontAxle.offset.x)) - transform.TransformPoint(new Vector3(0.0f, rearAxle.offset.y, rearAxle.offset.x));
        float   axleSeparation = axleDiff.magnitude;

        Vector3 wheelDiff        = transform.TransformPoint(new Vector3(frontAxle.width * -0.5f, frontAxle.offset.y, frontAxle.offset.x)) - transform.TransformPoint(new Vector3(frontAxle.width * 0.5f, frontAxle.offset.y, frontAxle.offset.x));
        float   wheelsSeparation = wheelDiff.magnitude;

        if (Mathf.Abs(frontAxle.steerAngle) < 0.001f)
        {
            // Sterring wheels are not turned
            return;
        }

        // Simple right-angled triangle math (find cathet if we know another cathet and angle)

        // Find cathet from cathet and angle
        //
        // axleSeparation - is first cathet
        // steerAngle - is angle between cathet and hypotenuse
        float rotationCenterOffsetL = axleSeparation / Mathf.Tan(frontAxle.steerAngle * Mathf.Deg2Rad);

        // Now we have another 2 cathet's (rotationCenterOffsetR and axleSeparation for second wheel)
        //  need to find right angle
        float rotationCenterOffsetR = rotationCenterOffsetL - wheelsSeparation;

        float rightWheelYaw = Mathf.Atan(axleSeparation / rotationCenterOffsetR);

        frontAxle.wheelDataR.yawRad = rightWheelYaw;
    }
Beispiel #14
0
    public void Init(VehicleSetUpData setupData, VehicleInput vehicleInput, List <Axle> axles)
    {
        m_vehicleInput = vehicleInput;
        //m_maxWheelTorque = setupData.MaxEngineTorque;
        m_rigidBody = GetComponent <Rigidbody>();
        //m_rigidBody.centerOfMass = setupData.

        //TODO null check, should also be a list
        m_front = axles[0];
        m_rear  = axles[1];
    }
Beispiel #15
0
 internal Car(Train train)
 {
     FrontAxle = new Axle(Program.CurrentHost, train, this);
     RearAxle  = new Axle(Program.CurrentHost, train, this);
     CarBrake  = new ElectromagneticStraightAirBrake(EletropneumaticBrakeType.None, train.Handles.EmergencyBrake, train.Handles.Reverser, true, 0.0, 0.0, new AccelerationCurve[] {});
     CarBrake.mainReservoir   = new MainReservoir(690000.0);
     CarBrake.brakePipe       = new BrakePipe(690000.0);
     CarBrake.brakeCylinder   = new BrakeCylinder(0.0);
     CarBrake.straightAirPipe = new StraightAirPipe(690000.0);
     Doors = new Door[2];
 }
Beispiel #16
0
    void Awake()
    {
        Rigidbody2D     = GetComponent <Rigidbody2D> ();
        CenterOfGravity = transform.Find("CenterOfGravity").gameObject;

        AxleFront = transform.Find("AxleFront").GetComponent <Axle>();
        AxleRear  = transform.Find("AxleRear").GetComponent <Axle>();

        Engine = transform.Find("Engine").GetComponent <Engine>();

        Init();
    }
Beispiel #17
0
    void ApplyVisual()
    {
        Vector3 wsDownDirection = transform.TransformDirection(Vector3.down);

        wsDownDirection.Normalize();


        for (int axleIndex = 0; axleIndex < axles.Length; axleIndex++)
        {
            Axle axle = axles[axleIndex];

            Vector3 localL = new Vector3(axle.width * -0.5f, axle.offset.y, axle.offset.x);
            Vector3 localR = new Vector3(axle.width * 0.5f, axle.offset.y, axle.offset.x);

            Vector3 wsL = transform.TransformPoint(localL);
            Vector3 wsR = transform.TransformPoint(localR);
            // Debug.Log(string.Format("wsL{0}wsR{1}轮子信息{2}", wsL, wsR, axle.wheelDataL.visualRotationRad));

            Vector3    wsPos;
            Quaternion wsRot;
            // 下面两段话就是对于轮子世界定位的初始化
            if (axle.wheelVisualLeft != null)
            {
                CalculateWheelVisualTransform(wsL, wsDownDirection, axle, axle.wheelDataL, WHEEL_LEFT_INDEX, axle.wheelDataL.visualRotationRad, out wsPos, out wsRot);
                // Debug.Log(string.Format("左轮世界定位{0},世界角度{1}",wsPos,wsRot));
                axle.wheelVisualLeft.transform.position   = wsPos;
                axle.wheelVisualLeft.transform.rotation   = wsRot;
                axle.wheelVisualLeft.transform.localScale = new Vector3(axle.radius, axle.radius, axle.radius) * axle.visualScale;

                if (!isBrake)
                {
                    CalculateWheelRotationFromSpeed(axle, axle.wheelDataL, wsPos);
                }
            }

            if (axle.wheelVisualRight != null)
            {
                CalculateWheelVisualTransform(wsR, wsDownDirection, axle, axle.wheelDataR, WHEEL_RIGHT_INDEX, axle.wheelDataR.visualRotationRad, out wsPos, out wsRot);
                // Debug.Log(string.Format("右轮世界定位{0},世界角度{1}",wsPos,wsRot));
                axle.wheelVisualRight.transform.position   = new Vector3(wsPos.x, wsPos.y, wsPos.z);
                axle.wheelVisualRight.transform.rotation   = wsRot;
                axle.wheelVisualRight.transform.localScale = new Vector3(axle.radius, axle.radius, axle.radius) * axle.visualScale;

                if (!isBrake)
                {
                    CalculateWheelRotationFromSpeed(axle, axle.wheelDataR, wsPos);
                }
            }

            //visualRotationRad
        }
    }
Beispiel #18
0
        public double GetStaticMoment(Axle axle)
        {
            if (Sign == Sign.Zero)
            {
                return(0.0);
            }

            if (axle == Axle.X)
            {
                return(Area * GravityCenter.Y);
            }
            return(Area * GravityCenter.X);
        }
Beispiel #19
0
    void SteeringForce()
    {
        Axle axle = axles[Axle.FRONT_AXLE_INDEX];

        if (axle.leftWheel.isGrounded)
        {
            rb.AddForceAtPosition(transform.right * steeringPower * Time.deltaTime * steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.rightWheel)), ForceMode.Acceleration);
        }

        if (axle.rightWheel.isGrounded)
        {
            rb.AddForceAtPosition(transform.right * steeringPower * Time.deltaTime * steeringInput / 2, FixToCarCentre(WheelPosition(axle, axle.rightWheel)), ForceMode.Acceleration);
        }
    }
Beispiel #20
0
    void OnDrawGizmosAxle(Vector3 wsDownDirection, Axle axle)
    {
        Vector3 localL = new Vector3(axle.width * -0.5f, axle.offset.y, axle.offset.x);
        Vector3 localR = new Vector3(axle.width * 0.5f, axle.offset.y, axle.offset.x);

        Vector3 wsL = transform.TransformPoint(localL);
        Vector3 wsR = transform.TransformPoint(localR);

        Gizmos.color = axle.debugColor;

        //draw axle
        Gizmos.DrawLine(wsL, wsR);

        //draw line to com
        Gizmos.DrawLine(transform.TransformPoint(new Vector3(0.0f, axle.offset.y, axle.offset.x)), transform.TransformPoint(centerOfMass));

        for (int wheelIndex = 0; wheelIndex < 2; wheelIndex++)
        {
            WheelData wheelData = (wheelIndex == WHEEL_LEFT_INDEX) ? axle.wheelDataL : axle.wheelDataR;
            Vector3   wsFrom    = (wheelIndex == WHEEL_LEFT_INDEX) ? wsL : wsR;

            Gizmos.color = wheelData.isOnGround ? Color.yellow : axle.debugColor;
            UnityEditor.Handles.color = Gizmos.color;

            float suspCurrentLen = Mathf.Clamp01(1.0f - wheelData.compression) * axle.lengthRelaxed;

            Vector3 wsTo = wsFrom + wsDownDirection * suspCurrentLen;

            // Draw suspension
            Gizmos.DrawLine(wsFrom, wsTo);

            Quaternion localWheelRot = Quaternion.Euler(new Vector3(0.0f, wheelData.yawRad * Mathf.Rad2Deg, 0.0f));
            Quaternion wsWheelRot    = transform.rotation * localWheelRot;

            Vector3 localAxle = (wheelIndex == WHEEL_LEFT_INDEX) ? Vector3.left : Vector3.right;
            Vector3 wsAxle    = wsWheelRot * localAxle;
            Vector3 wsForward = wsWheelRot * Vector3.forward;

            // Draw wheel axle
            Gizmos.DrawLine(wsTo, wsTo + wsAxle * 0.1f);
            Gizmos.DrawLine(wsTo, wsTo + wsForward * axle.radius);

            // Draw wheel
            UnityEditor.Handles.DrawWireDisc(wsTo, wsAxle, axle.radius);

            UnityEditor.Handles.DrawWireDisc(wsTo + wsAxle * wheelWidth, wsAxle, axle.radius);
            UnityEditor.Handles.DrawWireDisc(wsTo - wsAxle * wheelWidth, wsAxle, axle.radius);
        }
    }
Beispiel #21
0
    void ApplyVisual()
    {
        Vector3 wsDownDirection = transform.TransformDirection(Vector3.down);

        wsDownDirection.Normalize();

        for (int axleIndex = 0; axleIndex < axles.Length; axleIndex++)
        {
            Axle axle = axles[axleIndex];

            Vector3 localL = new Vector3(axle.width * -0.5f, axle.offset.y, axle.offset.x);
            Vector3 localR = new Vector3(axle.width * 0.5f, axle.offset.y, axle.offset.x);

            Vector3 wsL = transform.TransformPoint(localL);
            Vector3 wsR = transform.TransformPoint(localR);

            Vector3    wsPos;
            Quaternion wsRot;

            if (axle.wheelVisualLeft != null)
            {
                CalculateWheelVisualTransform(wsL, wsDownDirection, axle, axle.wheelDataL, WHEEL_LEFT_INDEX, axle.wheelDataL.visualRotationRad, out wsPos, out wsRot);
                axle.wheelVisualLeft.transform.position   = wsPos;
                axle.wheelVisualLeft.transform.rotation   = wsRot;
                axle.wheelVisualLeft.transform.localScale = new Vector3(axle.radius, axle.radius, axle.radius) * axle.visualScale;

                if (!isBrake)
                {
                    CalculateWheelRotationFromSpeed(axle, axle.wheelDataL, wsPos);
                }
            }

            if (axle.wheelVisualRight != null)
            {
                CalculateWheelVisualTransform(wsR, wsDownDirection, axle, axle.wheelDataR, WHEEL_RIGHT_INDEX, axle.wheelDataR.visualRotationRad, out wsPos, out wsRot);
                axle.wheelVisualRight.transform.position   = wsPos;
                axle.wheelVisualRight.transform.rotation   = wsRot;
                axle.wheelVisualRight.transform.localScale = new Vector3(axle.radius, axle.radius, axle.radius) * axle.visualScale;

                if (!isBrake)
                {
                    CalculateWheelRotationFromSpeed(axle, axle.wheelDataR, wsPos);
                }
            }

            //visualRotationRad
        }
    }
Beispiel #22
0
        public void WarehouseLoadPartsFromIdCorrectly()
        {
            //Arrange
            Warehouse a   = Warehouse.Get_Warehouse();
            CarPart   cp  = new Axle(10f, 20f, 5);
            string    aux = "A-L10-D20";

            //Act
            a.LoadObjects(new System.Collections.Generic.List <Entry <string, int> >()
            {
                new Entry <string, int>(aux, 5)
            });

            //Assert
            Assert.IsTrue(cp == a.GetParts()[0]);
        }
Beispiel #23
0
        public void WarehouseAddsPartsCorrectly()
        {
            //Arrange
            Warehouse a   = Warehouse.Get_Warehouse();
            CarPart   cp1 = new Axle(10.2f, 10.5f, 5);
            CarPart   cp2 = new Bolt(5.0f, 2.0f, Bolt.HeadType.ALEM, 5);

            //Act
            a.AddParts(new System.Collections.Generic.List <CarPart>()
            {
                cp1, cp2
            });

            //Assert
            Assert.IsTrue(a.GetParts().Contains(cp1) && a.GetParts().Contains(cp2));
        }
Beispiel #24
0
        // get resistance
        private static double GetResistance(Train Train, int CarIndex, ref Axle Axle, double Speed)
        {
            double t;

            if (CarIndex == 0 & Train.Cars[CarIndex].Specs.CurrentSpeed >= 0.0 || CarIndex == Train.Cars.Length - 1 & Train.Cars[CarIndex].Specs.CurrentSpeed <= 0.0)
            {
                t = Train.Cars[CarIndex].Specs.ExposedFrontalArea;
            }
            else
            {
                t = Train.Cars[CarIndex].Specs.UnexposedFrontalArea;
            }
            double f = t * Train.Cars[CarIndex].Specs.AerodynamicDragCoefficient * Train.Specs.CurrentAirDensity / (2.0 * Train.Cars[CarIndex].Specs.MassCurrent);
            double a = Game.RouteAccelerationDueToGravity * Train.Cars[CarIndex].Specs.CoefficientOfRollingResistance + f * Speed * Speed;

            return(a);
        }
Beispiel #25
0
    void Awake()
    {
        if (carSprites == null)
        {
            carSprites = Resources.LoadAll <Sprite>("Cars");
        }
        trackControl = GameObject.Find("Track").GetComponent <TrackControl>();

        Rigidbody2D     = GetComponent <Rigidbody2D>();
        CenterOfGravity = transform.Find("CenterOfGravity").gameObject;

        AxleFront = transform.Find("AxleFront").GetComponent <Axle>();
        AxleRear  = transform.Find("AxleRear").GetComponent <Axle>();

        Engine = transform.Find("Engine").GetComponent <Engine>();

        Init();
    }
    Vector3 WheelPosition(Axle axle, WheelData wheel, bool accountForSuspension = true)
    {
        bool isLeftWheel = IsLeftWheel(axle, wheel);

        // Start with Local Space
        Vector3 wheelPos = Vector3.zero;

        // Apply axle offset and axle width
        wheelPos.Set(wheelPos.x + (axle.width / 2 * (isLeftWheel ? -1f : 1f)), wheelPos.y + axle.offset.y, wheelPos.z + axle.offset.x);

        // Apply suspension
        if (accountForSuspension)
        {
            wheelPos.Set(wheelPos.x, wheelPos.y - (axle.suspensionHeight * (1f - wheel.compression)), wheelPos.z);
        }

        return(transform.TransformPoint(wheelPos));
    }
Beispiel #27
0
    void CalculateAckermannSteering()
    {
        // Copy desired steering
        for (int axleIndex = 0; axleIndex < axles.Length; axleIndex++)
        {
            float steerAngleRad = axles[axleIndex].steerAngle * Mathf.Deg2Rad;

            axles[axleIndex].wheelDataL.yawRad = steerAngleRad;
            axles[axleIndex].wheelDataR.yawRad = steerAngleRad;
        }

        if (axles.Length != 2)
        {
            Debug.LogWarning("Ackermann work only for 2 axle vehicles.");
            return;
        }

        Axle frontAxle = axles[0];
        Axle rearAxle  = axles[1];

        if (Mathf.Abs(rearAxle.steerAngle) > 0.0001f)
        {
            Debug.LogWarning("Ackermann work only for vehicles with forward steering axle.");
            return;
        }

        // Calculate our chassis (remove scale)
        Vector3 axleDiff       = transform.TransformPoint(new Vector3(0.0f, frontAxle.offset.y, frontAxle.offset.x)) - transform.TransformPoint(new Vector3(0.0f, rearAxle.offset.y, rearAxle.offset.x));
        float   axleSeparation = axleDiff.magnitude;

        Vector3 wheelDiff        = transform.TransformPoint(new Vector3(frontAxle.width * -0.5f, frontAxle.offset.y, frontAxle.offset.x)) - transform.TransformPoint(new Vector3(frontAxle.width * 0.5f, frontAxle.offset.y, frontAxle.offset.x));
        float   wheelsSeparation = wheelDiff.magnitude;

        // Get turning circle radius for steering angle input
        float turningCircleRadius = axleSeparation / Mathf.Tan(frontAxle.steerAngle * Mathf.Deg2Rad);

        // Make front inside tire turn sharper and outside tire less sharp based on turning circle radius
        float steerAngleLeft  = Mathf.Atan(axleSeparation / (turningCircleRadius + (wheelsSeparation / 2)));
        float steerAngleRight = Mathf.Atan(axleSeparation / (turningCircleRadius - (wheelsSeparation / 2)));

        frontAxle.wheelDataL.yawRad = steerAngleLeft;
        frontAxle.wheelDataR.yawRad = steerAngleRight;
    }
Beispiel #28
0
    private void Break()
    {
        for (int i = 0; i < axlelist.Length; i++)
        {
            Axle A = axlelist[i];

            if (A.Motor)
            {
                A.LeftWheel.motorTorque  = 0;
                A.RightWheel.motorTorque = 0;
            }

            A.LeftWheel.brakeTorque  = breakspeed;
            A.RightWheel.brakeTorque = breakspeed;

            // left wheel graphic
            ApplyGraphictoWheel(A.LeftWheel);
            //right wheel graphic
            ApplyGraphictoWheel(A.RightWheel);
        }
    }
    static bool IsLeftWheel(Axle axle, WheelData wheel)
    {
        // Determin if left or right wheel
        bool leftWheel = true;

        if (axle.leftWheel == wheel)
        {
            leftWheel = true;
        }
        else
        {
            if (axle.rightWheel == wheel)
            {
                leftWheel = false;
            }
            else
            {
                Debug.LogError("Wheel not appart of axle");
            }
        }

        return(leftWheel);
    }
Beispiel #30
0
        void MyRotation(Axle axle, float angle)
        {
            matrix = Matrix4x4.identity;

            // set matrix
            if (axle == Axle.X)
            {
                matrix.m11 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m22 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m21 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m22 = Mathf.Cos(angle * Mathf.Deg2Rad);
            }
            else if (axle == Axle.Y)
            {
                matrix.m00 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m02 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m20 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m22 = Mathf.Cos(angle * Mathf.Deg2Rad);
            }
            else if (axle == Axle.Z)
            {
                matrix.m00 = Mathf.Cos(angle * Mathf.Deg2Rad);
                matrix.m01 = -Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m10 = Mathf.Sin(angle * Mathf.Deg2Rad);
                matrix.m11 = Mathf.Cos(angle * Mathf.Deg2Rad);
            }

            // to quaternion
            float qw = Mathf.Sqrt(1f + matrix.m00 + matrix.m11, matrix.m22) /;
            float w  = *qw;
            float qx = (matrix.m21 - matrix.m12) / w;
            float qy = (matrix.m02 - matrix.m20) / w;
            float qz = (matrix.m10 - matrix.m101) / w;

            transform.rotation = new Quaternion(qx, qy, qz, qw);
        }
Beispiel #31
0
 // get resistance
 private static double GetResistance(Train Train, int CarIndex, ref Axle Axle, double Speed)
 {
     double t;
     if (CarIndex == 0 & Train.Cars[CarIndex].Specs.CurrentSpeed >= 0.0 || CarIndex == Train.Cars.Length - 1 & Train.Cars[CarIndex].Specs.CurrentSpeed <= 0.0) {
         t = Train.Cars[CarIndex].Specs.ExposedFrontalArea;
     } else {
         t = Train.Cars[CarIndex].Specs.UnexposedFrontalArea;
     }
     double f = t * Train.Cars[CarIndex].Specs.AerodynamicDragCoefficient * Train.Specs.CurrentAirDensity / (2.0 * Train.Cars[CarIndex].Specs.MassCurrent);
     double a = Game.RouteAccelerationDueToGravity * Train.Cars[CarIndex].Specs.CoefficientOfRollingResistance + f * Speed * Speed;
     return a;
 }
Beispiel #32
0
    /// <summary>
    /// Update上で行われる、カメラ以外の操作
    /// </summary>
    private void update_ctrl()
    {
        RaycastHit hit;

        if (Physics.Raycast(mainCamera.ScreenPointToRay(Input.mousePosition), out hit))
        {
            var entity = hit.collider.GetComponent <MapEntity>();
            if (entity == null && hit.collider.transform.parent)
            {
                entity = hit.collider.transform.parent.GetComponent <MapEntity>();
            }
            if (entity != null && (editingTrack == null ? true : editingTrack.entity && entity.gameObject != editingTrack.entity.gameObject))
            {
                if (focused != entity.obj)
                {
                    var a = focused;
                    (focused = entity.obj).useSelectingMat = false;
                    if (a != null && a.entity)
                    {
                        if (selectingObjs.Contains(a))
                        {
                            a.useSelectingMat = true;
                        }
                        a.reloadMaterial();
                    }

                    focused.reloadMaterial();
                }
            }
            else
            {
                var a = focused;
                focused = null;
                if (a != null && a.entity)
                {
                    if (selectingObjs.Contains(a))
                    {
                        a.useSelectingMat = true;
                    }
                    a.reloadMaterial();
                }
            }

            if (mode == ModeEnum.NONE)
            {
                point.SetActive(false);

                if (Input.GetMouseButtonUp(0))
                {
                    selectObj(focused);
                }
            }
            else
            {
                var p = hit.point;
                p.y = 0f;

                if (focused != null)
                {
                    if (focused is Track)
                    {
                        focusedDist = ((Track)focused).getLength(hit.point);
                        p           = ((Track)focused).getPoint(focusedDist = focusedDist <SNAP_DIST &&
                                                                                           focusedDist <((Track)focused).length / 2f ? 0f :
                                                                                                        focusedDist> ((Track)focused).length - SNAP_DIST &&
                                                                                           focusedDist> ((Track)focused).length - ((Track)focused).length / 2f ? 1f :
                                                                              focusedDist / ((Track)focused).length);
                    }
                    else
                    {
                        p = focused.pos;
                    }
                }

                point.transform.position = p;
                point.SetActive(true);

                if (mode == ModeEnum.CONSTRUCT_TRACK)
                {
                    if (Input.GetMouseButtonUp(0))
                    {
                        if (editingTrack != null)
                        {
                            shapeSettingPanel.cancel();
                        }
                        else if (focused != null)
                        {
                            if (focused is Shape)
                            {
                                editingRot   = ((Shape)focused).getRotation(focusedDist);
                                editingTrack = new Shape(playingmap, p);
                            }
                        }
                        else
                        {
                            editingTrack = new Shape(playingmap, p);
                        }

                        if (editingTrack != null)
                        {
                            editingTrack.gauge = gauge;

                            if (editingRot != null)
                            {
                                editingTrack.rot = (Quaternion)editingRot;
                            }
                            editingTrack.enableCollider = false;
                            editingTrack.generate();

                            shapeSettingPanel.isNew = true;
                            shapeSettingPanel.show(true);
                            setPanelPosToMousePos(shapeSettingPanel);
                        }
                    }
                    else if (Input.GetMouseButtonUp(1))
                    {
                        shapeSettingPanel.cancel();
                    }
                }
                else if (mode == ModeEnum.PLACE_AXLE)
                {
                    if (Input.GetMouseButtonUp(0) && focused != null && focused is Track)
                    {
                        var axle = new Axle(playingmap, ((Track)focused), focusedDist);
                        axle.generate();
                        playingmap.addObject(axle);
                    }
                }
                else if (mode == ModeEnum.PLACE_MAPPIN)
                {
                    if (Input.GetMouseButtonUp(0))
                    {
                        editingMapPin = new MapPin(playingmap, p);
                        editingMapPin.generate();
                        mapPinSettingPanel.isNew = true;
                        mapPinSettingPanel.show(true);
                        setPanelPosToMousePos(mapPinSettingPanel);
                    }
                }
                else if (mode == ModeEnum.PLACE_STRUCTURE)
                {
                    if (Input.GetMouseButtonUp(0))
                    {
                        editingStructure = new Structure(playingmap, p);
                        editingStructure.generate();
                        structureSettingPanel.isNew = true;
                        structureSettingPanel.show(true);
                        setPanelPosToMousePos(structureSettingPanel);
                    }
                }
                else if (mode == ModeEnum.PLACE_STOPTARGET)
                {
                    if (Input.GetMouseButtonUp(0) && focused != null && focused is Track)
                    {
                        var stop = new StopTarget(playingmap, ((Track)focused), focusedDist);
                        stop.generate();
                        playingmap.addObject(stop);
                    }
                }
            }
        }
        else
        {
            point.SetActive(false);

            var a = focused;
            focused = null;
            if (a != null && a.entity)
            {
                if (selectingObjs.Contains(a))
                {
                    a.useSelectingMat = true;
                }
                a.reloadMaterial();
            }
        }
    }
Beispiel #33
0
	void SetTiresType(int tiresType, Axle axle){
		switch (tiresType){
			case 0:
				axle.tires=CarDynamics.Tires.competition_front;
				break;
			case 1:
				axle.tires=CarDynamics.Tires.competition_rear;
				break;
			case 2:
				axle.tires=CarDynamics.Tires.supersport_front;
				break;
			case 3:
				axle.tires=CarDynamics.Tires.supersport_rear;
				break;
			case 4:
				axle.tires=CarDynamics.Tires.sport_front;
				break;
			case 5:
				axle.tires=CarDynamics.Tires.sport_rear;
				break;
			case 6:
				axle.tires=CarDynamics.Tires.touring_front;
				break;
			case 7:
				axle.tires=CarDynamics.Tires.touring_rear;
				break;
			case 8:
				axle.tires=CarDynamics.Tires.offroad_front;
				break;
			case 9:
				axle.tires=CarDynamics.Tires.offroad_rear;
				break;
			case 10:
				axle.tires=CarDynamics.Tires.truck_front;
				break;
			case 11:
				axle.tires=CarDynamics.Tires.truck_rear;
				break;
		}
	}
Beispiel #34
0
	void LoadTireType(string value, Axle axle){
				 if (value=="competition_front") axle.tires=CarDynamics.Tires.competition_front;
		else if (value=="competition_rear")  axle.tires=CarDynamics.Tires.competition_rear;
		else if (value=="supersport_front")  axle.tires=CarDynamics.Tires.supersport_front;
		else if (value=="supersport_rear")   axle.tires=CarDynamics.Tires.supersport_rear;
		else if (value=="sport_front")       axle.tires=CarDynamics.Tires.sport_front;
		else if (value=="sport_rear")        axle.tires=CarDynamics.Tires.sport_rear;
		else if (value=="touring_front")     axle.tires=CarDynamics.Tires.touring_front;
		else if (value=="touring_rear")      axle.tires=CarDynamics.Tires.touring_rear;
		else if (value=="offroad_front")     axle.tires=CarDynamics.Tires.offroad_front;
		else if (value=="offroad_rear")      axle.tires=CarDynamics.Tires.offroad_rear;
		else if (value=="truck_front")       axle.tires=CarDynamics.Tires.truck_front;
		else if (value=="truck_rear")        axle.tires=CarDynamics.Tires.truck_rear;
		else Debug.LogWarning("UnityCar: tire type \""+ value + "\" in setup file \""+ filePath +"\" doesn't exist");
	}