// 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;
}
}
}