public override void _CalculateSteering(TargetAcceleration acceleration)
{
_shortest_time = Mathf.Inf;
_first_neighbor = null;
_first_minimum_separation = 0;
_first_distance = 0;
var neighbor_count = proximity._FindNeighbors(_ReportNeighbor);
if (neighbor_count == 0 || _first_neighbor == null)
{
acceleration.SetZero();
}
else
{
if (
_first_minimum_separation <= 0 ||
_first_distance < agent.bounding_radius + _first_neighbor.bounding_radius)
{
acceleration.linear = _first_neighbor.position - agent.position;
}
else
{
acceleration.linear = (
_first_relative_position
+ (_first_relative_velocity * _shortest_time)
);
}
}
acceleration.linear = (acceleration.linear.Normalized() * -agent.linear_acceleration_max);
acceleration.angular = 0;
}
public virtual void _Arrive(TargetAcceleration acceleration, Vector3 target_position)
{
var to_target = target_position - agent.position;
var distance = to_target.Length();
if (distance <= arrival_tolerance)
{
acceleration.SetZero();
}
else
{
var desired_speed = agent.linear_speed_max;
if (distance <= deceleration_radius)
{
desired_speed *= distance / deceleration_radius;
}
var desired_velocity = to_target * desired_speed / distance;
desired_velocity = ((desired_velocity - agent.linear_velocity) * 1.0f / time_to_reach);
acceleration.linear = Utils.Clampedv3(desired_velocity, agent.linear_acceleration_max);
}
}
public override void _CalculateSteering(TargetAcceleration blended_accel)
{
foreach (Behavior behavior in _behaviors)
{
behavior.behavior.CalculateSteering(_accel);
blended_accel.AddScaledAccel(_accel, behavior.weight);
}
blended_accel.linear = Utils.Clampedv3(blended_accel.linear, agent.linear_acceleration_max);
blended_accel.angular = Mathf.Clamp(
blended_accel.angular, -agent.angular_acceleration_max, agent.angular_acceleration_max
);
}
public override void _ApplySteering(TargetAcceleration acceleration, float delta)
{
_applied_steering = true;
switch (movement_type)
{
case MovementType.COLLIDE:
_ApplyCollideSteering(acceleration.linear, delta); break;
case MovementType.SLIDE:
_ApplySlidingSteering(acceleration.linear, delta); break;
default:
_ApplyPositionSteering(acceleration.linear, delta); break;
}
_ApplyOrientationSteering(acceleration.angular, delta);
}
public override void _ApplySteering(TargetAcceleration acceleration, float delta)
{
RigidBody2D _body = (RigidBody2D)_body_ref.GetRef();
if (_body == null)
{
return;
}
_applied_steering = true;
_body.ApplyCentralImpulse(Utils.ToVector2(acceleration.linear));
_body.ApplyTorqueImpulse(acceleration.angular);
if (calculate_velocities)
{
linear_velocity = Utils.ToVector3(_body.LinearVelocity);
angular_velocity = _body.AngularVelocity;
}
}
public override void _CalculateSteering(TargetAcceleration acceleration)
{
var location = prediction_time == 0 ? agent.position : agent.position + (agent.linear_velocity * prediction_time);
var distance = path.CalculateDistance(location);
var target_distance = distance + path_offset;
if (prediction_time > 0 && path.is_open)
{
if (target_distance < path.CalculateDistance(agent.position))
{
target_distance = path.length;
}
}
var target_position = path.CalculateTargetPosition(target_distance);
if (is_arrive_enabled && path.is_open)
{
if (path_offset >= 0)
{
if (target_distance > path.length - deceleration_radius)
{
_Arrive(acceleration, target_position);
return;
}
}
else
{
if (target_distance < deceleration_radius)
{
_Arrive(acceleration, target_position);
return;
}
}
}
acceleration.linear = (target_position - agent.position).Normalized();
acceleration.linear *= agent.linear_acceleration_max;
acceleration.angular = 0;
}
public void AddScaledAccel(TargetAcceleration accel, float scalar)
{
linear += accel.linear * scalar;
angular += accel.angular * scalar;
}
public override void _CalculateSteering(TargetAcceleration acceleration)
{
_Arrive(acceleration, target.position);
}
