Java 路径行走/跟随并不适用于所有情况

我正在按照描述和实施路径行走/跟随。 唯一的区别是我将其转换为使用

Scene2D

和

Stage

除此部分外，它工作正常： 当下一个点的Y小于前一个点的Y时，精灵基本上从上一个点直接跳到下一个点

例： 在下图中，精灵从点A直接跳到点B，从点C跳到点D

下面是实现

屏幕的完整类

import java.util.ArrayList;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputMultiplexer;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.utils.viewport.StretchViewport;

public class WayPointsTutorial implements Screen {

    private Stage stage;

    private SpriteBatch batch;

    private ShapeRenderer renderer;
    private Sprite sprite;

    private TestPlayer player;

    public static ArrayList<Vector2> pathPoints;

    @Override
    public void show() {

        stage = new Stage(new StretchViewport(800,1280));

        InputMultiplexer inputM = new InputMultiplexer();
        inputM.addProcessor(stage);
        Gdx.input.setInputProcessor(inputM);

        renderer = new ShapeRenderer();
        batch = new SpriteBatch();

        sprite = new Sprite(new Texture("data/bt_comecar.png"));
        sprite.setSize(50, 50);
        sprite.setOrigin(0, 0);

        pathPoints = new ArrayList<Vector2>();

        pathPoints.add(new Vector2(170,550));
        pathPoints.add(new Vector2(40,40));
        pathPoints.add(new Vector2(150,40));
        pathPoints.add(new Vector2(608,1000));
        pathPoints.add(new Vector2(400,208));

        player = new TestPlayer(sprite, pathPoints);
        player.setPosition(400, 640);

        stage.addActor(player);
    }

    @Override
    public void render(float delta) {
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        //Update the stage
        stage.draw();
        stage.act(delta);

        if(Gdx.input.isTouched()){show();}

        stage.getCamera().update();
        batch.setProjectionMatrix(stage.getCamera().combined);
        renderer.setProjectionMatrix(batch.getProjectionMatrix());
        renderer.setTransformMatrix(batch.getTransformMatrix());

        renderer.setColor(Color.CYAN);
        renderer.begin(ShapeType.Line);
        renderer.line(new Vector2(player.getX(), player.getY()), player.getPath().get(player.getWaypoint()));
        renderer.end();

        Vector2 previous = player.getPath().get(0);
        for(Vector2 waypoint : player.getPath()) {
            renderer.setColor(Color.WHITE);
            renderer.begin(ShapeType.Line);
            renderer.line(previous, waypoint);
            renderer.end();

            renderer.begin(ShapeType.Filled);
            renderer.circle(waypoint.x, waypoint.y, 15);
            renderer.end();

            previous = waypoint;
        }
    }

    @Override
    public void resize(int width, int height) {}

    @Override
    public void dispose() {
        stage.dispose();
        renderer.dispose();
    }

    @Override
    public void hide() {dispose();}

    @Override
    public void pause() {}

    @Override
    public void resume() {}

    public class TestPlayer extends Actor {

        private Vector2 velocity = new Vector2();
        private float speed = 300, tolerance = 50;

        private ArrayList<Vector2> path;
        private int waypoint = 0;
        Sprite sprite;

        public TestPlayer(Sprite sprite, ArrayList<Vector2> pathPoints) {
            //super(sprite);
            this.path = pathPoints;
            this.sprite = sprite;
        }

        @Override
        public void draw(Batch batch, float parentAlpha) {
            update(Gdx.graphics.getDeltaTime());
            sprite.setPosition(this.getX(), this.getY());
            sprite.setRotation(this.getRotation());
            sprite.draw(batch);
        }

        public void update(float delta) {

            float angle = (float) Math.atan2(path.get(waypoint).y - getY(), path.get(waypoint).x - getX());
            velocity.set((float) Math.cos(angle) * speed, (float) Math.sin(angle) * speed);

            setPosition(getX() + velocity.x * delta, getY() + velocity.y * delta);
            setRotation(angle * MathUtils.radiansToDegrees);

            if(isWaypointReached(waypoint)) {
                setPosition(path.get(waypoint).x, path.get(waypoint).y);
                if(waypoint + 1 >= path.size()){
                    waypoint=0; 
                }else{
                    waypoint++;
                }
            }

        }

        public boolean isWaypointReached(int waypoint) {
            return path.get(waypoint).x - getX() <= speed / tolerance * Gdx.graphics.getDeltaTime() && path.get(waypoint).y - getY() <= speed / tolerance * Gdx.graphics.getDeltaTime();
        }

        public ArrayList<Vector2> getPath() {
            return path;
        }

        public int getWaypoint() {
            return waypoint;
        }
    }
}

