private void FixedUpdate()
{
// pass the input to the car!
Vector2 input = OVRInput.Get(OVRInput.Axis2D.PrimaryThumbstick);
car.Move(input.x, input.y);
}
private void FixedUpdate()
{
// pass the input to the car!
float h = Input.GetAxis("Horizontal");
float v = Input.GetAxis("Vertical");
car.Move(h, v);
}
private void FixedUpdate()
{
// pass the input to the car!
float h = CrossPlatformInputManager.GetAxis("Horizontal");
float v = CrossPlatformInputManager.GetAxis("Vertical");
car.Move(h, v);
}
private void FixedUpdate()
{
// pass the input to the car!
//horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
//vertical = CrossPlatformInputManager.GetAxis("Vertical");
vertical = 0.1f;
car.Move(horizontal, vertical);
}
private void FixedUpdate()
{
// pass the input to the car!
//float h = CrossPlatformInputManager.GetAxis("Horizontal");
//float v = CrossPlatformInputManager.GetAxis("Vertical");
float vGamePad = CrossPlatformInputManager.GetAxis("Fire1");
car.Move(carTurn, vGamePad);
//print (h + " " + vGamePad);
}
private void FixedUpdate()
{
if (target == null || !driving)
{
// Car should not be moving,
// (so use accel/brake to get to zero speed)
float accel = Mathf.Clamp(-carController.CurrentSpeed, -1, 1);
carController.Move(0, accel);
}
else
{
Vector3 fwd = transform.forward;
if (GetComponent <Rigidbody>().velocity.magnitude > carController.MaxSpeed * 0.1f)
{
fwd = GetComponent <Rigidbody>().velocity;
}
float desiredSpeed = carController.MaxSpeed;
// now it's time to decide if we should be slowing down...
switch (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(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 = GetComponent <Rigidbody>().angularVelocity.magnitude *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, cautiousMaxAngle,
Mathf.Max(spinningAngle,
approachingCornerAngle));
desiredSpeed = Mathf.Lerp(carController.MaxSpeed, carController.MaxSpeed * 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 = target.position - transform.position;
float distanceCautiousFactor = Mathf.InverseLerp(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 = GetComponent <Rigidbody>().angularVelocity.magnitude *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, cautiousMaxAngle, spinningAngle), distanceCautiousFactor);
desiredSpeed = Mathf.Lerp(carController.MaxSpeed, carController.MaxSpeed * cautiousSpeedFactor,
cautiousnessRequired);
break;
}
case BrakeCondition.NeverBrake:
break; // blarg!
}
// Evasive action due to collision with other cars:
// our target position starts off as the 'real' target position
Vector3 offsetTargetPos = target.position;
// if are we currently taking evasive action to prevent being stuck against another car:
if (Time.time < avoidOtherCarTime)
{
// slow down if necessary (if we were behind the other car when collision occured)
desiredSpeed *= avoidOtherCarSlowdown;
// and veer towards the side of our path-to-target that is away from the other car
offsetTargetPos += target.right * 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 += target.right *
(Mathf.PerlinNoise(Time.time * lateralWanderSpeed, randomPerlin) * 2 - 1) *
lateralWanderDistance;
}
// use different sensitivity depending on whether accelerating or braking:
float accelBrakeSensitivity = (desiredSpeed < carController.CurrentSpeed)
? brakeSensitivity
: accelSensitivity;
// decide the actual amount of accel/brake input to achieve desired speed.
float accel = Mathf.Clamp((desiredSpeed - 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 - accelWanderAmount) +
(Mathf.PerlinNoise(Time.time * accelWanderSpeed, randomPerlin) * 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 * steerSensitivity, -1, 1) * Mathf.Sign(carController.CurrentSpeed);
// feed input to the car controller.
carController.Move(steer, accel);
// if appropriate, stop driving when we're close enough to the target.
if (stopWhenTargetReached && localTarget.magnitude < reachTargetThreshold)
{
driving = false;
}
}
}