public static SteeringOutput GetSteering(KinematicState ownKS,
ref float targetOrientation,
float wanderRate = 30f,
float wanderRadius = 10f, float wanderOffset = 20f)
{
// change target orientation (change location of surrogate target on unit circle)
targetOrientation += wanderRate * Utils.binomial();
// place surrogate target on circle of wanderRadius
SURROGATE_TARGET.transform.position = Utils.OrientationToVector(targetOrientation) * wanderRadius;
// place circle "in front"
SURROGATE_TARGET.transform.position += ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset;
// show some gizmos before returning
Debug.DrawLine(ownKS.position,
ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset,
Color.black);
DebugExtension.DebugCircle(ownKS.position + Utils.OrientationToVector(ownKS.orientation) * wanderOffset,
new Vector3(0, 0, 1),
Color.red,
wanderRadius);
DebugExtension.DebugPoint(SURROGATE_TARGET.transform.position,
Color.black,
5f);
// Seek the surrogate target
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
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));
}
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)
{
SteeringOutput steering = new SteeringOutput();
Vector3 desiredDirection = Vector3.zero;
if (Input.GetKey(KeyCode.LeftArrow))
{
desiredDirection += Vector3.left;
}
if (Input.GetKey(KeyCode.RightArrow))
{
desiredDirection += Vector3.right;
}
if (Input.GetKey(KeyCode.UpArrow))
{
desiredDirection += Vector3.up;
}
if (Input.GetKey(KeyCode.DownArrow))
{
desiredDirection += Vector3.down;
}
if (desiredDirection.magnitude < 0.01f)
{
return(NULL_STEERING);
}
else
{
steering.linearAcceleration = desiredDirection * ownKS.maxAcceleration;
}
return(steering);
}
private SteeringOutput NaiveWander(KinematicState own)
{
// align with a surrogate target that has your new orientation and go there
SteeringOutput align, goWYL;
KinematicState surrogateTarget = new KinematicState();
// "sligtly" change the orientation
float desiredOrientation = own.orientation + wanderRate * binomial();
// give that orientation to the surrogate target
surrogateTarget.orientation = desiredOrientation;
// align
align = Align(own, surrogateTarget);
// go where you look (move "forward");
goWYL = goWhereYouLook(own); //goWhereYouLook never returns null...
// combine and return
if (align != null && goWYL != null)
{
goWYL.angularAcceleration = align.angularAcceleration;
}
return(goWYL);
}
private SteeringOutput Wander(KinematicState own, KinematicState wanderTarget)
{
// update orientation of wanderTarget
wanderTarget.orientation = wanderTarget.orientation + wanderRate * binomial();
// place the center of the wander circle
wanderTarget.position = own.position + wanderDistance * OrientationToVector(own.orientation);
// place the target somewhere in the wander circle
wanderTarget.position = wanderTarget.position + wanderRadius * OrientationToVector(wanderTarget.orientation + own.orientation);
/* why wanderTarget.orientation+own.orientation?
* because wanderTarget.orintation is in local -own- system and must be in world system
*/
// face the target
SteeringOutput face = Face(own, wanderTarget);
// go where you look (move "forward");
SteeringOutput goWYL = goWhereYouLook(own); //goWhereYouLook never returns null...
// combine and return
if (face != null && goWYL != null)
{
goWYL.angularAcceleration = face.angularAcceleration;
}
return(goWYL);
}
public static SteeringOutput GetSteering(KinematicState ownKS, GameObject target, float RequiredDsitance, float DesiredAngle)
{
Vector3 DirectionFromTarget;
Vector3 DesiredPos;
Vector3 OrientationVector;
float targetOrientation = target.transform.eulerAngles.z;
// Compute direction to target
OrientationVector = Utils.OrientationToVector(targetOrientation + DesiredAngle);
DirectionFromTarget = ((ownKS.position - target.transform.position)).normalized;
DesiredPos = (target.transform.position + DirectionFromTarget * RequiredDsitance) + OrientationVector;
//Matriz de rotacion 2d
//DirectionFromTarget.y = OrientationVector.x * Mathf.Sin(Mathf.Deg2Rad * DesiredAngle) + OrientationVector.y * Mathf.Cos(Mathf.Deg2Rad * DesiredAngle);
//DirectionFromTarget.x = OrientationVector.x * Mathf.Cos(Mathf.Deg2Rad * DesiredAngle) - OrientationVector.y * Mathf.Sin(Mathf.Deg2Rad * DesiredAngle);
//DirectionFromTarget.Normalize();
if (My_KeepDistanceVersatile.surrogateTarget == null)
{
My_KeepDistanceVersatile.surrogateTarget = new GameObject("Dummy (Surrogate Target for keep distance)");
}
My_KeepDistanceVersatile.surrogateTarget.transform.position = DesiredPos;
return(Seek.GetSteering(ownKS, surrogateTarget));
}
public static SteeringOutput GetSteering(KinematicState ownKS, GameObject target)
{
SteeringOutput result = Seek.GetSteering(ownKS, target);
result.linearAcceleration = -result.linearAcceleration;
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS,
float WanderRate, float wanderRadius, float wanderOffset, ref float targetOrientation,
bool showWhishker, float lookAheadLength, float avoidDistance, float secondaryWhiskerAngle, float secondaryWhiskerRatio,
ref bool avoidActive)
{
// give priority to obstacle avoidance
SteeringOutput so = ObstacleAvoidance.GetSteering(ownKS, showWhishker, lookAheadLength,
avoidDistance, secondaryWhiskerAngle, secondaryWhiskerRatio);
if (so == NULL_STEERING)
{
if (avoidActive)
{
// if avoidance was active last frame, update target orientation (otherwise the object would tend to regain
// the orientation it had before avoiding a collision which would make it face the obstacle again)
targetOrientation = ownKS.orientation;
}
avoidActive = false;
return(Wander.GetSteering(ownKS, ref targetOrientation, WanderRate, wanderRadius, wanderOffset));
}
else
{
avoidActive = true;
return(so);
}
}
public static SteeringOutput GetSteering(KinematicState ownKS,
GameObject target, float distance, float angle,
string tag, float repulsionTh,
float wlr /* COMPLETE */)
{
// compute both steerings
SteeringOutput lr = LinearRepulsion.GetSteering(ownKS, tag, repulsionTh);
SteeringOutput kp = KeepPosition.GetSteering(ownKS, target, distance, angle);
// blend
// (if one is SteeringBehaviour.NULL_STEERING return the other.
// if none is SteeringBehaviour.NULL_STEERING blend with weights wlr and 1-wlr)
/* COMPLETE */
if (lr == SteeringBehaviour.NULL_STEERING)
{
return(kp);
}
if (kp == SteeringBehaviour.NULL_STEERING)
{
return(lr);
}
// "concoct" the blending on lr
lr.linearAcceleration = wlr * lr.linearAcceleration + (1 - wlr) * kp.linearAcceleration;
return(lr);
}
public static SteeringOutput GetSteering(KinematicState ownKS, float wanderRate = 30f, float targetAngularRadius = 2f,
float slowDownAngularRadius = 10f, float timeToDesiredAngularSpeed = 0.1f)
{
// align with a surrogate target that has your new orientation and go there
// slightly change the orientation
float desiredOrientation = ownKS.orientation + wanderRate * Utils.binomial();
// give that orientation to the surrogate target
SURROGATE_TARGET.transform.rotation = Quaternion.Euler(0, 0, desiredOrientation);
// align with the surrogate target
SteeringOutput al = Align.GetSteering(ownKS, SURROGATE_TARGET, targetAngularRadius, slowDownAngularRadius, timeToDesiredAngularSpeed);
// go where you look (looked, actually)
SteeringOutput gwyl = GoWhereYouLook.GetSteering(ownKS); // should never return null
// combine, if possible
if (al != null)
{
gwyl.angularActive = true;
gwyl.angularAcceleration = al.angularAcceleration;
}
return(gwyl);
}
public static SteeringOutput GetSteering(KinematicState ownKS)
{
SteeringOutput steering = new SteeringOutput();
Vector3 desiredDirection = Vector3.zero;
if (Input.GetKey(KeyCode.LeftArrow))
{
desiredDirection += Vector3.left;
}
if (Input.GetKey(KeyCode.RightArrow))
{
desiredDirection += Vector3.right;
}
if (Input.GetKey(KeyCode.UpArrow))
{
desiredDirection += Vector3.up;
}
if (Input.GetKey(KeyCode.DownArrow))
{
desiredDirection += Vector3.down;
}
// Beware, this part of the code tampers with speed...
if (desiredDirection.magnitude < 0.01f)
{
ownKS.linearVelocity = Vector3.zero; // STOP
}
steering.linearAcceleration = desiredDirection * ownKS.maxAcceleration;
return(steering);
}
public static SteeringOutput GetSteering(KinematicState ownKS, GameObject repulsor, float scareRadius = 40f, float fleeWeight = 0.2f, string idTag = "BOID",
float cohesionThreshold = 40f, float repulsionThreshold = 10f,
float wanderRate = 10f)
{
SteeringOutput fleeOutput;
if ((ownKS.position - repulsor.transform.position).magnitude <= scareRadius)
{
fleeOutput = Flee.GetSteering(ownKS, repulsor);
}
else
{
fleeOutput = NULL_STEERING;
}
SteeringOutput result = Flocking.GetSteering(ownKS, idTag, cohesionThreshold, repulsionThreshold, wanderRate);
// beware, Flocking may return NULL_STEERING. In that case, just apply flee
if (result == NULL_STEERING)
{
return(fleeOutput);
}
result.linearAcceleration = result.linearAcceleration * (1 - fleeWeight) + fleeOutput.linearAcceleration * fleeWeight;
result.angularAcceleration = result.angularAcceleration * (1 - fleeWeight) + fleeOutput.angularAcceleration * fleeWeight;
return(result);
}
private SteeringOutput ScaredFish(KinematicState own)
{
SteeringOutput obstacleAvoidance = ObstacleAvoidance2D(own);
//SteeringOutput flocking = Flocking(own);
//SteeringOutput collision = CollisionAvoidance (own, "PREDATOR");
if (obstacleAvoidance == null)
{
GameObject pred = GameObject.FindGameObjectWithTag("PREDATOR");
KinematicState targetKS = pred.GetComponent <Steerings2> ().ownKS;
if ((own.position - targetKS.position).magnitude < 200)
{
return(Flee(own, targetKS));
}
else
{
return(Flocking(own));
}
}
else
{
return(obstacleAvoidance);
}
}
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, GameObject target, float maxPredictionTime = 3f)
{
// we need to know the kinematic state of the target since we need to know its linear velocity
// if target has no kinematic state "give up" and just seek
KinematicState targetKS = target.GetComponent <KinematicState> ();
if (targetKS == null)
{
Debug.Log("Pursue invoked with a target that has no kinematic state attached. Resorting to Seek");
return(Seek.GetSteering(ownKS, target));
}
Vector3 directionToTarget = targetKS.position - ownKS.position;
float distanceToTarget = directionToTarget.magnitude;
float currentSpeed = ownKS.linearVelocity.magnitude;
// determine the time it will take to reach the target
float predictedTimeToTarget = distanceToTarget / currentSpeed;
if (predictedTimeToTarget > maxPredictionTime)
{
predictedTimeToTarget = maxPredictionTime;
}
// now determine future (at predicted time) location of target
Vector3 futurePositionOfTarget = targetKS.position + targetKS.linearVelocity * predictedTimeToTarget;
// create surrogate target and place it at future location
SURROGATE_TARGET.transform.position = futurePositionOfTarget;
// delegate to seek
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
// could also delegate to Arrive if overshooting is an issue...
}
private SteeringOutput Pursue(KinematicState own, KinematicState target)
// INTERCEPT
{
Vector3 directionToTarget = target.position - own.position;
float distanceToTarget = directionToTarget.magnitude;
float currentSpeed = own.linearVelocity.magnitude;
// determine the time it will take to reach the target
float predictedTimeToTarget = distanceToTarget / currentSpeed;
if (predictedTimeToTarget > maxPredictionTime)
{
predictedTimeToTarget = maxPredictionTime;
}
// now determine future (at predicted time) location of target
Vector3 futurePositionOfTarget = target.position + target.linearVelocity * predictedTimeToTarget;
// create surrogate target and place it at future location
KinematicState surrogateTarget = new KinematicState();
surrogateTarget.position = futurePositionOfTarget;
// delegate to arrive
return(Arrive(own, surrogateTarget));
// could also delegate to seek... but we risk overshooting...
// return Seek(own, surrogateTarget);
}
public static SteeringOutput GetSteering(KinematicState ownKS, float wanderRate = 10f)
{
// "slightly" change your own orientation
ownKS.orientation += Utils.binomial() * wanderRate;
// and go where you look
return(GoWhereYouLook.GetSteering(ownKS));
}
public static SteeringOutput GetSteering(KinematicState ownKS, Transform target)
{
SteeringOutput result = new SteeringOutput();
result.m_linearAcceleration = (target.position - ownKS.m_position).normalized * ownKS.m_maxLinearAcceleration;
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS, Transform target)
{
SteeringOutput result = Seek.GetSteering(ownKS, target);
result.m_linearAcceleration *= -1;
return(result);
}
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, GameObject target)
{
// invoke SEEK...
SteeringOutput result = Seek.GetSteering(ownKS, target);
// ... reverse direction and that's all
result.linearAcceleration = -result.linearAcceleration;
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS, float seekWeight, ref SWander wanderInfo, SSeek seekInfo)
{
SteeringOutput seekSteering = Seek.GetSteering(ownKS, seekInfo.m_target);
SteeringOutput result = Wander.GetSteering(ownKS, ref wanderInfo);
result.m_linearAcceleration = result.m_linearAcceleration * (1f - seekWeight) + seekSteering.m_linearAcceleration * seekWeight;
return(result);
}
private SteeringOutput Flee(KinematicState own, KinematicState target)
{
SteeringOutput steering;
steering = Seek(own, target);
steering.linearAcceleration *= -1; // reverse sense of acceleration
return(steering);
}
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));
}
public static SteeringOutput GetSteering(KinematicState ownKS, GameObject target,
float targetAngularRadius = 2f,
float slowDownAngularRadius = 10f,
float timeToDesiredAngularSpeed = 0.1f)
{
SteeringOutput result = new SteeringOutput();
result.linearActive = false; // this is not a linear steering
result.angularActive = true; // this is a rotational steering
float requiredAngularSpeed;
float targetOrientation = target.transform.eulerAngles.z; // BEWARE...
float requiredRotation = targetOrientation - ownKS.orientation; // how many degs do we have to rotate?
if (requiredRotation < 0)
{
requiredRotation = 360 + requiredRotation; // map to positive angles
}
if (requiredRotation > 180)
{
requiredRotation = -(360 - requiredRotation); // don't rotate more than 180 degs. just reverse rotation sense
}
// when here, required rotation is in [-180, +180]
float rotationSize = Mathf.Abs(requiredRotation);
if (rotationSize <= targetAngularRadius) // if we're "there", no steering needed
{
return(NULL_STEERING);
}
if (rotationSize > slowDownAngularRadius)
{
requiredAngularSpeed = ownKS.maxAngularSpeed;
}
else
{
requiredAngularSpeed = ownKS.maxAngularSpeed * (rotationSize / slowDownAngularRadius);
}
// restablish sign
requiredAngularSpeed = requiredAngularSpeed * Mathf.Sign(requiredRotation);
// compute acceleration
result.angularAcceleration = (requiredAngularSpeed - ownKS.angularSpeed) / timeToDesiredAngularSpeed;
// clip if necessary
if (Mathf.Abs(result.angularAcceleration) > ownKS.maxAngularAcceleration)
{
result.angularAcceleration = ownKS.maxAngularAcceleration * Mathf.Sign(result.angularAcceleration);
}
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS)
{
// just "seek" your own direction
Vector3 myDirection = Utils.OrientationToVector(ownKS.orientation);
SURROGATE_TARGET.transform.position = ownKS.position + myDirection;
return(Seek.GetSteering(ownKS, SURROGATE_TARGET));
}
public static SteeringOutput GetSteering(KinematicState me, GameObject target, float distance, float angle)
{
float desiredAngle = target.transform.eulerAngles.z + angle;
Vector3 desiredDirectionFromTarget = Utils.OrientationToVector(desiredAngle).normalized;
desiredDirectionFromTarget *= distance;
SURROGATE_TARGET.transform.position = desiredDirectionFromTarget + target.transform.position;
return(Arrive.GetSteering(me, SURROGATE_TARGET, 0, 5, 0.1f));
}
public static SteeringOutput GetSteering(KinematicState ownKS)
{
SteeringOutput result = new SteeringOutput();
result.angularActive = true;
Vector3 desiredDirection = Vector3.zero;
float desiredAngularDirection = 0;
// UP is MOVE FORWARD.
// DOWN is MOVE BACKWARDS.
if (Input.GetKey(KeyCode.UpArrow))
{
desiredDirection += Utils.OrientationToVector(ownKS.orientation);
}
if (Input.GetKey(KeyCode.DownArrow))
{
desiredDirection += -Utils.OrientationToVector(ownKS.orientation);
}
if (Input.GetKey(KeyCode.LeftArrow))
{
desiredAngularDirection += 1f;
}
if (Input.GetKey(KeyCode.RightArrow))
{
desiredAngularDirection += -1f;
}
// Beware: this part of the code tampers with the speed...
if (desiredAngularDirection == 0)
{
ownKS.angularSpeed = 0; // stop!!!
if (desiredDirection.magnitude < 0.01f)
{
ownKS.linearVelocity = Vector3.zero; // stop!!
}
}
if (desiredAngularDirection == 0f)
{
result.angularActive = false;
}
if (desiredDirection.magnitude < 0.01f)
{
result.linearActive = false;
}
result.linearAcceleration = desiredDirection * ownKS.maxAcceleration;
result.angularAcceleration = desiredAngularDirection * ownKS.maxAngularAcceleration;
return(result);
}
public static SteeringOutput GetSteering(KinematicState ownKS)
{
SteeringOutput result = new SteeringOutput();
result.angularAcceleration = ownKS.maxAngularAcceleration;
SteeringOutput r2 = GoWhereYouLook.GetSteering(ownKS);
result.linearAcceleration = r2.linearAcceleration;
return(result);
}
