import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Wander wander = (Wander)steeringBC.behavior;
    Steerable steerable = wander.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);

    wander.setWanderRadius(0.1f);
    wander.setTimeToTarget(0.1f);
    wander.setDecelerationRadius(1f);
    wander.setFaceEnabled(false);
    wander.setWanderOrientation(250f);

}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Wander wander = (Wander)steeringBC.behavior;
    Steerable steerable = wander.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);

    wander.setWanderRadius(0.1f);
    wander.setTimeToTarget(0.1f);
    wander.setDecelerationRadius(0f);
    wander.setFaceEnabled(false);
    wander.setWanderOrientation(250f);

}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Wander wander = (Wander)steeringBC.behavior;
    Steerable steerable = wander.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);
    //wander.setTarget(loc);
    wander.setWanderRadius(5f);
    wander.setTimeToTarget(0.1f);
    wander.setDecelerationRadius(3f);
    wander.setFaceEnabled(false);
    wander.setWanderOrientation(250f);

}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public boolean reportNeighbor (Steerable<T> neighbor) {

	toAgent.set(owner.getPosition()).sub(neighbor.getPosition());
	float distanceSqr = toAgent.len2();
	float maxAcceleration = getActualLimiter().getMaxLinearAcceleration();

	// Calculate the strength of repulsion through inverse square law decay
	float strength = getDecayCoefficient() / distanceSqr;
	if (strength > maxAcceleration) strength = maxAcceleration;

	// Add the acceleration
	// Optimized code for linear.mulAdd(toAgent.nor(), strength);
	linear.mulAdd(toAgent, strength / (float)Math.sqrt(distanceSqr));

	return true;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public boolean reportNeighbor (Steerable<T> neighbor) {
	// Calculate the position of the hiding spot for this obstacle
	T hidingSpot = getHidingPosition(neighbor.getPosition(), neighbor.getBoundingRadius(), target.getPosition());

	// Work in distance-squared space to find the closest hiding
	// spot to the owner
	float distance2 = hidingSpot.dst2(owner.getPosition());
	if (distance2 < distance2ToClosest) {
		distance2ToClosest = distance2;
		bestHidingSpot.set(hidingSpot);
		return true;
	}

	return false;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Pursue pursue = (Pursue)steeringBC.behavior;
    Steerable steerable = pursue.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);
    pursue.setMaxPredictionTime(0.85f);


}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code RayConfigurationBase} for the given owner and the specified number of rays.
 * @param owner the owner of this configuration
 * @param numRays the number of rays used by this configuration */
