示例#1
0
    /// <summary>
    /// ドリフトをキャンセルする処理
    /// ■forward    : 正面方向
    /// ■velocity   : 加速方向
    /// ■wheelState : タイヤのステート
    /// </summary>
    public WheelState CancelDrift(Vector3 forward, Vector3 velocity, WheelState wheelState)
    {
        if (wheelState == WheelState.GRIP)
        {
            mTimer = 0.0f;
            return(WheelState.GRIP);
        }
        //車の正面方向と加速している方向をみて(ステアリング0かつ)その差が±何度以下の状態に数秒あったら戻す
        float deg = Vector3.Angle(velocity, forward);

        //指定角度以内か
        if (deg < mDriftSettings.DriftCancelAngle)
        {
            mTimer += Time.deltaTime;
            //指定時間留まったか
            if (mTimer >= mDriftSettings.DriftCancelTime)
            {
                return(WheelState.GRIP);
            }
        }
        //留まってない場合やり直す
        else
        {
            mTimer = 0.0f;
        }
        return(WheelState.DRIFT);
    }
示例#2
0
        public Vehicle(Model model, ObjectStats.VehicleStats vehicleStats)
            : base(model, vehicleStats)
        {
            rearWheelsCount = vehicleStats.RearWheelCount;
            frontWheelsCount = vehicleStats.FrontWheelCount;
            doorCount = vehicleStats.DoorCount;
            hasTurret = vehicleStats.HasTurret;
            waterSourceCount = vehicleStats.WaterSourceCount;

            leftDoorAngle = 0;
            rightDoorAngle = 0;
            leftDoorState = DoorState.Closed;
            rightDoorState = DoorState.Closed;

            wheelAngle = 0;
            wheelState = WheelState.Straight;

            NextStep = new Vector2(Position.X,Position.Z);

            //TEMP
            //leftDoorState = DoorState.Opening;
            //rightDoorState = DoorState.Opening;
            //wheelState = WheelState.StraightLeft;
            //gi = new GameInfo();
        }
示例#3
0
 //---Wheel resistance
 private void applyResistanceForWheel(WheelState inWheelState)
 {
     _rigidBody.AddForceAtPosition(
         getWheelResistanceForce(inWheelState),
         getWheelWorldPosition(inWheelState),
         ForceMode2D.Force
         );
 }
        // WheelState and Wheel objects must be initialized with a minimum data per wheel

        void ConfigureWheelData(WheelState ws, Wheel wheel, VPWheelCollider wheelCol, bool steerable = false)
        {
            ws.wheelCol        = wheelCol;
            ws.steerable       = steerable;
            wheel.tireFriction = tireFriction;
            wheel.radius       = wheelCol.radius;
            wheel.mass         = wheelCol.mass;
        }
示例#5
0
        protected virtual void OnDisable()
        {
            currentState = WheelState.Idle;

            onSpinEnd?.Invoke();
            onSpinEnd = delegate { };
            gameObject.transform.localRotation = Quaternion.Euler(Vector3.zero);
        }
示例#6
0
 public void RotateWheelToNextSection()
 {
     print("Rotate again");
     wheelState = WheelState.SPIN;
     spinSpeed -= 1f;
     wheelState = WheelState.SLOW_DOWN;
     // FindObjectOfType<WheelFlag>().SendScore();
     // transform.Rotate(new Vector3(0, 0, -10f) * Time.deltaTime);
 }
示例#7
0
    //--Utils
    //---Gas
    private void applyGasForWheel(WheelState inWheelState, float inGasValue)
    {
        Vector2 theGetForceInUnits = XMetrics.forceToUnits(
            getWheelGasForce(inWheelState, inGasValue)
            );

        _rigidBody.AddForceAtPosition(
            theGetForceInUnits, getWheelWorldPosition(inWheelState),
            ForceMode2D.Force
            );
    }
示例#8
0
 /// <summary>
 /// 旋回処理
 /// ■transform:自分の車のTransform
 /// ■steer:ハンドルからの入力
 /// </summary>
 public Quaternion CalcAddRotValue(float steer, float speed, WheelState wheelState)
 {
     //速度が遅い場合旋回を行わない
     if (speed < IGNORE_SPEED)
     {
         return(Quaternion.identity);
     }
     /*steerの値が大きいと回転が速くなります*/
     //transform.Rotate(0f, steer, 0f);
     return(Quaternion.Euler(0.0f, steer * mSensitivities.GetValue(wheelState), 0.0f));//SLICK -> 指数関数?
 }
