public void Steer(Vector3 target, Vector3 target_velocity, float max_target_speed)
{
// TODO 5: Create a fake position to represent
// enemies predicted movement. Then call Steer()
// on our Steering Seek / Arrive with the predicted position in
// max_seconds_prediction time
// Be sure that arrive / seek's update is not called at the same time
Vector3 diff = move.target.transform.position - transform.position;
float distance = diff.magnitude;
float speed = move.movement.magnitude;
float fake_prediction;
if (speed < distance / max_seconds_prediction)
{
fake_prediction = max_seconds_prediction;
}
else
{
fake_prediction = distance / speed;
}
arrive.Steer(move.target.transform.position + (target_velocity * fake_prediction));
// TODO 6: Improve the prediction based on the distance from
// our target and the speed we have
}
public void Steer(Vector3 target, Vector3 velocity)
{
// TODO 5: Create a fake position to represent
// enemies predicted movement. Then call Steer()
// on our Steering Seek / Arrive with the predicted position in
// max_seconds_prediction time
// Be sure that arrive / seek's update is not called at the same time
Vector3 Distance = target - transform.position;
float vel = 0;
if (move.movement.magnitude > 0)
{
vel = move.max_mov_velocity / move.movement.magnitude;
}
// TODO 6: Improve the prediction based on the distance from
// our target and the speed we have
float dist = Distance.magnitude / max_distance;
Debug.Log(dist);
float average = (vel + dist) / 2;
Vector3 vel_time = velocity * max_seconds_prediction * average;
Vector3 Fposition = target + vel_time;
arrive.Steer(Fposition);
}
public void Steer(Vector3 target, Vector3 velocity, float target_max_speed)
{
Vector3 diff = target - transform.position;
float distance = diff.magnitude;
float seconds_prediction = distance / target_max_speed;
Vector3 prediction = target + velocity * seconds_prediction;
arrive.Steer(prediction);
}
public void Steer(Vector3 target, Vector3 velocity)
{
// TODO 6: Create a fake position to represent
// enemies predicted movement. Then call Steer()
// on our Steering Arrive
velocity.Normalize();
Vector3 tar = target + (velocity * max_prediction);
arrive.Steer(tar);
}
public void Steer(Vector3 target, Vector3 target_velocity, float max_target_speed)
{
target = Movenemy.transform.position;
Vector3 diff = target - transform.position;
float distance = diff.magnitude;
float seconds_prediction = distance / max_target_speed;
Vector3 prediction = target + target_velocity * seconds_prediction;
arrive.Steer(prediction);
}
// Update is called once per frame
void Update()
{
float angle = Mathf.Atan2(move.movement.x, move.movement.z);
Quaternion q = Quaternion.AngleAxis(Mathf.Rad2Deg * angle, Vector3.up);
foreach (my_ray ray in rays)
{
RaycastHit hit;
if (Physics.Raycast(new Vector3(transform.position.x, 1.0f, transform.position.z), q * ray.direction.normalized, out hit, ray.length, mask) == true)
{
seek.Steer(new Vector3(hit.point.x, transform.position.y, hit.point.z) + hit.normal * avoid_distance);
}
}
}
public void Steer(Vector3 target, Vector3 velocity)
{
Vector3 diff = target - transform.position;
float distance = diff.magnitude;
float my_speed = move.movement.magnitude;
float prediction;
// is the speed too small ?
if (my_speed < distance / max_prediction)
{
prediction = max_prediction;
}
else
{
prediction = distance / my_speed;
}
arrive.Steer(target + (velocity * prediction));
}
public void Steer(Vector3 target, Vector3 velocity)
{
// TODO 6: Create a fake position to represent
// enemies predicted movement. Then call Steer()
// on our Steering Arrive
Vector3 predictedPosition = Vector3.zero;
// Prediction 1 (simple)
predictedPosition = target + velocity * max_prediction;
// Prediction 2 (improved. The acceleration decreases depending on how close the target is)
float distanceToTarget = Vector3.Distance(transform.position, target);
float prediction = distanceToTarget / max_prediction;
predictedPosition = target + velocity * prediction;
arrive.Steer(predictedPosition);
}
public void Steer(Vector3 target, Vector3 velocity)
{
Vector3 diff = target - transform.position;
float distance = diff.magnitude;
float current_speed = move.current_velocity[priority].magnitude;
float prediction;
// is the speed too small ?
if (current_speed < distance / max_seconds_prediction)
{
prediction = max_seconds_prediction;
}
else
{
prediction = distance / current_speed;
}
arrive.Steer(target + (velocity * prediction));
}
public void Steer(Vector3 target, Vector3 velocity)
{
// TODO 6: Create a fake position to represent
// enemies predicted movement. Then call Steer()
// on our Steering Arrive
Vector3 position = target - transform.position;
float predict = 0.0f;
if (velocity.magnitude <= position.magnitude / max_prediction)
{
predict = max_prediction;
}
else
{
predict = position.magnitude / velocity.magnitude;
}
target += move.movement * predict;
arrive.Steer(target);
}
// Update is called once per frame
void Update()
{
if (!move)
{
move = GetComponent <Move>();
}
else
{
if (path.status == NavMeshPathStatus.PathComplete)
{
align.Steer(path.corners[current_point]);
if (current_point != path.corners.Length - 1)
{
seek.Steer(path.corners[current_point]);
if (Vector3.Distance(transform.position, path.corners[current_point]) < min_distance)
{
current_point++;
}
}
else
{
if (arrive.Steer(path.corners[current_point]))
{
if (!once)
{
once = true;
}
}
else
{
once = false;
}
}
}
}
}
