public void Update()
{
switch (m_currentState)
{
case EState.INITIAL:
m_nextState = EState.KEEP_POSITION;
ChangeState();
break;
case EState.KEEP_POSITION:
if (m_attackTimer.CheckTimer())
{
m_nextState = EState.SHOOT;
ChangeState();
break;
}
break;
case EState.SHOOT:
if (MathExtent.IsInRange(Vector3.Distance(transform.position, m_blackboard.m_player.position), m_blackboard.m_soloAttackDistanceToPlayer))
{
Shoot();
m_nextState = EState.KEEP_POSITION;
ChangeState();
break;
}
break;
}
}
public void Update()
{
switch (m_currentState)
{
case EStates.INITIAL:
m_nextState = EStates.WANDER;
ChangeState();
break;
case EStates.WANDER:
if (!MathExtent.IsInRange(Vector3.Distance(this.transform.position, m_blackboard.m_player.position), m_blackboard.m_alertRadius))
{
m_nextState = EStates.FIGHT;
ChangeState();
}
break;
case EStates.FIGHT:
if (MathExtent.IsInRange(Vector3.Distance(this.transform.position, m_blackboard.m_player.position), m_blackboard.m_alertRadius))
{
m_nextState = EStates.WANDER;
ChangeState();
}
break;
}
}
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 virtual void ApplyFTI(SteeringOutput steering, GameObject target)
{
transform.rotation = Quaternion.Euler(0, MathExtent.VectorToAngle(target.transform.position - m_ownKS.m_position) - 90f, 0);
m_ownKS.m_orientation = transform.rotation.eulerAngles.y;
steering.m_angularActive = false;
}
public static SteeringOutput GetSteering(KinematicState ownKS, SObstacleAvoidance info)
{
Ray l_ray = new Ray(ownKS.m_position, ownKS.m_linearVelocity.normalized);
RaycastHit l_hitInfo;
if (Physics.Raycast(l_ray, out l_hitInfo, info.m_avoidDistance))
{
SURROGATE_TARGET.position = l_hitInfo.point + l_hitInfo.normal * info.m_avoidDistance;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
l_ray = new Ray(ownKS.m_position, MathExtent.AngleToVector(MathExtent.VectorToAngle(ownKS.m_linearVelocity.normalized) + info.m_AngleSecondWhisk));
if (Physics.Raycast(l_ray, out l_hitInfo, info.m_primaryWhiskerLenght * info.m_RatioSecondWhisk))
{
SURROGATE_TARGET.position = l_hitInfo.point + l_hitInfo.normal * info.m_avoidDistance;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
l_ray = new Ray(ownKS.m_position, MathExtent.AngleToVector(MathExtent.VectorToAngle(ownKS.m_linearVelocity.normalized) - info.m_AngleSecondWhisk));
if (Physics.Raycast(l_ray, out l_hitInfo, info.m_primaryWhiskerLenght * info.m_RatioSecondWhisk))
{
SURROGATE_TARGET.position = l_hitInfo.point + l_hitInfo.normal * info.m_avoidDistance;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
return(NULL_STEERING);
}
public static SteeringOutput GetSteering(KinematicState ownKS)
{
Vector3 l_direction = MathExtent.AngleToVector(ownKS.m_orientation);
SURROGATE_TARGET.position = ownKS.m_position + l_direction;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
public static SteeringOutput GetSteering(KinematicState ownKS, ref SWander info)
{
info.m_targetOrientation += info.m_wanderRate * MathExtent.Binomial();
SURROGATE_TARGET.transform.position = MathExtent.AngleToVector(info.m_targetOrientation) * info.m_wanderRadius;
SURROGATE_TARGET.transform.position += ownKS.m_position + MathExtent.AngleToVector(ownKS.m_orientation) * info.m_wanderOffset;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
protected virtual void ApplyLWYGI(SteeringOutput steering)
{
if (m_ownKS.m_linearVelocity.magnitude > 0.001f)
{
transform.rotation = Quaternion.Euler(0f, MathExtent.VectorToAngle(m_ownKS.m_linearVelocity), 0f);
m_ownKS.m_orientation = transform.rotation.eulerAngles.y;
}
steering.m_angularActive = false;
}
public static SteeringOutput GetSteering(KinematicState me, SKeepPosition info)
{
float targetOrientation = info.m_target.transform.eulerAngles.y;
targetOrientation += info.m_requiredAngle;
Vector3 finalTargetPosition = MathExtent.AngleToVector(targetOrientation).normalized;
finalTargetPosition *= info.m_requiredDistance;
SURROGATE_TARGET.position = info.m_target.position + finalTargetPosition;
return(Seek.GetSteering(me, SURROGATE_TARGET));
}
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));
}
protected virtual void ApplyLWYG(SteeringOutput steering)
{
if (m_ownKS.m_linearVelocity.magnitude > 0.001f)
{
SURROGATE_TARGET.transform.rotation = Quaternion.Euler(0, MathExtent.VectorToAngle(m_ownKS.m_linearVelocity), 0);
m_alignInfo.m_target = SURROGATE_TARGET;
SteeringOutput st = Align.GetSteering(m_ownKS, m_alignInfo);
steering.m_angularAcceleration = st.m_angularAcceleration;
steering.m_angularActive = st.m_angularActive;
}
else
{
steering.m_angularActive = false;
}
}
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;
}
}
public static SteeringOutput GetSteering(KinematicState ownKS, SNaiveWander info)
{
ownKS.m_orientation += info.m_wanderRate * MathExtent.Binomial();
return(GoWhereYouLook.GetSteering(ownKS));
}
public static SteeringOutput GetSteering(KinematicState ownKS, SAlign info)
{
SURROGATE_TARGET.rotation = Quaternion.Euler(SURROGATE_TARGET.eulerAngles.x, MathExtent.VectorToAngle(info.m_target.position - ownKS.m_position), SURROGATE_TARGET.eulerAngles.z);
info.m_target = SURROGATE_TARGET;
return(Align.GetSteering(ownKS, info));
}
