Ich versuche, auf einem Pfad mit der LibGDX-CatmullRomSpline eine konstante Geschwindigkeit zu erreichen, und ich habe Probleme, sie zum Laufen zu bringen. Ich habe viel zu diesem Thema recherchiert, unter anderem im LibGDX-Wiki, aber ihre Erklärung für das Erreichen einer konstanten Geschwindigkeit ist nicht wirklich sinnvoll und ich konnte ihre Methode nicht zum Laufen bringen.https: //github.com/libgdx/libgdx/wiki/Path-interface-&-Spline In meinem Fall sind die Ableitungswerte sehr groß (in Hunderten). Wenn Sie also eine Zahl zwischen 0 und 1 durch die Ableitung dividieren, ist das Ergebnis sehr klein und die Bewegung ist sehr langsam und immer noch nicht konstant. Ich bin mir also nicht sicher, wie ihr Beispiel genau funktioniert.

In meinem Beispiel habe ich ein paar visuelle Hilfsmittel, die mit der Geschwindigkeit des Balls übereinstimmen. Der Balken am unteren Rand des Bildschirms wird länger, wenn die Geschwindigkeit zunimmt, und die Farbe ändert sich auch von weiß nach rot, wenn die Geschwindigkeit zunimmt.

In der act () -Methode von MyPath.java habe ich zwei Abschnitte auskommentiert, beginnend mit [1] und [2]. Der erste ist normal mit der variablen Geschwindigkeit über den Pfad und der zweite ist mein fehlgeschlagener Versuch, die konstante Geschwindigkeit des LibGDX-Wikis zum Laufen zu bringen. Kommentieren Sie diese Zeilen einfach aus, um zwischen den beiden Versionen zu wechseln.

Meine Idee für eine konstante Geschwindigkeit besteht darin, die Geschwindigkeit anhand der Gesamtlänge des Pfades (unter Verwendung der Methode approxLength (1000) auf dem Spline) zu ermitteln und dann mithilfe der Ableitungsfunktion die tatsächliche Geschwindigkeit zu einem bestimmten Zeitpunkt zu bestimmen und die Geschwindigkeit anzupassen Prozentwert, der in den Spline gesendet wird, um die Geschwindigkeitsänderungen zu kompensieren, um die Geschwindigkeit konstant zu halten. Ich verstehe jedoch nicht ganz, was die Ableitungsfunktion tatsächlich darstellt. Ich habe früher eine Frage zur Ableitungsfunktion gestellt, aber aufgrund eines Kommentars, den ich erhalten habe, war es wahrscheinlich einfacher, stattdessen nach der Erreichung einer konstanten Geschwindigkeit zu fragen. Hier ist meine vorherige Frage zur Ableitungsfunktion:LibGDX CatmullRomSpline Derivative Bedeutung?

Jede Idee, wie ich in meinem Beispiel eine konstante Geschwindigkeit erreichen kann (oder zu erklären, was die Ableitungsfunktion für die CatmullRomSpline tatsächlich darstellt, damit ich besser verstehen kann, wie sie verwendet wird), wäre sehr willkommen.

Für alle, die das Programm ausführen möchten, sind hier die beiden Bilddateien, die ich für mein Beispiel erstellt habe (fügen Sie diese im Stammverzeichnis des Assets-Ordners hinzu):http: //dropshots.com/Tekker/date/2015-09-1

Hier ist mein Beispielcode:

DesktopLauncher.java: (Breite und Höhe des Desktop-Fensters auf 1000 geändert)

public class DesktopLauncher {
    public static void main (String[] arg) {
        LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
        config.width = 1000;
        config.height = 1000;
        new LwjglApplication(new TEST(), config);
    }
}

TEST.java:

public class TEST extends Game {
    Stage stage;    
    MyPath path;

    @Override
    public void create () {
        stage = new Stage();
        stage.setViewport(new ScreenViewport(stage.getViewport().getCamera()));
        Gdx.input.setInputProcessor(stage);
        path = new MyPath(1000, 1000);
        stage.addActor(path);
    }

    @Override
    public void render () {
        Gdx.gl.glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        stage.act(Gdx.graphics.getDeltaTime());
        stage.draw();
    }

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

MyPath.java:

public class MyPath extends WidgetGroup {
    Image start, end, path, bar1, horizontal;
    float time, percent, dVal, pathLength, dMax=1000, cycle=6, maxPercent, deltaCycle;

    CatmullRomSpline<Vector2> catmull;
    Vector2 result = new Vector2();
    Vector2 previousResult = new Vector2(50,150);
    Vector2 derivative = new Vector2();
    Vector2 previousDerivative = new Vector2();
    Vector2[] points = {
        new Vector2(50,150), new Vector2(50,150),
        new Vector2(400,800), new Vector2(600,150), new Vector2(700,400),
        new Vector2(860,150), new Vector2(860,150)
    };

    boolean print = true;

    public MyPath(int width, int height){
        this.setSize(width, height);
        catmull = new CatmullRomSpline<Vector2>(points, false);

        createPath();
        createBar();

        pathLength = catmull.approxLength(1000);
    }

    @Override
    public void act(float delta){
        // [1] VARIABLE SPEED
        //time += delta;
        //percent = (time / cycle) % 1;

        // [2] CONSTANT SPEED FAIL!
        //catmull.derivativeAt(previousDerivative, percent);
        //time += delta;
        //percent = ((time / cycle) / previousDerivative.len() ) % 1;

        catmull.valueAt(result, percent);
        path.setPosition(result.x, this.getHeight() - result.y);

        updateSpeedVisuals();
        debugPrint();

        previousResult.set(result);
    }

    private void createPath(){
        start = new Image(new Texture("dot.png"));
        start.setColor(Color.GRAY);
        start.setPosition(50, this.getHeight() - 150);
        this.addActor(start);

        end = new Image(new Texture("dot.png"));
        end.setColor(Color.GRAY);
        end.setPosition(860, this.getHeight() - 150);
        this.addActor(end);

        path = new Image(new Texture("dot.png"));
        path.setColor(Color.WHITE);
        this.addActor(path);
    }

    private void createBar(){
        Texture texture = new Texture("ninepatch.png");
        int crop = (int)(texture.getWidth()/2)-1;
        NinePatch patch9 = new NinePatch(texture, crop, crop, crop, crop);
        bar1 = new Image(patch9);
        bar1.setColor(Color.GRAY);
        bar1.setPosition(5, this.getHeight()-900);
        this.addActor(bar1);
    }

    private void updateSpeedVisuals(){
        catmull.derivativeAt(derivative, percent);
        dVal = derivative.len() / dMax;
        path.setColor(1f, 1f-dVal, 1f-dVal, 1f);
        bar1.setWidth(derivative.len());
        bar1.setColor(1f, 1f-dVal, 1f-dVal, 1f);
    }

    private void debugPrint(){
        maxPercent = (percent > maxPercent) ? percent : maxPercent;
        if (maxPercent > percent){
            print = false;
        }
        if (print){
            String debugPrint = "";
            debugPrint = debugPrint + "pathLength=" + pathLength + "\t";
            debugPrint = debugPrint + "derivative=" + derivative.len() + "\t";
            System.out.println(debugPrint);
        }
    }
}