FollowPath (libGDX AI)

java.lang.Object
- com.badlogic.gdx.ai.steer.SteeringBehavior<T>
- - com.badlogic.gdx.ai.steer.behaviors.Arrive<T>
  - - com.badlogic.gdx.ai.steer.behaviors.FollowPath<T,P>

Type Parameters:

T - Type of vector, either 2D or 3D, implementing the Vector interface

P - Type of path parameter implementing the Path.PathParam interface
```
public class FollowPath<T extends com.badlogic.gdx.math.Vector<T>,P extends Path.PathParam>
extends Arrive<T>
```
FollowPath behavior produces a linear acceleration that moves the agent along the given path. First it calculates the agent location based on the specified prediction time. Then it works out the position of the internal target based on the location just calculated and the shape of the path. It finally uses seek behavior to move the owner towards the internal target position. However, if the path is open arrive behavior is used to approach path's extremities when they are far less than the deceleration radius from the internal target position.
For complex paths with sudden changes of direction the predictive behavior (i.e., with prediction time greater than 0) can appear smoother than the non-predictive one (i.e., with no prediction time). However, predictive path following has the downside of cutting corners when some sections of the path come close together. This cutting-corner attitude can make the character miss a whole section of the path. This might not be what you want if, for example, the path represents a patrol route.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`arriveEnabled` The flag indicating whether to use `Arrive` behavior to approach the end of an open path.
`protected Path<T,P>`	`path` The path to follow
`protected float`	`pathOffset` The distance along the path to generate the target.
`protected P`	`pathParam` The current position on the path
`protected float`	`predictionTime` The time in the future to predict the owner's position.

Fields inherited from class com.badlogic.gdx.ai.steer.behaviors.Arrive
arrivalTolerance, decelerationRadius, target, timeToTarget

Fields inherited from class com.badlogic.gdx.ai.steer.SteeringBehavior
enabled, limiter, owner

Constructor Summary

Constructors
Constructor and Description
`FollowPath(Steerable<T> owner, Path<T,P> path)` Creates a non-predictive `FollowPath` behavior for the specified owner and path.
`FollowPath(Steerable<T> owner, Path<T,P> path, float pathOffset)` Creates a non-predictive `FollowPath` behavior for the specified owner, path and path offset.
`FollowPath(Steerable<T> owner, Path<T,P> path, float pathOffset, float predictionTime)` Creates a `FollowPath` behavior for the specified owner, path, path offset, maximum linear acceleration and prediction time.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected SteeringAcceleration<T>`	`calculateRealSteering(SteeringAcceleration<T> steering)` Calculates the steering acceleration produced by this behavior and writes it to the given steering output.
`T`	`getInternalTargetPosition()` Returns the current position of the internal target.
`Path<T,P>`	`getPath()` Returns the path to follow
`float`	`getPathOffset()` Returns the path offset.
`P`	`getPathParam()` Returns the current path parameter.
`float`	`getPredictionTime()` Returns the prediction time.
`boolean`	`isArriveEnabled()` Returns the flag indicating whether to use `Arrive` behavior to approach the end of an open path.
`FollowPath<T,P>`	`setArrivalTolerance(float arrivalTolerance)` Sets the tolerance for arriving at the target.
`FollowPath<T,P>`	`setArriveEnabled(boolean arriveEnabled)` Sets the flag indicating whether to use `Arrive` behavior to approach the end of an open path.
`FollowPath<T,P>`	`setDecelerationRadius(float decelerationRadius)` Sets the radius for beginning to slow down.
`FollowPath<T,P>`	`setEnabled(boolean enabled)` Sets this steering behavior on/off.
`FollowPath<T,P>`	`setLimiter(Limiter limiter)` Sets the limiter of this steering behavior.
`FollowPath<T,P>`	`setOwner(Steerable<T> owner)` Sets the owner of this steering behavior.
`FollowPath<T,P>`	`setPath(Path<T,P> path)` Sets the path followed by this behavior.
`FollowPath<T,P>`	`setPathOffset(float pathOffset)` Sets the path offset to generate the target.
`FollowPath<T,P>`	`setPredictionTime(float predictionTime)` Sets the prediction time.
`FollowPath<T,P>`	`setTarget(Location<T> target)` Sets the target to arrive to.
`FollowPath<T,P>`	`setTimeToTarget(float timeToTarget)` Sets the time over which to achieve target speed.

Methods inherited from class com.badlogic.gdx.ai.steer.behaviors.Arrive
arrive, getArrivalTolerance, getDecelerationRadius, getTarget, getTimeToTarget

Methods inherited from class com.badlogic.gdx.ai.steer.SteeringBehavior
calculateSteering, getActualLimiter, getLimiter, getOwner, isEnabled, newVector

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - path
```
protected Path<T extends com.badlogic.gdx.math.Vector<T>,P extends Path.PathParam> path
```
    The path to follow
  - pathOffset
```
protected float pathOffset
```
    The distance along the path to generate the target. Can be negative if the owner has to move along the reverse direction.
  - pathParam
```
protected P extends Path.PathParam pathParam
```
    The current position on the path
  - arriveEnabled
```
protected boolean arriveEnabled
```
    The flag indicating whether to use Arrive behavior to approach the end of an open path. It defaults to true.
  - predictionTime
```
protected float predictionTime
```
    The time in the future to predict the owner's position. Set it to 0 for non-predictive path following.
- Constructor Detail
  - FollowPath
```
public FollowPath(Steerable<T> owner,
                  Path<T,P> path)