@SuppressWarnings("unchecked")
public RayConfigurationBase (Steerable<T> owner, int numRays) {
	this.owner = owner;
	this.rays = new Ray[numRays];
	for (int i = 0; i < numRays; i++)
		this.rays[i] = new Ray<T>(owner.getPosition().cpy().setZero(), owner.getPosition().cpy().setZero());
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Seek seek = (Seek)steeringBC.behavior;
    Steerable steerable = seek.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);

}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Pursue pursue = (Pursue)steeringBC.behavior;
    Steerable steerable = pursue.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);

}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public void applyConfigs(SteeringBehaviorComponent steeringBC) {
    Arrive arrive = (Arrive)steeringBC.behavior;
    Steerable steerable = arrive.getOwner();
    steerable.setMaxLinearSpeed(MAX_LINEAR_SPEED);
    steerable.setMaxLinearAcceleration(MAX_LINEAR_ACCELERATION);
    steerable.setMaxAngularSpeed(MAX_ANGULAR_SPEED);
    steerable.setMaxAngularAcceleration(MAX_ANGULAR_ACCELERATION);

    arrive.setArrivalTolerance(0.5f);
    arrive.setDecelerationRadius(10f);
    arrive.setTimeToTarget(0.005f);
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
public static Arrive createArrive(float x, float y, Steerable steerable){
    SteerLocation loc = new SteerLocation();
    loc.getPosition().set(x, y);
    Arrive arrive = new Arrive(steerable, loc);
        arrive.setTarget(loc);

    arrive.setOwner(steerable);
    return arrive;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code CentralRayWithWhiskersConfiguration} for the given owner where the central ray has the specified length and
 * the two whiskers have the specified length and angle.
 * @param owner the owner of this configuration
 * @param rayLength the length of the central ray
 * @param whiskerLength the length of the two whiskers (usually shorter than the central ray)
 * @param whiskerAngle the angle in radians of the whiskers from the central ray */
public CentralRayWithWhiskersConfiguration (Steerable<T> owner, float rayLength, float whiskerLength, float whiskerAngle) {
	super(owner, 3);
	this.rayLength = rayLength;
	this.whiskerLength = whiskerLength;
	this.whiskerAngle = whiskerAngle;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code FieldOfViewProximity} for the specified owner, agents and cone area defined by the given radius and angle
 * in radians.
 * @param owner the owner of this proximity
 * @param agents the agents
 * @param radius the radius of the cone area
 * @param angle the angle in radians of the cone area */
public FieldOfViewProximity (Steerable<T> owner, Iterable<? extends Steerable<T>> agents, float radius, float angle) {
	super(owner, agents);
	this.radius = radius;
	setAngle(angle);
	this.lastTime = 0;
	this.ownerOrientation = owner.getPosition().cpy().setZero();
	this.toAgent = owner.getPosition().cpy().setZero();
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public int findNeighbors (ProximityCallback<T> callback) {
	int neighborCount = 0;
	for (Steerable<T> currentAgent : agents) {
		// Make sure the agent being examined isn't the owner
		if (currentAgent != owner) {
			if (callback.reportNeighbor(currentAgent)) {
				neighborCount++;
			}
		}
	}

	return neighborCount;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates an {@code Interpose} behavior for the specified owner and agents using the the given interposing ratio.
 * @param owner the owner of this behavior
 * @param agentA the first agent
 * @param agentB the other agent
 * @param interpositionRatio a number between 0 and 1 indicating the percentage of the distance between the 2 agents that the
 *           owner should reach, where 0 is agentA position and 1 is agentB position. */
public Interpose (Steerable<T> owner, Steerable<T> agentA, Steerable<T> agentB, float interpositionRatio) {
	super(owner);
	this.agentA = agentA;
	this.agentB = agentB;
	this.interpositionRatio = interpositionRatio;

	this.internalTargetPosition = newVector(owner);
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code RaycastObstacleAvoidance} behavior.
 * @param owner the owner of this behavior
 * @param rayConfiguration the ray configuration
 * @param raycastCollisionDetector the collision detector
 * @param distanceFromBoundary the minimum distance to a wall (i.e., how far to avoid collision). */
public RaycastObstacleAvoidance (Steerable<T> owner, RayConfiguration<T> rayConfiguration,
	RaycastCollisionDetector<T> raycastCollisionDetector, float distanceFromBoundary) {
	super(owner);
	this.rayConfiguration = rayConfiguration;
	this.raycastCollisionDetector = raycastCollisionDetector;
	this.distanceFromBoundary = distanceFromBoundary;

	this.outputCollision = new Collision<T>(newVector(owner), newVector(owner));
	this.minOutputCollision = new Collision<T>(newVector(owner), newVector(owner));
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code CollisionAvoidance} behavior for the specified owner and proximity.
 * @param owner the owner of this behavior
 * @param proximity the proximity of this behavior. */
public CollisionAvoidance (Steerable<T> owner, Proximity<T> proximity) {
	super(owner, proximity);

	this.firstRelativePosition = newVector(owner);
	this.firstRelativeVelocity = newVector(owner);

	this.relativeVelocity = newVector(owner);
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
@Override
public boolean reportNeighbor (Steerable<T> neighbor) {
	// Calculate the time to collision
	relativePosition.set(neighbor.getPosition()).sub(owner.getPosition());
	relativeVelocity.set(neighbor.getLinearVelocity()).sub(owner.getLinearVelocity());
	float relativeSpeed2 = relativeVelocity.len2();

	// Collision can't happen when the agents have the same linear velocity.
	// Also, note that timeToCollision would be NaN due to the indeterminate form 0/0 and,
	// since any comparison involving NaN returns false, it would become the shortestTime,
	// so defeating the algorithm.
	if (relativeSpeed2 == 0) return false;
	
	float timeToCollision = -relativePosition.dot(relativeVelocity) / relativeSpeed2;

	// If timeToCollision is negative, i.e. the owner is already moving away from the the neighbor,
	// or it's not the most imminent collision then no action needs to be taken.
	if (timeToCollision <= 0 || timeToCollision >= shortestTime) return false;

	// Check if it is going to be a collision at all
	float distance = relativePosition.len();
	float minSeparation = distance - (float)Math.sqrt(relativeSpeed2) * timeToCollision /* shortestTime */;
	if (minSeparation > owner.getBoundingRadius() + neighbor.getBoundingRadius()) return false;

	// Store most imminent collision data
	shortestTime = timeToCollision;
	firstNeighbor = neighbor;
	firstMinSeparation = minSeparation;
	firstDistance = distance;
	firstRelativePosition.set(relativePosition);
	firstRelativeVelocity.set(relativeVelocity);

	return true;
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code BlendedSteering} for the specified {@code owner}, {@code maxLinearAcceleration} and
 * {@code maxAngularAcceleration}.
 * @param owner the owner of this behavior. */
public BlendedSteering (Steerable<T> owner) {
	super(owner);

	this.list = new Array<BehaviorAndWeight<T>>();
	this.steering = new SteeringAcceleration<T>(newVector(owner));
}
 

import com.badlogic.gdx.ai.steer.Steerable; //导入依赖的package包/类
/** Creates a {@code FollowPath} behavior for the specified owner, path, path offset, maximum linear acceleration and prediction
 * time.
 * @param owner the owner of this behavior
 * @param path the path to be followed by the owner
 * @param pathOffset the distance along the path to generate the target. Can be negative if the owner is to move along the
 *           reverse direction.
 * @param predictionTime the time in the future to predict the owner's position. Can be 0 for non-predictive path following. */
public FollowPath (Steerable<T> owner, Path<T, P> path, float pathOffset, float predictionTime) {
	super(owner);
	this.path = path;
	this.pathParam = path.createParam();
	this.pathOffset = pathOffset;
	this.predictionTime = predictionTime;

	this.arriveEnabled = true;

	this.internalTargetPosition = newVector(owner);
}