public static SteeringOutput GetSteering(KinematicState ownKS, SArrive info)
{
Vector3 l_distanceToTarget = info.m_target.position - ownKS.m_position;
if (l_distanceToTarget.magnitude < info.m_closeEnoughRadius)
{
return(NULL_STEERING);
}
if (l_distanceToTarget.magnitude > info.m_slowDownRadius)
{
return(Seek.GetSteering(ownKS, info.m_target));
}
float l_desiredSpeed = ownKS.m_maxLinearSpeed * (l_distanceToTarget.magnitude / info.m_slowDownRadius);
Vector3 l_desiredVelocity = l_distanceToTarget.normalized * l_desiredSpeed;
Vector3 l_requiredAcceleration = (l_desiredVelocity - ownKS.m_linearVelocity) / info.m_timeToDesiredSpeed;
l_requiredAcceleration = MathExtent.Clip(l_requiredAcceleration, ownKS.m_maxLinearAcceleration);
SteeringOutput result = new SteeringOutput();
result.m_linearAcceleration = l_requiredAcceleration;
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS, SIntercept info)
{
if (info.m_targetLinearVelocity == null)
{
return(NULL_STEERING);
}
float l_predictedTimeToTarget = (info.m_target.position - ownKS.m_position).magnitude / ownKS.m_linearVelocity.magnitude;
l_predictedTimeToTarget = MathExtent.Clip(l_predictedTimeToTarget, info.m_maxPredictionTime);
SURROGATE_TARGET.position = info.m_target.position + (info.m_targetLinearVelocity * l_predictedTimeToTarget);
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
public static SteeringOutput GetSteering(KinematicState ownKS, SEvade info)
{
if (info.m_targetLinearVelocity == null)
{
return(NULL_STEERING);
}
float l_distanceToMe = (ownKS.m_position - info.m_target.position).magnitude;
float l_predictedCollisionTime = l_distanceToMe / info.m_targetLinearVelocity.magnitude;
l_predictedCollisionTime = MathExtent.Clip(l_predictedCollisionTime, info.m_maxPredictionTime);
SURROGATE_TARGET.position = info.m_target.position + info.m_targetLinearVelocity * l_predictedCollisionTime;
return(Flee.GetSteering(ownKS, SURROGATE_TARGET));
}
public static SteeringOutput GetSteering(KinematicState ownKS, SVelocityMatching info)
{
if (info.m_targetLinearVelocity == null)
{
return(NULL_STEERING);
}
Vector3 l_requiredAcceleration = (info.m_targetLinearVelocity - ownKS.m_linearVelocity) / info.m_timeToDesiredVelocity;
l_requiredAcceleration = MathExtent.Clip(l_requiredAcceleration, ownKS.m_maxLinearAcceleration);
SteeringOutput l_result = new SteeringOutput();
l_result.m_linearAcceleration = l_requiredAcceleration;
return(l_result);
}
public static SteeringOutput GetSteering(KinematicState ownKS, SAlign info)
{
float l_requiredAngularSpeed;
float l_requiredAngularAcceleration;
float l_angleSize;
float l_requiredRotation = info.m_target.rotation.eulerAngles.y - ownKS.m_orientation;
if (l_requiredRotation < 0f)
{
l_requiredRotation += 360f;
}
if (l_requiredRotation > 180f)
{
l_requiredRotation = -(360f - l_requiredRotation);
}
l_angleSize = Mathf.Abs(l_requiredRotation);
if (l_angleSize <= info.m_closeEnoughAngle)
{
return(NULL_STEERING);
}
if (l_angleSize > info.m_slowDownAngle)
{
l_requiredAngularSpeed = ownKS.m_maxAngularSpeed;
}
else
{
l_requiredAngularSpeed = ownKS.m_maxAngularSpeed * (l_angleSize - info.m_slowDownAngle);
}
l_requiredAngularSpeed *= Mathf.Sign(l_requiredRotation);
l_requiredAngularAcceleration = (l_requiredAngularSpeed - ownKS.m_angularSpeed) / info.m_timeToDesiredAngularSpeed;
l_requiredAngularAcceleration = MathExtent.Clip(l_requiredAngularAcceleration, ownKS.m_maxAngularAcceleration, true);
SteeringOutput result = new SteeringOutput();
result.m_angularAcceleration = l_requiredAngularAcceleration;
return(result);
}
void Update()
{
//Get Accelerations
SteeringOutput l_steering = GetSteering();
//Stop if there is no acceleration
if (l_steering == null)
{
m_ownKS.m_linearVelocity = Vector3.zero;
m_ownKS.m_angularSpeed = 0f;
return;
}
float dt = Time.deltaTime;
//Apply linear accelerations
if (l_steering.m_linearActive)
{
m_ownKS.m_linearVelocity = m_ownKS.m_linearVelocity + l_steering.m_linearAcceleration * dt;
m_ownKS.m_linearVelocity = MathExtent.Clip(m_ownKS.m_linearVelocity, m_ownKS.m_maxLinearSpeed);
m_ownKS.m_position += m_ownKS.m_linearVelocity * dt + 0.5f * l_steering.m_linearAcceleration * dt * dt;
transform.position = m_ownKS.m_position;
}
else
{
m_ownKS.m_linearVelocity = Vector3.zero;
}
//Apply angular Accelerations
if (l_steering.m_angularActive)
{
m_ownKS.m_angularSpeed = m_ownKS.m_angularSpeed + l_steering.m_angularAcceleration * dt;
m_ownKS.m_angularSpeed = MathExtent.Clip(m_ownKS.m_angularSpeed, m_ownKS.m_maxAngularSpeed, true);
m_ownKS.m_orientation += m_ownKS.m_angularSpeed * dt + 0.5f * l_steering.m_angularAcceleration * dt * dt;
transform.rotation = Quaternion.Euler(0f, m_ownKS.m_orientation, 0f);
}
else
{
m_ownKS.m_angularSpeed = 0f;
}
}