Libgdx AI

Gdx.app.log("",steering.linear.x+" "+steering.linear.y);

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.ai.steer.Steerable;
import com.badlogic.gdx.ai.steer.SteeringAcceleration;
import com.badlogic.gdx.ai.steer.SteeringBehavior;
import com.badlogic.gdx.ai.steer.behaviors.Seek;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
 
public class Test extends GameActor  implements Steerable<Vector2> {
 
        private static final SteeringAcceleration<Vector2> steeringOutput = new SteeringAcceleration<Vector2>(new Vector2());
    float maxLinearSpeed;
    float maxLinearAcceleration;
    float maxAngularSpeed;
    float maxAngularAcceleration;
    Vector2 position;
    float orientation;
    Vector2 linearVelocity;
    float angularVelocity;
    float maxSpeed;
    boolean independentFacing;
    SteeringBehavior<Vector2> steeringBehavior;
 
    public Test(Vector2 position) {
                super(null);
        this.position = position;
    }
 
    public Test(Body body,Vector2 position) {
                super(body);
        this.position = new Vector2(100,100);
        this.linearVelocity= new Vector2(1,1);;
        this.angularVelocity=3;
        this.maxSpeed=3;
        this.independentFacing=false;
        steeringBehavior = new Seek<Vector2>(this,new Test(new Vector2(500,400)));
        }
 
    public void act(float delta) {
        if (steeringBehavior != null) {
            steeringBehavior.calculateSteering(steeringOutput);
            applySteering(steeringOutput, delta);
        }
    }
 
    private void applySteering(SteeringAcceleration<Vector2> steering,
            float time) {
        Gdx.app.log("",steering.linear.x+" "+steering.linear.y);
        this.position.mulAdd(linearVelocity, time);
        this.linearVelocity.mulAdd(steering.linear, time).limit(
                this.getMaxLinearSpeed());
        if (independentFacing) {
            this.orientation += angularVelocity * time;
            this.angularVelocity += steering.angular * time;
        } else {
            float newOrientation = calculateOrientationFromLinearVelocity(this);
            if (newOrientation != this.orientation) {
                this.angularVelocity = (newOrientation - this.orientation)* time;
                this.orientation = newOrientation;
            }
        }
    }
    
     public static float calculateOrientationFromLinearVelocity (Steerable<Vector2> character) {
            if (character.getLinearVelocity().isZero(MathUtils.FLOAT_ROUNDING_ERROR))
                return character.getOrientation();
            return character.vectorToAngle(character.getLinearVelocity());
        }
 
    @Override
    public float getMaxLinearSpeed() {
        return maxLinearSpeed;
    }
    @Override
    public void setMaxLinearSpeed(float maxLinearSpeed) {
        this.maxLinearSpeed=maxLinearSpeed;
    }
    @Override
    public float getMaxLinearAcceleration() {
        return maxLinearAcceleration;
    }
    @Override
    public void setMaxLinearAcceleration(float maxLinearAcceleration) {
        this.maxLinearAcceleration=maxLinearAcceleration;
    }
    @Override
    public float getMaxAngularSpeed() {
        return maxAngularSpeed;
    }
    @Override
    public void setMaxAngularSpeed(float maxAngularSpeed) {
        this.maxAngularSpeed=maxAngularSpeed;
    }
    @Override
    public float getMaxAngularAcceleration() {
        return maxAngularAcceleration;
    }
    @Override
    public void setMaxAngularAcceleration(float maxAngularAcceleration) {
        this.maxAngularAcceleration=maxAngularAcceleration;
    }
    @Override
    public Vector2 getPosition() {
        return position;
    }
    @Override
    public float getOrientation() {
        return orientation;
    }
    @Override
    public Vector2 getLinearVelocity() {
        return linearVelocity;
    }
    @Override
    public float getAngularVelocity() {
        return angularVelocity;
    }
    @Override
    public float getBoundingRadius() {
        return 0;
    }
    @Override
    public boolean isTagged() {
        return false;
    }
    @Override
    public void setTagged(boolean tagged) {
        
    }
    @Override
    public Vector2 newVector() {
        return null;
    }
    @Override
    public float vectorToAngle (Vector2 vector) {
        return (float)Math.atan2(-vector.x, vector.y);
    }
 
    @Override
    public Vector2 angleToVector (Vector2 outVector, float angle) {
        outVector.x = -(float)Math.sin(angle);
        outVector.y = (float)Math.cos(angle);
        return outVector;
    }
     
}