// Update is called once per frame void FixedUpdate() { float steer = Input.GetAxis("Horizontal"); float accel = Input.GetAxis("Vertical"); float handBrake = Input.GetAxis("Jump"); UpdateKaCheCheTiQiBuOrStop(accel, handBrake); UpdateKaCheFrontWheelLRRot(steer); FixKaCheRotPos(); if (CarSpeedVal <= 0.5f && Mathf.Abs(accel) <= 0.05f) { if (!CarRig.isKinematic) { CarRig.isKinematic = true; CarRunState = 0; IsRunKaCheWheel = false; for (int i = 0; i < CarBackWheelTwRot.Length; i++) { CarBackWheelTwRot[i].enabled = false; } } return; } if (CarRig.isKinematic) { CarRig.isKinematic = false; } UpdateKaCheLunZiRot(accel); if (accel > 0f) { if (Vector3.Dot(CarRig.velocity, CarTr.forward) < 0f || CarSpeedVal < MinCarQianJinSpeed) { Vector3 minCarSpeed = CarTr.forward * MinCarQianJinSpeed; CarRig.velocity = Vector3.Lerp(CarRig.velocity, minCarSpeed, Time.deltaTime * 4f); } } if (accel < 0f) { if (Vector3.Dot(CarRig.velocity, -CarTr.forward) < 0f || CarSpeedVal < MaxCarHouTuiSpeed) { Vector3 minCarSpeed = -CarTr.forward * MaxCarHouTuiSpeed; CarRig.velocity = Vector3.Lerp(CarRig.velocity, minCarSpeed, Time.deltaTime * 4f); } if (CarSpeedVal >= MaxCarHouTuiSpeed) { accel = 0f; } } if (accel == 0f && CarSpeedVal > 0.2f) { Vector3 minCarSpeed = CarTr.forward * 0.1f; CarRig.velocity = Vector3.Lerp(CarRig.velocity, minCarSpeed, Time.deltaTime * 2f); } if ((handBrake > 0f && steer != 0f && CarSpeedVal > 30f) || (IsActivePiaoYi && handBrake <= 0f && Time.realtimeSinceStartup - TimePiaoYiLast < DealyOverPiaoYiTime)) { if (handBrake > 0f) { TimePiaoYiLast = Time.realtimeSinceStartup; } IsActivePiaoYi = true; handBrake = 0f; XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed = 1f; steer = steer > 0f ? PiaoYiOffsetVal : -PiaoYiOffsetVal; CarController.m_MaximumSteerAngle = MaxAngleVal; if (Mathf.Abs(RealCarAngleY) < PiaoYiAngleVal) { float carAngleY = steer > 0f ? PiaoYiAngleVal : -PiaoYiAngleVal; if (!CarPiaoYiDirCom.enabled && RealCarAngleY == 0f) { CarPiaoYiDirCom.from = Vector3.zero; CarPiaoYiDirCom.to = new Vector3(0f, carAngleY, 0f); CarPiaoYiDirCom.ResetToBeginning(); CarPiaoYiDirCom.PlayForward(); CarPiaoYiDirCom.enabled = true; } RealCarAngleY = CarPiaoYiDirCom.transform.localScale.y; //Debug.Log("RealCarAngleY "+RealCarAngleY); if (Mathf.Abs(RealCarAngleY) >= PiaoYiAngleVal) { RealCarAngleY = carAngleY; } RealCarTr.localEulerAngles = new Vector3(0f, RealCarAngleY, 0f); } } else { if (IsActivePiaoYi) { XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed = 0.5f; TimePiaoYiOver = Time.realtimeSinceStartup; PiaoYiOverSpeed = CarSpeedVal; } IsActivePiaoYi = false; float rotSpeedVal = (CarSpeedVal / KeyRotSpeed) + MaxAngleVal; CarController.m_MaximumSteerAngle = Mathf.Clamp(rotSpeedVal, MinAngleVal, MaxAngleVal); if (RealCarAngleY != 0f) { RealCarAngleY = 0f; CarPiaoYiDirCom.enabled = false; CarPiaoYiDirCom.ResetToBeginning(); RealCarTr.parent = null; CarTr.forward = RealCarTr.forward; RealCarTr.parent = CarTr; RealCarTr.localPosition = Vector3.zero; RealCarTr.localEulerAngles = Vector3.zero; RealCarTr.localScale = Vector3.one; } } if (Time.realtimeSinceStartup - TimePiaoYiOver < 2f) { Vector3 piaoYiSpeedVec = CarTr.forward * PiaoYiOverSpeed * 1.2f; CarRig.velocity = Vector3.Lerp(CarRig.velocity, piaoYiSpeedVec, Time.deltaTime * 15f); } else { if (!IsActivePiaoYi && XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed < 1f) { // float valSpeed = XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed; XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed += Time.deltaTime * 2f; if (XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed >= 0.97f) { XKPlayerMoveCarCameraCtrl.PerCameraFollowSpeed = 1f; } } } CarController.Move(steer, accel, accel, handBrake); CheckDaoYanHit(); UpdateKaCheCheTiRotZ(steer); }
private void FixedUpdate() { if (m_Target == null || !m_Driving) { // Car should not be moving, // use handbrake to stop } else { Vector3 fwd = transform.forward; if (m_Rigidbody.velocity.magnitude > m_CarController.MaxSpeed * 0.1f) { fwd = m_Rigidbody.velocity; } float desiredSpeed = m_CarController.MaxSpeed; // now it's time to decide if we should be slowing down... switch (m_BrakeCondition) { case BrakeCondition.TargetDirectionDifference: { // the car will brake according to the upcoming change in direction of the target. Useful for route-based AI, slowing for corners. // check out the angle of our target compared to the current direction of the car float approachingCornerAngle = Vector3.Angle(m_Target.forward, fwd); // also consider the current amount we're turning, multiplied up and then compared in the same way as an upcoming corner angle float spinningAngle = m_Rigidbody.angularVelocity.magnitude * m_CautiousAngularVelocityFactor; // if it's different to our current angle, we need to be cautious (i.e. slow down) a certain amount float cautiousnessRequired = Mathf.InverseLerp(0, m_CautiousMaxAngle, Mathf.Max(spinningAngle, approachingCornerAngle)); desiredSpeed = Mathf.Lerp(m_CarController.MaxSpeed, m_CarController.MaxSpeed * m_CautiousSpeedFactor, cautiousnessRequired); break; } case BrakeCondition.TargetDistance: { // the car will brake as it approaches its target, regardless of the target's direction. Useful if you want the car to // head for a stationary target and come to rest when it arrives there. // check out the distance to target Vector3 delta = m_Target.position - transform.position; float distanceCautiousFactor = Mathf.InverseLerp(m_CautiousMaxDistance, 0, delta.magnitude); // also consider the current amount we're turning, multiplied up and then compared in the same way as an upcoming corner angle float spinningAngle = m_Rigidbody.angularVelocity.magnitude * m_CautiousAngularVelocityFactor; // if it's different to our current angle, we need to be cautious (i.e. slow down) a certain amount float cautiousnessRequired = Mathf.Max( Mathf.InverseLerp(0, m_CautiousMaxAngle, spinningAngle), distanceCautiousFactor); desiredSpeed = Mathf.Lerp(m_CarController.MaxSpeed, m_CarController.MaxSpeed * m_CautiousSpeedFactor, cautiousnessRequired); break; } case BrakeCondition.NeverBrake: break; } // Evasive action due to collision with other cars: // our target position starts off as the 'real' target position Vector3 offsetTargetPos = m_Target.position; // if are we currently taking evasive action to prevent being stuck against another car: if (Time.time < m_AvoidOtherCarTime) { // slow down if necessary (if we were behind the other car when collision occured) desiredSpeed *= m_AvoidOtherCarSlowdown; // and veer towards the side of our path-to-target that is away from the other car offsetTargetPos += m_Target.right * m_AvoidPathOffset; } else { // no need for evasive action, we can just wander across the path-to-target in a random way, // which can help prevent AI from seeming too uniform and robotic in their driving offsetTargetPos += m_Target.right * (Mathf.PerlinNoise(Time.time * m_LateralWanderSpeed, m_RandomPerlin) * 2 - 1) * m_LateralWanderDistance; } // use different sensitivity depending on whether accelerating or braking: float accelBrakeSensitivity = (desiredSpeed < m_CarController.CurrentSpeed) ? m_BrakeSensitivity : m_AccelSensitivity; // decide the actual amount of accel/brake input to achieve desired speed. float accel = Mathf.Clamp((desiredSpeed - m_CarController.CurrentSpeed) * accelBrakeSensitivity, -1, 1); // add acceleration 'wander', which also prevents AI from seeming too uniform and robotic in their driving // i.e. increasing the accel wander amount can introduce jostling and bumps between AI cars in a race accel *= (1 - m_AccelWanderAmount) + (Mathf.PerlinNoise(Time.time * m_AccelWanderSpeed, m_RandomPerlin) * m_AccelWanderAmount); // calculate the local-relative position of the target, to steer towards Vector3 localTarget = transform.InverseTransformPoint(offsetTargetPos); // work out the local angle towards the target float targetAngle = Mathf.Atan2(localTarget.x, localTarget.z) * Mathf.Rad2Deg; // get the amount of steering needed to aim the car towards the target float steer = Mathf.Clamp(targetAngle * m_SteerSensitivity, -1, 1) * Mathf.Sign(m_CarController.CurrentSpeed); // feed input to the car controller. m_CarController.Move(steer, accel, accel, 0f); // if appropriate, stop driving when we're close enough to the target. //if (m_StopWhenTargetReached && localTarget.magnitude < m_ReachTargetThreshold) if (localTarget.magnitude < m_ReachTargetThreshold) { m_Driving = false; } } }