```
    Creates a non-predictive FollowPath behavior for the specified owner and path.
    
    Parameters:
    
    owner - the owner of this behavior
    
    path - the path to be followed by the owner.
  - FollowPath
```
public FollowPath(Steerable<T> owner,
                  Path<T,P> path,
                  float pathOffset)
```
    Creates a non-predictive FollowPath behavior for the specified owner, path and path offset.
    
    Parameters:
    
    owner - the owner of this behavior
    
    path - the path to be followed by the owner
    
    pathOffset - the distance along the path to generate the target. Can be negative if the owner is to move along the reverse direction.
  - FollowPath
```
public FollowPath(Steerable<T> owner,
                  Path<T,P> path,
                  float pathOffset,
                  float predictionTime)
```
    Creates a FollowPath behavior for the specified owner, path, path offset, maximum linear acceleration and prediction time.
    
    Parameters:
    
    owner - the owner of this behavior
    
    path - the path to be followed by the owner
    
    pathOffset - the distance along the path to generate the target. Can be negative if the owner is to move along the reverse direction.
    
    predictionTime - the time in the future to predict the owner's position. Can be 0 for non-predictive path following.
- Method Detail
  - calculateRealSteering
```
protected SteeringAcceleration<T> calculateRealSteering(SteeringAcceleration<T> steering)
```
    Description copied from class: SteeringBehavior
    
    Calculates the steering acceleration produced by this behavior and writes it to the given steering output.
    This method is called by SteeringBehavior.calculateSteering(SteeringAcceleration) when this steering behavior is enabled.
    
    Overrides:
    
    calculateRealSteering in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Parameters:
    
    steering - the steering acceleration to be calculated.
    
    Returns:
    
    the calculated steering acceleration for chaining.
  - getPath
```
public Path<T,P> getPath()
```
    Returns the path to follow
  - setPath
```
public FollowPath<T,P> setPath(Path<T,P> path)
```
    Sets the path followed by this behavior.
    
    Parameters:
    
    path - the path to set
    
    Returns:
    
    this behavior for chaining.
  - getPathOffset
```
public float getPathOffset()
```
    Returns the path offset.
  - isArriveEnabled
```
public boolean isArriveEnabled()
```
    Returns the flag indicating whether to use Arrive behavior to approach the end of an open path.
  - getPredictionTime
```
public float getPredictionTime()
```
    Returns the prediction time.
  - setPredictionTime
```
public FollowPath<T,P> setPredictionTime(float predictionTime)
```
    Sets the prediction time. Set it to 0 for non-predictive path following.
    
    Parameters:
    
    predictionTime - the predictionTime to set
    
    Returns:
    
    this behavior for chaining.
  - setArriveEnabled
```
public FollowPath<T,P> setArriveEnabled(boolean arriveEnabled)
```
    Sets the flag indicating whether to use Arrive behavior to approach the end of an open path. It defaults to true.
    
    Parameters:
    
    arriveEnabled - the flag value to set
    
    Returns:
    
    this behavior for chaining.
  - setPathOffset
```
public FollowPath<T,P> setPathOffset(float pathOffset)
```
    Sets the path offset to generate the target. Can be negative if the owner has to move along the reverse direction.
    
    Parameters:
    
    pathOffset - the pathOffset to set
    
    Returns:
    
    this behavior for chaining.
  - getPathParam
```
public P getPathParam()
```
    Returns the current path parameter.
  - getInternalTargetPosition
```
public T getInternalTargetPosition()
```
    Returns the current position of the internal target. This method is useful for debug purpose.
  - setOwner
```
public FollowPath<T,P> setOwner(Steerable<T> owner)
```
    Description copied from class: SteeringBehavior
    
    Sets the owner of this steering behavior.
    
    Overrides:
    
    setOwner in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setEnabled
```
public FollowPath<T,P> setEnabled(boolean enabled)
```
    Description copied from class: SteeringBehavior
    
    Sets this steering behavior on/off.
    
    Overrides:
    
    setEnabled in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setLimiter
```
public FollowPath<T,P> setLimiter(Limiter limiter)
```
    Sets the limiter of this steering behavior. The given limiter must at least take care of the maximum linear speed and acceleration. However the maximum linear speed is not required for a closed path.
    
    Overrides:
    
    setLimiter in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setTarget
```
public FollowPath<T,P> setTarget(Location<T> target)
```
    Description copied from class: Arrive
    
    Sets the target to arrive to.
    
    Overrides:
    
    setTarget in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setArrivalTolerance
```
public FollowPath<T,P> setArrivalTolerance(float arrivalTolerance)
```
    Description copied from class: Arrive
    
    Sets the tolerance for arriving at the target. It lets the owner get near enough to the target without letting small errors keep it in motion.
    
    Overrides:
    
    setArrivalTolerance in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setDecelerationRadius
```
public FollowPath<T,P> setDecelerationRadius(float decelerationRadius)
```
    Description copied from class: Arrive
    
    Sets the radius for beginning to slow down.
    
    Overrides:
    
    setDecelerationRadius in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.
  - setTimeToTarget
```
public FollowPath<T,P> setTimeToTarget(float timeToTarget)
```
    Description copied from class: Arrive
    
    Sets the time over which to achieve target speed.
    
    Overrides:
    
    setTimeToTarget in class Arrive<T extends com.badlogic.gdx.math.Vector<T>>
    
    Returns:
    
    this behavior for chaining.

Class FollowPath<T extends com.badlogic.gdx.math.Vector<T>,P extends Path.PathParam>

Field Summary

Fields inherited from class com.badlogic.gdx.ai.steer.behaviors.Arrive

Fields inherited from class com.badlogic.gdx.ai.steer.SteeringBehavior

Constructor Summary

Method Summary

Methods inherited from class com.badlogic.gdx.ai.steer.behaviors.Arrive

Methods inherited from class com.badlogic.gdx.ai.steer.SteeringBehavior

Methods inherited from class java.lang.Object

Field Detail

path

pathOffset

pathParam

arriveEnabled

predictionTime

Constructor Detail

FollowPath

FollowPath

FollowPath

Method Detail

calculateRealSteering

getPath

setPath

getPathOffset

isArriveEnabled

getPredictionTime

setPredictionTime

setArriveEnabled

setPathOffset

getPathParam

getInternalTargetPosition

setOwner

setEnabled

setLimiter

setTarget

setArrivalTolerance

setDecelerationRadius

setTimeToTarget