示例#9
0
 /// <summary>
 /// 条件を満たしていた場合ドリフトステートを返す
 /// ■speed      : 現在の速度
 /// ■steer      : ハンドルの入力
 /// ■brake      : ブレーキの入力
 /// ■wheelState : タイヤのステート
 /// </summary>
 public WheelState ChangeState(float speed, float steer, float brake, WheelState wheelState)
 {
     if (speed < ConvertUnits.KmphToMps(mDriftSettings.DriftSpeed))
     {
         return(WheelState.GRIP);
     }
     if (Mathf.Abs(steer) < mDriftSettings.IgnoreSteerInput)
     {
         return(wheelState);
     }
     return(WheelState.DRIFT);
 }
示例#10
0
        protected IEnumerator StoppingSpin()
        {
            currentState = WheelState.Braking;
            float currentPositionCorrection = FULL_CIRCLE_ANGLE - gameObject.transform.localRotation.eulerAngles.z;
            float distanceToPass            = BrakeLoops * FULL_CIRCLE_ANGLE + currentPositionCorrection + targetAngle;

            yield return(StartCoroutine(SpinPhase(distanceToPass, stopSpinCurve)));

            currentState = WheelState.Idle;
            onSpinEnd?.Invoke();
            onSpinEnd = delegate { };
        }
        public static void SetVehicleWheelState(Vehicle veh, WheelID wheel, WheelState state)
        {
            VehicleSyncData data = GetVehicleSyncData(veh);

            if (data == default(VehicleSyncData))
            {
                data = new VehicleSyncData();
            }

            data.Wheel[(int)wheel] = (int)state;
            UpdateVehicleSyncData(veh, data);
            NAPI.ClientEvent.TriggerClientEventInDimension(veh.Dimension, "VehStream_SetVehicleWheelStatus_Single", veh.Handle, (int)wheel, (int)state);
        }
示例#12
0
    /// <summary>
    /// ギア毎の滑り具合を決める係数を返す処理
    /// </summary>
    /// <param name="speed"></param>
    /// <returns></returns>
    public float GetGripCoef(float speed, WheelState wheelState)
    {
        int length = WheelData.Length;

        for (int i = 0; i < length; i++)
        {
            if (speed < WheelData[i].Speed)
            {
                return(WheelData[i].GetCoef(wheelState));
            }
        }
        return(WheelData[length - 1].Grip);
    }
示例#13
0
        /// <summary>
        /// 指定したステートの値を取り出す
        /// </summary>
        /// <param name="wheelState"></param>
        /// <returns></returns>
        public float GetValue(WheelState wheelState)
        {
            switch (wheelState)
            {
            case WheelState.GRIP: return(Grip);

            case WheelState.DRIFT: return(Drift);

            case WheelState.SLICK: return(Slick);

            default: return(0.0f);
            }
        }
示例#14
0
        public void Trick(int trickMode, float minAngle, float maxAngle)
        {
            if (_state == WheelState.Trick)
            {
                return;
            }
            _state     = WheelState.Trick;
            _trickMode = (TrickMode)trickMode;
            _trickMin  = minAngle;
            _trickMax  = maxAngle;
            _tricked   = false;
            _trickIn   = false;

            switch (_trickMode)
            {
            case TrickMode.Back:
            {
                float sign   = _speed > 0 ? 1 : -1;
                float offset = 10;
                minAngle -= offset;
                maxAngle -= offset;
                _speed    = Mathf.Max(150, Mathf.Abs(_speed)) * sign;
                float duration = Random.Range(0.15f, 0.8f);
                _accSpeed = (0 - _speed) / duration;
                _trickIn  = true;
                //Debug.Log("Trick Back Begin AccSpeed = " + _accSpeed.ToString() + ", _speed = " + _speed.ToString());
                break;
            }

            case TrickMode.Pass:
            {
                float sign = (_speed >= 0 ? 1 : -1);
                _accSpeed = 0;
                // 保证此刻速度足够
                if (Mathf.Abs(_speed) <= 100)
                {
                    _speed = 150 * sign;
                }
                //逆时针旋转
                // 计算快速通过时间
                float passDuration = 0.15f;        //150ms
                _trickSpeed = sign * Mathf.Abs(_trickMax - _trickMin) / passDuration;
                _trickSpeed = sign * Mathf.Max(100, Mathf.Abs(_trickSpeed));
                Debug.Log("Trick Pass Begin : Speed = " + _trickSpeed.ToString());
                break;
            }
            }
        }
