public static Steering GetSteering(Agent npc, float threshold, float targetRadius, float slowRadius, float timeToTarget, bool visibleRays)
{
int neighbours = 0;
float targetOrientation = 0;
Vector3 Heading = Vector3.zero;
int layerMask = 1 << 9;
Collider[] hits = Physics.OverlapSphere(npc.position, threshold, layerMask);
foreach (Collider coll in hits)
{
Agent agent = coll.GetComponent <Agent>();
float distance = Util.HorizontalDist(agent.position, npc.position);
if (agent != npc && distance < threshold)
{
targetOrientation += agent.orientation;
neighbours++;
}
}
if (neighbours > 0)
{
targetOrientation /= neighbours;
return(Align.GetSteering(targetOrientation, npc, targetRadius, slowRadius, timeToTarget, visibleRays));
}
return(new Steering());
}
public static Steering GetSteering(Vector3 targetPosition, Agent npc, float targetRadius, float slowRadius, float timeToTarget, bool visibleRays)
{
Steering steering = new Steering();
Vector3 direction = targetPosition - npc.position;
if (direction.magnitude <= 0.0f)
{
return(steering);
}
float targetOrientation = Mathf.Atan2(direction.x, direction.z);
targetOrientation *= Mathf.Rad2Deg;
// virtualTarget.GetComponent<Agent>.orientation = targetOrientation
// return Align.Steer(...), siendo el target con el que nos vamos a alinear el virtualTarget
return(Align.GetSteering(targetOrientation, npc, targetRadius, slowRadius, timeToTarget, visibleRays));
}
public static Steering GetSteering(Vector3 target, Agent npc, float orientation, float slowingRadius, float maxAccel, bool visibleRays)
{
return(Arrive.GetSteering(target, npc, npc.exteriorRadius, maxAccel) + Align.GetSteering(orientation, npc, npc.interiorAngle, npc.exteriorAngle, 0.1f, visibleRays));
}
public override Steering GetSteering()
{
if (!active)
{
return(new Steering());
}
// Debug.Log ("Vamos a actuar con una orientacion de " + orientation);
Steering force = Arrive.GetSteering(target, npc, npc.exteriorRadius, maxAccel) + Align.GetSteering(orientation, npc, npc.interiorAngle, npc.exteriorAngle, 0.1f, visibleRays);
/* if (Util.HorizontalDistance(target,npc.position) <= 0.1f && Mathf.Abs(orientation - npc.orientation) <= 1.1f)
* GoalReached();*/
// Debug.Log ("El GoForm contribuye al angular en " + force.angular);
return(force);
}
// Update is called once per frame
void Update()
{
if (float.IsNaN(angularVel))
{
angularVel = 0.0f;
}
SteeringOutput moving = new SteeringOutput();
SteeringOutput turning = new SteeringOutput();
seeking.character = this;
seeking.target = aiTarget;
SteeringOutput movement = new SteeringOutput();
switch (movementType)
{
case "Seek":
moving = seeking.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Flee":
flee = true;
moving = seeking.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Arrive":
moving = arrive.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Face":
facing.target = aiTarget;
facing.character = this;
//moving = seeking.GetSteering();
turning = facing.GetSteering();
movement.linear = Vector3.zero;
movement.angular = turning.angular;
break;
case "Seek Align":
aligned.character = this;
aligned.target = aiTarget;
moving = seeking.GetSteering();
turning = aligned.GetSteering();
movement.linear = moving.linear;
movement.angular = turning.angular;
break;
case "Seek Face":
facing.character = this;
facing.target = aiTarget;
moving = seeking.GetSteering();
turning = facing.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Seek Look":
looky.character = this;
looky.target = aiTarget;
//Debug.Log(looky.GetSteering());
if (looky.GetSteering() == null)
{
moving = seeking.GetSteering();
movement.linear = moving.linear;
movement.angular = 0;
}
else
{
moving = seeking.GetSteering();
turning = looky.GetSteering();
//Debug.Log(looky.GetSteering());
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Arrive Align":
aligned.character = this;
aligned.target = aiTarget;
moving = arrive.GetSteering();
turning = aligned.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Arrive Face":
facing.character = this;
facing.target = aiTarget;
moving = arrive.GetSteering();
turning = facing.GetSteering();
movement.linear = moving.linear;
movement.angular = turning.angular;
break;
case "Arrive Look":
looky.character = this;
//looky.target = aiTarget;
arrive.character = this;
arrive.target = aiTarget;
moving = arrive.GetSteering();
turning = looky.GetSteering();
movement.linear = moving.linear;
movement.angular = turning.angular;
Debug.Log(movement.angular);
break;
case "Path Follow":
pathFollow.path = aiTargets;
pathFollow.character = this;
pathFollow.maxAccel = maxAccel;
pathFollow.maxSpeed = maxSpeed;
pathFollow.targetRad = targetRad;
pathFollow.slowRad = slowRad;
moving = pathFollow.GetSteering();
movement.linear = moving.linear;
break;
case "Path Follow Face":
pathFollow.path = aiTargets;
pathFollow.character = this;
pathFollow.maxAccel = maxAccel;
pathFollow.maxSpeed = maxSpeed;
pathFollow.targetRad = targetRad;
pathFollow.slowRad = slowRad;
moving = pathFollow.GetSteering();
aiTarget = pathFollow.target;
facing.character = this;
facing.target = aiTarget;
turning = facing.GetSteering();
movement.linear = moving.linear;
movement.angular = turning.angular;
break;
case "Separate":
separate.character = this;
separate.avoid = kinTargets;
separate.threshold = threshold;
separate.decay = decay;
//separate.avoid = avoidance;
moving = separate.GetSteering();
movement.linear = moving.linear;
movement.angular = 0;
break;
case "Pursue":
pursuing.character = this;
pursuing.target = aiTarget;
moving = pursuing.GetSteering();
movement.linear = moving.linear;
movement.angular = 0;
break;
case "Avoidance":
avoid.character = this;
avoid.targets = kinTargets;
kinTarget = avoid.firstTarget;
moving = avoid.GetSteering();
movement.linear = moving.linear;
movement.angular = 0;
break;
case "Obstacles":
obstacles.character = this;
//obstacles.target = aiTarget;
looky.character = this;
looky.target = obstacles.target;
moving = obstacles.GetSteering();
turning = looky.GetSteering();
movement.linear = moving.linear;
movement.angular = turning.angular;
break;
case "Flocking":
arrive.character = this;
arrive.target = aiTarget;
arrive.maxAccel = maxAccel;
arrive.maxSpeed = maxSpeed;
arrive.targetRad = targetRad;
arrive.slowRad = slowRad;
looky.character = this;
obstacles.character = this;
separate.character = this;
separate.avoid = kinTargets;
separate.threshold = threshold;
separate.decay = decay;
behaviors[0] = new BehaviorAndWeight();
behaviors[0].behavior = arrive;
behaviors[0].weight = 35f;
behaviors[1] = new BehaviorAndWeight();
behaviors[1].behavior = separate;
behaviors[1].weight = 1f;
behaviors[2] = new BehaviorAndWeight();
behaviors[2].behavior = looky;
behaviors[2].weight = 50f;
behaviors[3] = new BehaviorAndWeight();
behaviors[3].behavior = obstacles;
behaviors[3].weight = 10f;
flocking.behaviors = behaviors;
flocking.maxAccel = maxAccel;
flocking.maxRotation = maxRot;
moving = flocking.GetSteering();
movement.linear = moving.linear;
movement.angular = moving.angular;
break;
default:
facing.character = this;
facing.target = aiTarget;
moving = seeking.GetSteering();
turning = aligned.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
}
// Update linear and angular velocities
//Debug.Log(movement.angular);
linearVel += movement.linear * Time.deltaTime;
angularVel += movement.angular * Time.deltaTime;
//angularInc *= Mathf.Rad2Deg;
transform.position += linearVel * Time.deltaTime * maxSpeed;
angularInc = new Vector3(0, angularVel * Time.deltaTime * angVelMax, 0);
//Debug.Log(angularInc)
if (!float.IsNaN(angularInc.y))
{
transform.eulerAngles += angularInc;
}
//Debug.Log(linearVel);
if (linearVel.magnitude > maxSpeed)
{
linearVel.Normalize();
linearVel *= maxSpeed;
}
}
// Update is called once per frame
void Update()
{
//Debug.Log(target);
// Check distance to see if steering behavior should be applied to AI
// float targetDist = (transform.position - target.transform.position).magnitude;
// if (!DistanceActivation || targetDist >= activationRange) { }
transform.position += linearVelocity * Time.deltaTime;
// adding angular velocity to current transform rotation y component
if (float.IsNaN(angularVelocity))
{
angularVelocity = 0;
}
transform.eulerAngles += new Vector3(0, angularVelocity * Time.deltaTime, 0);
// control to switch to proper steering behavior
if (avoidObstacles)
{
ObstacleAvoidance avoid = new ObstacleAvoidance();
avoid.ai = this;
SteeringOutput avoidForce = avoid.GetSteering();
if (avoidForce != null)
{
linearVelocity += avoidForce.linear;
}
}
if (seperationObstacles.Length > 0)
{
Seperation seperation = new Seperation();
seperation.targets = seperationObstacles;
seperation.ai = this;
SteeringOutput seperateForce = seperation.GetSteering();
// check to see if steering is greater than zero and lock out control from other steering
if (seperateForce.linear.magnitude > 0)
{
seperating = true;
}
else
{
seperating = false;
}
linearVelocity += seperateForce.linear * Time.deltaTime;
}
if (collisionAvoidance.Length > 0)
{
CollisionAvoidance avoidKinematic = new CollisionAvoidance();
avoidKinematic.ai = this;
avoidKinematic.targets = collisionAvoidance;
SteeringOutput avoidKinematicForce = avoidKinematic.GetSteering();
if (avoidKinematicForce != null)
{
linearVelocity += avoidKinematicForce.linear;
}
}
switch (movementType)
{
case "seek":
Seek mySeek = new Seek();
mySeek.ai = this;
// if seek is false set seek property on class to false to activate flee
mySeek.seek = true;
mySeek.target = target;
SteeringOutput steeringSeek = mySeek.GetSteering();
if (!seperating)
{
linearVelocity += steeringSeek.linear * Time.deltaTime;
}
if (linearVelocity.magnitude > maxSpeed)
{
linearVelocity.Normalize();
linearVelocity *= maxSpeed;
}
break;
case "flee":
Seek myFlee = new Seek();
myFlee.ai = this;
// if seek is false set seek property on class to false to activate flee
myFlee.seek = false;
myFlee.target = target;
SteeringOutput steeringFlee = myFlee.GetSteering();
if (!seperating)
{
linearVelocity += steeringFlee.linear * Time.deltaTime;
}
if (linearVelocity.magnitude > maxSpeed)
{
linearVelocity.Normalize();
linearVelocity *= maxSpeed;
}
break;
case "arrive":
Arrive myArrive = new Arrive();
myArrive.ai = this;
myArrive.target = target;
SteeringOutput steeringArrive = myArrive.GetSteering();
if (!seperating)
{
linearVelocity += steeringArrive.linear * Time.deltaTime;
}
break;
case "pursue":
Pursue myPursue = new Pursue();
myPursue.ai = this;
myPursue.target = target;
SteeringOutput steeringPursue = myPursue.GetSteering();
if (!seperating)
{
linearVelocity += steeringPursue.linear * Time.deltaTime;
}
if (linearVelocity.magnitude > maxSpeed)
{
linearVelocity.Normalize();
linearVelocity *= maxSpeed;
}
break;
case "evade":
Pursue myEvade = new Pursue();
myEvade.ai = this;
myEvade.target = target;
// This changes the seek flag in the parent Seek class of Pursue, sending it the flee vector instead
myEvade.seek = false;
SteeringOutput steeringEvade = myEvade.GetSteering();
if (!seperating)
{
linearVelocity += steeringEvade.linear * Time.deltaTime;
}
if (linearVelocity.magnitude > maxSpeed)
{
linearVelocity.Normalize();
linearVelocity *= maxSpeed;
}
break;
default:
// provide no input
break;
// If obstacles have been provided, return steering to seperate from them
}
switch (rotationType)
{
case "face":
Face myFace = new Face();
myFace.ai = this;
myFace.target = target;
SteeringOutput steeringFace = myFace.GetSteering();
if (steeringFace != null)
{
// linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steeringFace.angular * Time.deltaTime;
}
break;
case "align":
Align myAlign = new Align();
myAlign.ai = this;
myAlign.target = target;
SteeringOutput steeringAlign = myAlign.GetSteering();
if (steeringAlign != null)
{
//linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steeringAlign.angular * Time.deltaTime;
}
break;
case "look":
LookWhereGoing myLook = new LookWhereGoing();
myLook.ai = this;
myLook.target = target;
SteeringOutput steeringLook = myLook.GetSteering();
if (steeringLook != null)
{
//linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steeringLook.angular * Time.deltaTime;
}
break;
default:
//provide no input
break;
}
}
// Update is called once per frame
void Update()
{
transform.position += linearVelocity * Time.deltaTime;
// adding angular velocity to current transform rotation y component
if (float.IsNaN(angularVelocity))
{
angularVelocity = 0;
}
transform.eulerAngles += new Vector3(0, angularVelocity * Time.deltaTime, 0);
//dynamicSteering steering = new Seek();
// control to switch to proper steering behavior
if (!arrive)
{
Seek mySeek = new Seek();
mySeek.ai = this;
// if seek is false set seek property on class to false to activate flee
if (!seek)
{
mySeek.seek = false;
}
else
{
mySeek.seek = true;
}
mySeek.target = target;
SteeringOutput steering = mySeek.GetSteering();
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
if (linearVelocity.magnitude > maxSpeed)
{
linearVelocity.Normalize();
linearVelocity *= maxSpeed;
}
}
else
{
Arrive myArrive = new Arrive();
myArrive.ai = this;
myArrive.target = target;
SteeringOutput steering = myArrive.GetSteering();
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
if (align)
{
Align myAlign = new Align();
myAlign.ai = this;
myAlign.target = target;
SteeringOutput steering = myAlign.GetSteering();
if (steering != null)
{
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
}
if (lookWhereGoing && !align && !face)
{
LookWhereGoing myLook = new LookWhereGoing();
myLook.ai = this;
myLook.target = target;
SteeringOutput steering = myLook.GetSteering();
if (steering != null)
{
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
else
{
Debug.Log("Returning Null");
}
}
if (!lookWhereGoing && !align && face)
{
Face myFace = new Face();
myFace.ai = this;
myFace.target = target;
SteeringOutput steering = myFace.GetSteering();
if (steering != null)
{
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
}
}
public Steering GetSteering()
{
return(Align.GetSteering(target.orientation, npc, npc.interiorAngle, npc.exteriorAngle, timeToTarget, visibleRays));
}
public static Steering GetSteering(Agent target, Agent npc, float targetRadius, float slowRadius, float timeToTarget, bool visibleRays)
{
return(Align.GetSteering(target.orientation + 180.0f, npc, targetRadius, slowRadius, timeToTarget, visibleRays));
}
void Update()
{
SteeringOutput movementSteering;
//SteeringOutput lookSteering;
//Update position and rotation
transform.position += linearVelocity * Time.deltaTime;
Vector3 angularIncrement = new Vector3(0, angularVelocity * Time.deltaTime, 0);
transform.eulerAngles += angularIncrement;
switch (moveType)
{
case SteeringType.Pursue:
movementSteering = pursueAI.GetSteering();
break;
case SteeringType.Evade:
movementSteering = evadeAI.GetSteering();
break;
case SteeringType.FollowPath:
movementSteering = followAI.GetSteering();
break;
case SteeringType.Seek:
movementSteering = seekAI.GetSteering();
break;
case SteeringType.Flee:
movementSteering = fleeAI.GetSteering();
break;
case SteeringType.Seperation:
movementSteering = seperationAI.GetSteering();
break;
case SteeringType.Arrive:
movementSteering = arriveAI.GetSteering();
break;
case SteeringType.CollisionAvoidance:
movementSteering = avoidAI.GetSteering();
break;
case SteeringType.ObstacleAvoidance:
movementSteering = obstacleAI.GetSteering();
break;
default:
movementSteering = new SteeringOutput();
break;
}
if (movementSteering != null)
{
linearVelocity += movementSteering.linear * Time.deltaTime;
//angularVelocity += movementSteering.angular * Time.deltaTime;
}
switch (lookType)
{
case LookType.None:
break;
case LookType.Align:
lookSteering = alignAI.GetSteering();
break;
case LookType.Face:
lookSteering = faceAI.GetSteering();
break;
case LookType.LookWhereGoing:
lookSteering = lookAI.GetSteering();
break;
default:
lookSteering = alignAI.GetSteering();
break;
}
if (lookSteering != null)
{
angularVelocity += lookSteering.angular * Time.deltaTime;
}
//Update kinematic reference with complex data it can't get by itself
kinematic.GetData(movementSteering);
kinematic.GetData(lookSteering);
}
// Update is called once per frame
void Update()
{
seeking = new Seek_And_Flee();
arrive = new Arrival();
//aligning = new Align();
SteeringOutput moving = new SteeringOutput();
SteeringOutput turning = new SteeringOutput();
seeking.character = this;
seeking.target = aiTarget;
arrive.character = this;
arrive.target = aiTarget;
SteeringOutput movement = new SteeringOutput();
switch (movementType)
{
case "Seek":
moving = seeking.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Flee":
flee = true;
moving = seeking.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Arrive":
moving = arrive.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Face":
Face staticFace = new Face();
staticFace.target = aiTarget;
staticFace.character = this;
//moving = seeking.GetSteering();
turning = staticFace.GetSteering();
movement.linear = Vector3.zero;
movement.angular = turning.angular;
break;
case "Seek Align":
Align aligning = new Align();
SteeringOutput turn = new SteeringOutput();
aligning.character = this;
aligning.target = aiTarget;
moving = seeking.GetSteering();
turn = aligning.GetSteering();
movement.linear = moving.linear;
movement.angular = turn.angular;
break;
case "Seek Face":
Face faces = new Face
{
character = this,
target = aiTarget
};
moving = seeking.GetSteering();
turning = faces.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Seek Look":
Look_Where_Going looky = new Look_Where_Going();
SteeringOutput shouldTurn = new SteeringOutput();
looky.character = this;
looky.target = aiTarget;
Debug.Log(looky.GetSteering());
moving = seeking.GetSteering();
shouldTurn = looky.GetSteering();
Debug.Log(looky.GetSteering());
movement.linear = moving.linear;
movement.angular = shouldTurn.angular;
break;
case "Arrive Align":
Align aligned = new Align
{
character = this,
target = aiTarget
};
moving = arrive.GetSteering();
turning = aligned.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
case "Arrive Face":
Face facing = new Face();
facing.character = this;
facing.target = aiTarget;
//Debug.Log(facing.target);
//Debug.Log(facing);
moving = arrive.GetSteering();
turning = facing.GetSteering();
//Debug.Log(facing);
//Debug.Log(turning.angular);
movement.linear = moving.linear;
movement.angular = turning.angular;
//Debug.Log(movement.angular);
break;
case "Arrive Look":
Look_Where_Going look = new Look_Where_Going
{
character = this,
target = aiTarget
};
moving = arrive.GetSteering();
turning = look.GetSteering();
//Debug.Log(turning.angular);
movement.linear = moving.linear;
movement.angular = turning.angular;
Debug.Log(movement.angular);
break;
default:
Face aligns = new Face
{
character = this,
target = aiTarget
};
moving = seeking.GetSteering();
turning = aligns.GetSteering();
if (moving == null)
{
movement.linear = Vector3.zero;
}
else
{
movement.linear = moving.linear;
movement.angular = turning.angular;
}
break;
}
// Update linear and angular velocities
//Debug.Log(movement.angular);
linearVel += movement.linear * Time.deltaTime;
angularVel += movement.angular * Time.deltaTime;
//angularInc *= Mathf.Rad2Deg;
transform.position += linearVel * Time.deltaTime;
angularInc = new Vector3(0, angularVel * Time.deltaTime, 0);
//Debug.Log(angularInc);
transform.eulerAngles += angularInc;
}
public SteeringOutput GetAction()
{
flockingOutput.m_linear = cohesion.GetSteering(m_MaxSpeed).m_linear + align.GetSteering().m_linear;
flockingOutput.m_angular = cohesion.GetSteering(m_MaxSpeed).m_angular *align.GetSteering().m_angular;
return(flockingOutput);
}
