public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
int count = 0;
foreach (Kinematic target in targets)
{
Vector3 direction = target.posicion - character.posicion;
float distance = direction.magnitude;
if (distance < threshold)
{
steering.vector += target.posicion;
count++;
}
}
if (count == 0)
{
return(steering);
}
steering.vector /= count;
kinetic.posicion = steering.vector;
target = kinetic;
return(base.GetSteering(character));
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
int count = 0;
foreach (Kinematic target in targets)
{
Vector3 direction = target.posicion - character.posicion;
float distance = direction.magnitude;
if (distance < threshold)
{
steering.real += target.orientacion;
count++;
}
}
if (count > 0)
{
steering.real = steering.real / count;
steering.real -= character.orientacion;
}
return(steering);
}
// Update is called once per frame
void Update()
{
if (Input.GetKey(KeyCode.A))
{
distancePathfinding = 1;
}
if (Input.GetKey(KeyCode.S))
{
distancePathfinding = 2;
}
if (Input.GetKey(KeyCode.D))
{
distancePathfinding = 3;
}
if (Input.GetMouseButtonDown(0) && distancePathfinding != 0)
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 1000.0f))
{
if (hit.transform != null && hit.transform.tag != "Muro" && hit.transform.tag != "Agua")
{
listPuntos = controlador.EstablecerNodoFinal(this);
pintarCamino();
}
}
}
for (int i = 0; i < listSteerings.Length; i++)
{
SteeringOutPut str = listSteerings[i].GetSteering(this);
setSteering(str);
}
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
if (listPuntos != character.listPuntos)
{
listPuntos = character.listPuntos;
nodoActual = 0;
}
if (listPuntos.Count != 0 && nodoActual < listPuntos.Count)
{
puntos = new Vector3[listPuntos.Count];
for (int i = 0; i < listPuntos.Count; i++)
{
puntos[i] = listPuntos[i];
}
pathTarget.posicion = puntos[nodoActual];
Vector3 distance = pathTarget.posicion - character.posicion;
float distancia = distance.magnitude;
if (distancia <= radius)
{
nodoActual++;
}
if (nodoActual >= puntos.Length)
{
return(steering);
}
target = pathTarget;
return(base.GetSteering(character));
}
return(steering);
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
if (kinetic != null)
{
kinetic.posicion = character.posicion;
}
wanderOrientation += randomBinomial() * wanderRate;
float targetOrientation = wanderOrientation + character.orientacion; //La orientación del objetivo
kinetic.orientacion = targetOrientation;
Vector3 target = character.posicion + wanderOffset * asVector(character.orientacion);
target += wanderRadius * asVector(targetOrientation);
kinetic.posicion = target;
targetOrig = kinetic;
steering = base.GetSteering(character);
steering.vector = character.maxAceleration * asVector(targetOrientation);
return(steering);
}
public void setSteering(SteeringOutPut str)
{
if (str.vector.magnitude > 0)
{
velocidadActual = velocidadActual + str.vector * Time.deltaTime; //str.vector = aceleracion
posicion = posicion + velocidadActual * Time.deltaTime;
}
else
{
velocidadActual -= velocidadActual * Time.deltaTime; //str.vector = aceleracion
posicion = posicion + velocidadActual * Time.deltaTime;
}
if (str.real > 0)
{
rotacionActual = rotacionActual + str.real * Time.deltaTime; //str.real = aceleracion angular
orientacion = orientacion + rotacionActual * Time.deltaTime;
}
else
{
rotacionActual -= rotacionActual * Time.deltaTime; //str.real = aceleracion angular
orientacion = orientacion + rotacionActual * Time.deltaTime;
}
transform.position = posicion;
transform.rotation = Quaternion.identity;
//ajustar con los valores que yo quiera a Unity (de lo que quiero a Unity)
float grados = orientacion * Mathf.Rad2Deg;
transform.Rotate(Vector3.up, grados); //rota con respecto al eje y, trabaja en grados
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
steering.vector = target.posicion - character.posicion;
steering.vector.Normalize();
steering.vector *= character.maxAceleration;
steering.vector = steering.vector - character.velocidadActual;
steering.real = 0;
return(steering);
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
SteeringOutPut steeringAux = new SteeringOutPut();
foreach (BehaviorAndWeight behavior in behaviors)
{
steeringAux = behavior.behavior.GetSteering(character);
steering.vector += steeringAux.vector * behavior.weight;
steering.real += steeringAux.real * behavior.weight;
}
return(steering);
}
public override SteeringOutPut GetSteering(Kinematic character)
{
float distance = character.velocidadActual.magnitude;
if (distance == 0)
{
SteeringOutPut steering = new SteeringOutPut();
return(steering);
}
target.orientacion = Mathf.Atan2(character.velocidadActual.z, character.velocidadActual.x);
return(base.GetSteering(character));
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
steering.vector = target.velocidadActual - character.velocidadActual;
steering.vector /= timeToTarget;
if (steering.vector.magnitude > character.maxAceleration)
{
steering.vector.Normalize();
steering.vector *= character.maxAceleration;
}
steering.real = 0;
return(steering);
}
public float epsilon; //Que sea un valor pequeño
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
foreach (BlendedSteering group in groups)
{
steering = group.GetSteering(character);
if ((steering.vector.magnitude > epsilon) || (Mathf.Abs(steering.real) > epsilon)) //Si el valor de este grupo es muy pequeño, se pasa al siguiente grupo
{
return(steering);
}
}
return(steering); //Si se llega aqui, entonces se pasa el steering del último grupo, aunque sea el del menor valor
}
public override SteeringOutPut GetSteering(Kinematic character)
{
if (targetOrig == null)
{
return(new SteeringOutPut());
}
Vector3 direction = targetOrig.posicion - character.posicion;
float distance = direction.magnitude;
if (distance == 0)
{
SteeringOutPut steering = new SteeringOutPut();
return(steering);
}
target = targetOrig;
target.orientacion = Mathf.Atan2(direction.x, direction.z);
return(base.GetSteering(character));
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
rayVector = character.velocidadActual;
rayVector.Normalize();
rayVector *= lookahead;
Collision collision = collisionDetector.getCollision(character.posicion, rayVector, lookahead);
if (collision != null)
{
kinetic.posicion = collision.posicion + collision.normal * avoidDistance;
target = kinetic;
return(base.GetSteering(character));
}
return(steering);
}
public override SteeringOutPut GetSteering(Kinematic character)
{
SteeringOutPut steering = new SteeringOutPut();
foreach (Kinematic target in targets)
{
Vector3 direction = character.posicion - target.posicion;
float distance = direction.magnitude;
if (distance < threshold)
{
float strength = Mathf.Min(decayCoefficient / (distance * distance), character.maxAceleration);
direction.Normalize();
steering.vector += strength * direction;
}
}
return(steering);
}
public override SteeringOutPut GetSteering(Kinematic character)
{
if (target == null)
{
return(new SteeringOutPut());
}
SteeringOutPut steering = new SteeringOutPut();
Vector3 direction = target.posicion - character.posicion;
float distancia = direction.magnitude;
if (distancia < targetRadius)
{
steering.vector = -character.velocidadActual; //Sería -VelocidadActual para anular la velocidad y que se quede quieto
return(steering);
}
float targetSpeed;
if (distancia > slowRadius)
{
targetSpeed = character.maxSpeed;
}
else
{
targetSpeed = character.maxSpeed * distancia / slowRadius;
}
Vector3 targetVelocity = direction;
targetVelocity.Normalize();
targetVelocity *= targetSpeed;
steering.vector = targetVelocity - character.velocidadActual;
steering.vector = new Vector3(steering.vector.x / timeToTarget, steering.vector.y / timeToTarget, steering.vector.z / timeToTarget);
if (steering.vector.magnitude > character.maxAceleration)
{
steering.vector.Normalize();
steering.vector *= character.maxAceleration;
}
steering.real = 0;
return(steering);
}
//float timeToTarget = 0.1f;
public override SteeringOutPut GetSteering(Kinematic character)
{
float targetRadiusLoc = targetRadius * Mathf.Deg2Rad;
float slowRadiusLoc = slowRadius * Mathf.Deg2Rad;
SteeringOutPut steering = new SteeringOutPut();
float rotation = target.orientacion - character.orientacion;
rotation = mapToRange(rotation);
rotation = rotation * Mathf.Deg2Rad;
float rotationSize = Mathf.Abs(rotation);
if (rotationSize < targetRadiusLoc)
{
steering.real = -character.rotacionActual;
return(steering);
}
float targetRotation;
if (rotationSize > slowRadiusLoc)
{
targetRotation = character.maxRotation;
}
else
{
targetRotation = character.maxRotation * rotationSize / slowRadiusLoc;
}
targetRotation *= rotation / rotationSize;
steering.real = targetRotation - character.rotacionActual;
float angularAcceleration = Mathf.Abs(steering.real);
if (angularAcceleration > character.maxAcelerationAngular)
{
steering.real /= angularAcceleration;
steering.real *= character.maxAcelerationAngular;
}
steering.vector = new Vector3(0, 0, 0);
return(steering);
}