示例#15
0
        protected IEnumerator Spin()
        {
            currentState = WheelState.Acceleration;
            float currentPositionCorrection = FULL_CIRCLE_ANGLE - gameObject.transform.localRotation.eulerAngles.z;
            float distanceToPass            = BrakeLoops * FULL_CIRCLE_ANGLE + currentPositionCorrection + targetAngle;

            yield return(StartCoroutine(SpinPhase(distanceToPass, startSpinCurve)));

            currentState = WheelState.Spin;
            currentPositionCorrection = FULL_CIRCLE_ANGLE - gameObject.transform.localRotation.eulerAngles.z;
            distanceToPass            = BrakeLoops * FULL_CIRCLE_ANGLE + currentPositionCorrection + targetAngle;
            yield return(StartCoroutine(SpinPhase(distanceToPass, mainSpinCurve)));

            #region IF PLAYER DIDN'T STOP THE WHEEL (Using for Spin by time)
            yield return(StartCoroutine(StoppingSpin()));

            #endregion IF PLAYER DIDN'T STOP THE WHEEL (Using for Spin by time)
        }
示例#16
0
 /// <summary>
 /// 車を操縦する処理
 /// ■enigneRot:エンジン回転数
 /// ■steer:ハンドルからの入力
 /// </summary>
 /// <param name="engineRot"></param>
 /// <param name="steer"></param>
 public void UpdateMove(float engineRot, float steer, float brake, bool isGround)
 {
     if (isGround)
     {
         //前後処理
         UpdateBaseMove(mTransform.forward, engineRot);
         //旋回処理
         mTransform.rotation *= mSteeringScript.CalcAddRotValue(steer, mSpeed, mWheelState);
         //タイヤの状態をドリフト状態に変える処理
         mWheelState = mDriftScript.ChangeState(mSpeed, steer, brake, mWheelState);
         mWheelState = mDriftScript.CancelDrift(mTransform.forward, mRigidbody.velocity, mWheelState);
     }
     else
     {
         //重力処理
         mRigidbody.velocity = RigidbodyCalc.UpdateGravity(mRigidbody.velocity);
     }
 }
示例#17
0
    private Vector2 getWheelResistanceForce(WheelState inWheelState)
    {
        Vector2 theWheelPosition  = getWheelWorldPosition(inWheelState);
        float   theWheelsRotation = getWheelWorldRotation(inWheelState);

        Vector2 theVelocityInWheelPosition = _rigidBody.GetPointVelocity(theWheelPosition);

        Vector3 theWheelsDiraction = XMath.getDiractionVectorForAngle(theWheelsRotation);
        Vector2 theDirectProjectedAccumulateVelocity =
            Vector3.Project(theVelocityInWheelPosition, theWheelsDiraction);
        Vector2 theDirectResistanceForce = -theDirectProjectedAccumulateVelocity * _directResistanceK;

        Vector3 theWheelsNormalDiraction           = XMath.getVectorRotatedBy90Degrees(theWheelsDiraction);
        Vector2 theSideProjectedAccumulateVelocity =
            Vector3.Project(theVelocityInWheelPosition, theWheelsNormalDiraction);
        Vector2 theSideResistanceForce = -theSideProjectedAccumulateVelocity * _sideResistanceK;

        return(theDirectResistanceForce + theSideResistanceForce);
    }