import java.util.ArrayList；
导入com.badlogic.gdx.gdx；
导入com.badlogic.gdx.InputMultiplexer；
导入com.badlogic.gdx.Screen；
导入com.badlogic.gdx.graphics.Color；
导入com.badlogic.gdx.graphics.GL20；
导入com.badlogic.gdx.graphics.Texture；
导入com.badlogic.gdx.graphics.g2d.Batch；
导入com.badlogic.gdx.graphics.g2d.Sprite；
导入com.badlogic.gdx.graphics.g2d.SpriteBatch；
导入com.badlogic.gdx.graphics.glutils.shaperender；
导入com.badlogic.gdx.graphics.glutils.shaperender.ShapeType；
导入com.badlogic.gdx.math.MathUtils；
导入com.badlogic.gdx.math.Vector2；
导入com.badlogic.gdx.scenes.scene2d.Actor；
导入com.badlogic.gdx.scenes.scene2d.Stage；
导入com.badlogic.gdx.utils.viewport.StretchViewport；
公共类航路点指示屏幕{
私人舞台；
专用SpriteBatch批次；
私有shaperender渲染器；
私人雪碧；
私人测试玩家；
公共静态数组列表路径点；
@凌驾
公开展览（{
stage=新stage（新StretchViewport（8001280））；
InputMultiplexer inputM=新的InputMultiplexer（）；
输入加处理器（级）；
Gdx.input.setInputProcessor（inputM）；
渲染器=新的ShaperEnder（）；
批次=新的SpriteBatch（）；
精灵=新精灵（新纹理（“data/bt_comecar.png”）；
设置大小（50，50）；
sprite.setOrigin（0,0）；
路径点=新的ArrayList（）；
添加（新矢量2（170550））；
添加（新向量2（40,40））；
添加（新向量2（150,40））；
添加（新矢量2（6081000））；
添加（新向量2（400208））；
player=新的TestPlayer（精灵、路径点）；
播放器设置位置（400640）；
舞台演员（演员）；
}
@凌驾
公共无效渲染（浮动增量）{
Gdx.gl.glClear（GL20.gl\u颜色\u缓冲\u位）；
//更新舞台
stage.draw（）；
舞台表演（三角洲）；
if（Gdx.input.isTouched（））{show（）；}
stage.getCamera（）.update（）；
batch.setProjectionMatrix（stage.getCamera（）.combined）；
renderer.setProjectionMatrix（batch.getProjectionMatrix（））；
setTransformMatrix（batch.getTransformMatrix（））；
渲染器.setColor（Color.CYAN）；
renderer.begin（ShapeType.Line）；
renderer.line（新矢量2（player.getX（），player.getY（）），player.getPath（）.get（player.getWaypoint（））；
end（）；
Vector2 previous=player.getPath（）.get（0）；
对于（矢量2航路点：player.getPath（））{
渲染器.setColor（Color.WHITE）；
renderer.begin（ShapeType.Line）；
行（上一个，航路点）；
end（）；
renderer.begin（ShapeType.Filled）；
圆（航路点.x，航路点.y，15）；
end（）；
先前=航路点；
}
}
@凌驾
公共空间大小调整（整数宽度，整数高度）{}
@凌驾
公共空间处置（）{
stage.dispose（）；
renderer.dispose（）；
}
@凌驾
public void hide（）{dispose（）；}
@凌驾
公共无效暂停（）{}
@凌驾
公共无效恢复（）{}
公共类TestPlayer扩展了Actor{
私有向量2速度=新向量2（）；
专用浮动速度=300，公差=50；
私有数组列表路径；
专用int航路点=0；
雪碧雪碧；
公共TestPlayer（精灵精灵，ArrayList路径点）{
//超级（雪碧）；
this.path=路径点；
this.sprite=精灵；
}
@凌驾
公共作废提取（批处理、浮动parentAlpha）{
更新（Gdx.graphics.getDeltaTime（））；
setPosition（this.getX（），this.getY（））；
setRotation（this.getRotation（））；
雪碧.抽（批）；
}
公共无效更新（浮动增量）{
浮动角度=（浮动）数学.atan2（path.get（waypoint）.y-getY（），path.get（waypoint）.x-getX（））；
设置速度（（浮点）数学cos（角度）*速度，（浮点）数学sin（角度）*速度）；
设置位置（getX（）+速度.x*delta，getY（）+速度.y*delta）；
设置旋转（角度*数学弧度/度）；
如果（IsWayPoint已到达（waypoint））{
设置位置（路径get（航路点）.x，路径get（航路点）.y）；
如果（航路点+1>=path.size（））{
航路点=0；
}否则{
航路点++；
}
}
}
到达公共布尔值IsWayPoint（整数航路点）{
返回path.get（waypoint）.x-getX（）我想（我没有检查）你的
iswaypointreated（）
方法被破坏了。如果你的新
waypoint.x
和新
waypoint.y
，那么在你的公式中，你会在
waypoint.x-getX（）
和
waypoint.y中得到负值
绝对小于始终为正的
速度/公差*Gdx.graphics.getDeltaTime（）
。在这种情况下，方法将立即返回到达的航路点

尝试将
Math.abs（）
函数添加到公式中：

return Math.abs(path.get(waypoint).x - getX()) <= speed / tolerance * Gdx.graphics.getDeltaTime() && Math.abs(path.get(waypoint).y - getY()) <= speed / tolerance * Gdx.graphics.getDeltaTime();

return Math.abs（path.get（waypoint）.x-getX（））@dermetfan他是这段视频的作者，他是用户stakoverflow，也许他能帮你，我留下这堆乱七八糟的东西