示例#18
0
    void ConfigureAxle(VPAxle axle, int leftWheelIndex, int rightWheelIndex, TireFrictionBase tireFriction)
    {
        WheelState leftWheelState  = wheelState[leftWheelIndex];
        WheelState rightWheelState = wheelState[rightWheelIndex];
        Wheel      leftWheelBlock  = wheels[leftWheelIndex];
        Wheel      rightWheelBlock = wheels[rightWheelIndex];

        bool isSteeringAxle = axle.steeringMode != Steering.SteeringMode.Disabled;

        // Configure the mandatory data per wheel

        ConfigureWheelData(leftWheelState, leftWheelBlock, axle.leftWheel, tireFriction, isSteeringAxle);
        ConfigureWheelData(rightWheelState, rightWheelBlock, axle.rightWheel, tireFriction, isSteeringAxle);

        // Configure steering

        if (isSteeringAxle)
        {
            m_steering.AddWheel(leftWheelState, GetWheelLocalPosition(axle.leftWheel), axle.steeringMode, axle.steeringRatio);
            m_steering.AddWheel(rightWheelState, GetWheelLocalPosition(axle.rightWheel), axle.steeringMode, axle.steeringRatio);
        }
    }
        private FrictionSettings GetFrictionSettingsForState(Wheel wheel, WheelState state,
                                                             FrictionType frictionType)
        {
            if (wheel.info.isFrontWheel)
            {
                switch (state)
                {
                case WheelState.powerslide:
                    return(frictionType == FrictionType.forward ?
                           _physicsSettings.frontPowerslideForwardFriction :
                           _physicsSettings.frontPowerslideSidewaysFriction);

                default:
                    return(frictionType == FrictionType.forward ?
                           _physicsSettings.frontDefaultForwardFriction :
                           _physicsSettings.frontDefaultSidewaysFriction);
                }
            }
            else
            {
                switch (state)
                {
                case WheelState.powerslide:
                    return(frictionType == FrictionType.forward ?
                           _physicsSettings.rearPowerslideForwardFriction :
                           _physicsSettings.rearPowerslideSidewaysFriction);

                default:
                    return(frictionType == FrictionType.forward ?
                           _physicsSettings.rearDefaultForwardFriction :
                           _physicsSettings.rearDefaultSidewaysFriction);
                }
            }

            throw new ArgumentOutOfRangeException($@"No friction settings found for wheel: {wheel.info.isFrontWheel},
                state: {state}, frictionType: {frictionType}");
        }
示例#20
0
        public override void CalculateNextStep(GameTime gameTime, IEnumerable<GameObject> gameObjects)
        {
            if(Path.Count > 0)
            {
                toleranceX = toleranceBig;
                toleranceY = toleranceBig;
            }
            else
            {
                toleranceX = toleranceSmall;
                toleranceY = toleranceSmall;
            }

            Vector2 curStep = new Vector2(NextStep.X - Position.X, NextStep.Y - Position.Z);

            curStep = new Vector2(curStep.X * Convert.ToSingle(Math.Cos(Angle.Y)) - curStep.Y * Convert.ToSingle(Math.Sin(Angle.Y)),
                curStep.Y * Convert.ToSingle(Math.Cos(Angle.Y)) + curStep.X * Convert.ToSingle(Math.Sin(Angle.Y)));

            //gi.ShowInfo("curStep: " + curStep.ToString() + "\r\nAngle: " + Angle.Y.ToString() + "\r\n WheelState" + WheelState.ToString() + "\r\n" +
            //    Path.ToArray().ToString());

            if(Math.Abs(curStep.X) <= toleranceX && Math.Abs(curStep.Y) <= toleranceY)
            {
                if(Path != null && Path.Count > 0)
                {
                    NextStep = new Vector2(Path[0].X,Path[0].Y);
                    Path.RemoveAt(0);
                }
                else
                {
                    Move(Direction.None, gameTime);
                    Turn(Direction.None, gameTime);
                    return;
                }
            }

            if (Math.Abs(curStep.X) <= toleranceX)
            {
                if (Math.Abs(curStep.Y) <= toleranceY)
                {
                    Move(Direction.None, gameTime);
                    Turn(Direction.None, gameTime);
                }
                else if (curStep.Y > toleranceY)
                {
                    if (WheelState == WheelState.Left)
                    {
                        WheelState = WheelState.LeftStraight;
                    }
                    else if (WheelState == WheelState.Right)
                    {
                        WheelState = WheelState.RightStraight;
                    }

                    if (WheelState == WheelState.Straight || WheelState == WheelState.LeftStraight || WheelState == WheelState.RightStraight)
                    {
                        if (CheckMoveList(Direction.Forward, Direction.None, gameObjects, gameTime))
                        {
                            Move(Direction.Forward, gameTime);
                        }
                    }
                }
                else
                {
                    if (WheelState == WheelState.Left)
                    {
                        WheelState = WheelState.LeftStraight;
                    }
                    else if (WheelState == WheelState.Right)
                    {
                        WheelState = WheelState.RightStraight;
                    }

                    if (WheelState == WheelState.Straight || WheelState == WheelState.LeftStraight || WheelState == WheelState.RightStraight)
                    {
                        if (CheckMoveList(Direction.Backward, Direction.None, gameObjects, gameTime))
                        {
                            Move(Direction.Backward, gameTime);
                        }
                    }

                }
            }
            else if (curStep.X > toleranceX)
            {
                if(Math.Abs(curStep.Y) <= toleranceY)
                {
                    Path.Insert(0, new Point(Convert.ToInt32(NextStep.X), Convert.ToInt32(NextStep.Y)));

                    NextStep = CalculateBackingUp(Angle.Y, new Vector2(Position.X, Position.Z), 25.0, Direction.Forward);
                }
                else if (curStep.Y > toleranceY)
                {
                    if(WheelState == WheelState.Straight)
                    {
                        WheelState = WheelState.StraightLeft;
                    }
                    else if (WheelState == WheelState.Right)
                    {
                        WheelState = WheelState.RightStraight;
                    }
                    if (WheelState == WheelState.StraightLeft || WheelState == WheelState.Left)
                    {
                        if (CheckMoveList(Direction.Forward, Direction.Left, gameObjects, gameTime))
                        {
                            Move(Direction.Forward, gameTime);
                            Turn(Direction.Left, gameTime);
                        }
                    }
                }
                else
                {
                    if(WheelState == WheelState.Straight)
                    {
                        WheelState = WheelState.StraightRight;
                    }
                    else if (WheelState == WheelState.Left)
                    {
                        WheelState = WheelState.LeftStraight;
                    }
                    if (WheelState == WheelState.StraightRight || WheelState == WheelState.Right)
                    {
                        if (CheckMoveList(Direction.Backward, Direction.Left, gameObjects, gameTime))
                        {
                            Move(Direction.Backward, gameTime);
                            Turn(Direction.Left, gameTime);
                        }
                    }
                }
            }
            else
            {
                if (Math.Abs(curStep.Y) <= toleranceY)
                {
                    Path.Insert(0, new Point(Convert.ToInt32(NextStep.X), Convert.ToInt32(NextStep.Y)));

                    NextStep = CalculateBackingUp(Angle.Y, new Vector2(Position.X, Position.Z), 25.0, Direction.Forward);
                }
                else if (curStep.Y > toleranceY)
                {
                    if (WheelState == WheelState.Straight)
                    {
                        WheelState = WheelState.StraightRight;
                    }
                    else if (WheelState == WheelState.Left)
                    {
                        WheelState = WheelState.LeftStraight;
                    }
                    if (WheelState == WheelState.StraightRight || WheelState == WheelState.Right)
                    {
                        if (CheckMoveList(Direction.Forward, Direction.Right, gameObjects, gameTime))
                        {
                            Move(Direction.Forward, gameTime);
                            Turn(Direction.Right, gameTime);
                        }
                    }
                }
                else
                {
                    if (WheelState == WheelState.Straight)
                    {
                        WheelState = WheelState.StraightRight;
                    }
                    else if (WheelState == WheelState.Left)
                    {
                        WheelState = WheelState.LeftStraight;
                    }
                    if (WheelState == WheelState.StraightRight || WheelState == WheelState.Right)
                    {
                        if (CheckMoveList(Direction.Backward, Direction.Left, gameObjects, gameTime))
                        {
                            Move(Direction.Backward, gameTime);
                            Turn(Direction.Left, gameTime);
                        }
                    }
                }
            }
        }
示例#21
0
 public void MoveForwardMaxPower()
 {
     State = WheelState.MaxMove;
 }
示例#22
0
 public void MoveBack()
 {
     State = WheelState.Back;
 }
示例#23
0
	void RotateWheel()
	{
		//Shoot ray into the screen from the mouse position
		Ray ray = sceneCamera.ScreenPointToRay (Input.mousePosition);
		RaycastHit hit;
		
		
		
		//Check that it hits the collider 
    	if (collider.Raycast (ray, out hit, 3f) && Input.GetMouseButton(0) && !isHoldingTreasure) 
		{
			myState = WheelState.DRAGGING;
			//canRotate = true;
			//Will be used for creation of plane
			Vector3 forward = Vector3.forward;
			
			Plane playerPlane = new Plane(-forward, transform.position);
			
			float hitdist = 0.0f;
			
			playerPlane.Raycast(ray, out hitdist);
			
        	// Get the point along the ray that hits the calculated distance.
        	Vector3 targetPoint = ray.GetPoint(hitdist);
			
			//Where the "Wheel" will point to..
        	Vector3 aimPoint = targetPoint - transform.position;
			
			Vector3 prevDirection = new Vector3();
			
			prevDirection = transform.up;
			transform.up = aimPoint;
			
			float angle = Vector2.Angle(Vector2.right, (Vector2) wheel_Dir.up);
			
			if( wheel_Dir.up.y <= 0 || angle > 170f || angle < 10f)
			{
				//Debug.Log("Can't Rotate");
				transform.up = prevDirection;
				
			}
			
			else
				myShip.SteerShip(CalculateShipVelocity(angle));
			
    	}
		
		else if (myState == WheelState.DRAGGING)
		{
			myShip.WheelReloadCannon();
			myState = WheelState.NONE;
		}
	}
示例#24
0
 //--Wheel utils
 private Vector2 getWheelWorldPosition(WheelState inWheel)
 {
     return(transform.TransformPoint(inWheel.getPosition()));
 }
示例#25
0
 public void MoveForward()
 {
     State = WheelState.Move;
 }
示例#26
0
 public void ResetWheel()
 {
     spinSpeed  = -1;
     wheelState = WheelState.STILL;
 }
示例#27
0
    private Vector2 getWheelGasForce(WheelState inWheelState, float inGasValue)
    {
        Vector2 theDiraction = XMath.getDiractionVectorForAngle(getWheelWorldRotation(inWheelState));

        return(theDiraction * inGasValue);
    }
示例#28
0
 public void StopRotate()
 {
     _state = WheelState.Stop;
 }
示例#29
0
 public void StartRotate()
 {
     ReCaculateSpeed();
     _state = WheelState.Rotate;
 }
示例#30
0
        private void TrickUpdate()
        {
            if (_trickMode == TrickMode.None)
            {
                return;
            }
            float angleZ      = transform.localEulerAngles.z;
            bool  isClockwise = _speed < 0;
            bool  inArea      = _trickMax > 360 ? ((angleZ >= _trickMin && angleZ <= 360) || (angleZ >= 0 && angleZ <= (_trickMax - 360))) :
                                (angleZ >= _trickMin && angleZ <= _trickMax);

            if (_trickMode == TrickMode.Back)
            {
                if (_trickIn)
                {
                    //_speed *= 0.85f;
                }
                else
                {
                    _speed = _speed + _accSpeed * Time.fixedDeltaTime;
                }
                if (inArea)
                {
                    if (_trickIn)
                    {//开始反向
                        float sign = _speed > 0 ? 1 : -1;
                        sign       *= -1;
                        _speed      = 0;
                        _trickSpeed = Random.Range(100, 200) * sign;
                        float duration = Random.Range(0.35f, 0.8f);
                        _accSpeed = (_trickSpeed - _speed) / duration;
                        _trickIn  = false;
                        _tricked  = true;
                        // Debug.Log("Trick Back Back  _speed = " + _speed.ToString());
                    }
                }
                if (_tricked)
                {
                    if (Mathf.Abs(_speed) >= Mathf.Abs(_trickSpeed))
                    {
                        _state = WheelState.Rotate;
                        // Debug.Log("Trick Back End  _speed = " + _speed.ToString());
                        ReCaculateSpeed();
                        _tricked = false;
                        // Debug.Log("Trick B to Normal  _speed = " + _speed.ToString());
                        if (OnTrickOver != null)
                        {
                            OnTrickOver.Invoke();
                        }
                    }
                }
            }
            else
            {   //快速通过
                if (inArea)
                {
                    _speed   = _trickSpeed;
                    _tricked = true;
                }
                else
                {
                    if (_tricked)
                    {
                        Debug.Log("Trick Pass End  _speed = " + _speed.ToString());
                        _state   = WheelState.Rotate;
                        _tricked = false;
                        float sign           = _speed > 0 ? 1 : -1;
                        int   changeSpeedCnt = _changeSpeedCfg.Count;
                        if (changeSpeedCnt > 0)
                        {
                            NumberArea area = _changeSpeedCfg[0];
                            if (changeSpeedCnt > 1)
                            {
                                int idx = Random.Range(0, changeSpeedCnt);

                                area = _changeSpeedCfg[idx];
                            }
                            _speed = sign * Mathf.Abs(Random.Range(area.Min, area.Max));
                        }
                        ReCaculateSpeed();

                        Debug.Log("Trick Pass To Normal  _speed = " + _speed.ToString());
                        if (OnTrickOver != null)
                        {
                            OnTrickOver.Invoke();
                        }
                    }
                }
            }
            transform.Rotate(0, 0, _speed * Time.fixedDeltaTime);
        }
示例#31
0
        private void AnimateTurn(GameTime gameTime)
        {
            float rot = 0;
            const float turningSpeed = 0.003f;
            const float maxAngle = 0.5f*MathHelper.PiOver4;
            switch(wheelState)
            {
                case WheelState.StraightRight:
                    rot = turningSpeed * gameTime.ElapsedGameTime.Milliseconds;
                    wheelAngle += rot;
                    if (wheelAngle >= maxAngle)
                    {
                        wheelState = WheelState.Right;
                        //TEMP
                        //WheelState = WheelState.RightStraight;
                        //\TEMP
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] *
                                Matrix.CreateRotationZ(-maxAngle + wheelAngle - rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] *
                                Matrix.CreateRotationZ(maxAngle - wheelAngle + rot);
                        }
                        wheelAngle = maxAngle;
                    }
                    else
                    {

                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(-rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(rot);
                        }
                    }
                    break;
                case WheelState.RightStraight:
                    rot = -turningSpeed * gameTime.ElapsedGameTime.Milliseconds;
                    wheelAngle += rot;
                    if (wheelAngle <= 0)
                    {
                        wheelState = WheelState.Straight;
                        //TEMP
                        //WheelState = WheelState.StraightLeft;
                        //\TEMP
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(wheelAngle - rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(-wheelAngle + rot);
                        }
                        wheelAngle = 0;
                    }
                    else
                    {
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(-rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(rot);
                        }
                    }
                    break;
                case WheelState.StraightLeft:
                    rot = -turningSpeed * gameTime.ElapsedGameTime.Milliseconds;
                    wheelAngle += rot;
                    if (wheelAngle <= -maxAngle)
                    {
                        wheelState = WheelState.Left;
                        //TEMP
                        //WheelState = WheelState.LeftStraight;
                        //\TEMP
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(maxAngle + wheelAngle - rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(-maxAngle - wheelAngle + rot);
                        }
                        wheelAngle = -maxAngle;
                    }
                    else
                    {
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(-rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(rot);
                        }
                    }
                    break;
                case WheelState.LeftStraight:
                    rot = turningSpeed * gameTime.ElapsedGameTime.Milliseconds;
                    wheelAngle += rot;
                    if (wheelAngle >= 0)
                    {
                        wheelState = WheelState.Straight;
                        //TEMP
                        //WheelState = WheelState.StraightRight;
                        //\TEMP
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(wheelAngle - rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(-wheelAngle + rot);
                        }
                        wheelAngle = 0;
                    }
                    else
                    {
                        for (int i = 0; i < frontWheelsCount / 2; i++)
                        {
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i)].Index]*
                                Matrix.CreateRotationZ(-rot);
                            AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index] =
                                AnimationTransforms[Model.Bones["FrontWheel" + Convert.ToInt32(2*i + 1)].Index]*
                                Matrix.CreateRotationZ(+rot);
                        }
                    }
                    break;
            }
        }
示例#32
0
 public void Stop()
 {
     State = WheelState.Stop;
 }
示例#33
0
 private float getWheelWorldRotation(WheelState inWheel)
 {
     return(transform.rotation.eulerAngles.z + inWheel.getRotation());
 }