Wie bringe ich springenden Ball schneller voran? dynamische Geschwindigkeit?

Question

So hatte ich ein Programm, um einen springenden Ball über den Bildschirm mit JavaFX jetzt zu bewegen, jetzt habe ich versucht, bestimmte Werte unter Duration.millis() in meiner Timeline Animation neu formatieren und je niedriger ich es desto schneller der Ball geht aber, jemand hat mir gesagt, dass nicht der beste Weg ist, anstatt zu gehen, ich dynamische Geschwindigkeit fragen sollte hier mein Programm hinzufügen für Bewegung meiner Kugel meines Code ist:

public class BallPane extends Pane { 

public final double radius = 5; 
public double x = radius, y = radius; 
public double dx = 1, dy = 1; 
public Circle circle = new Circle(x, y, radius); 
public Timeline animation; 

public BallPane(){  
circle.setFill(Color.BLACK); // Set ball color 
getChildren().add(circle); // Place ball into Pane 

// Create animation for moving the Ball 
animation = new Timeline(
    new KeyFrame(Duration.millis(10), e -> moveBall())); 
animation.setCycleCount(Timeline.INDEFINITE); 
animation.play(); 
} 

public void moveBall() { 
// Check Boundaries 
if (x < radius || x > getWidth() - radius) { 
    dx *= -1; //change Ball direction 
} 
if (y < radius || y > getHeight() - radius) { 
    dy *= -1; //change Ball direction 
} 
x += dx; 
y += dy; 
circle.setCenterX(x); 
circle.setCenterY(y); 
} } 

wiederum, es wird ein pong-Spiel sein also werde ich 5 Levels haben und in jedem Level möchte ich, dass der Ball sich schneller bewegt. Ich kann das tun, indem ich die Duration.millis() erniedrige, aber mir wurde gesagt, dass das nicht der beste Weg ist, um die Geschwindigkeit zu erhöhen Gehen Sie dabei vor, ohne meine Duration.millis in meinen Time-Line-Animationsparametern zu verringern? Gibt es einen anderen Parameter, den ich hinzufügen oder eine andere Methode der Geschwindigkeit?

Answer 1

Ich möchte einen anderen Ansatz vorschlagen: Verwenden Sie einen AnimationTimer, Vector calculation und Forces.

Die Kugeln/Sprites haben Attribute:

PVector location; 
PVector velocity; 
PVector acceleration; 

Die Bewegung erfolgt durch Kräfte der Beschleunigung, Beschleunigung auf die Geschwindigkeit und die Geschwindigkeit auf Position Anwendung: in einem Spiel

public void applyForce(PVector force) { 

    // Making a copy of the PVector before using it! 
    PVector f = PVector.div(force, mass); 
    acceleration.add(f); 
} 

public void move() { 

    // set velocity depending on acceleration 
    velocity.add(acceleration); 

    // limit velocity to max speed 
    velocity.limit(maxSpeed); 

    // change location depending on velocity 
    location.add(velocity); 

    // clear acceleration 
    acceleration.mult(0); 
} 

Und dies geschieht Schleife für jedes Sprite:

gameLoop = new AnimationTimer() { 

    @Override 
    public void handle(long now) { 

     // physics: apply forces 
     allSprites.forEach(s -> s.applyForce(Settings.FORCE_GRAVITY)); 
     allSprites.forEach(s -> s.applyForce(Settings.FORCE_WIND)); 

     // move 
     allSprites.forEach(Sprite::move); 

     // check boundaries 
     allSprites.forEach(Sprite::checkBounds); 

     // update in fx scene 
     allSprites.forEach(Sprite::display); 

    } 
}; 

Sie können ein komplettes Beispiel o. finden n dieser gist. Die Kugeln prallen auf den Boden, abhängig von der Schwerkraft. Der Wind weht von links nach rechts, also bewegen sich die Bälle dorthin. Aber Sie können das leicht in den Einstellungsattributen ändern.

Mach dir keine Sorgen, es ist nicht viel Code, nur der allgemeine Zweck Vector Berechnung Klasse ist lang. Aber Sie müssen nur ein paar Methoden davon kennen.

Das Beispiel verwendet die Kräfte Wind und Schwerkraft. Was auch immer Sie erreichen möchten, wenden Sie einfach die Kraft an. Natürlich könntest du für deine Frage einfach die Geschwindigkeit erhöhen, ohne eine Kraft anzuwenden. Alles hängt davon ab, mit was du herumspielen willst.

Screenshot:

Beispiel darüber, wie Sie das Aufprallen der Kugeln aufgrund der Reibung ändern könnte, ist in chapter 2.7. Hier ist die Verarbeitung Code, Daniel Shiffman in seinem Buch verwendet, aber Sie sehen, es ist sehr einfach zu JavaFX übersetzen:

for (int i = 0; i < movers.length; i++) { 

    float c = 0.01; 
    PVector friction = movers[i].velocity.get(); 
    friction.mult(-1); 
    friction.normalize(); 
    friction.mult(c); 

    movers[i].applyForce(friction); 
    movers[i].applyForce(wind); 
    movers[i].applyForce(gravity); 

    movers[i].update(); 
    movers[i].display(); 
    movers[i].checkEdges(); 
    } 

ich die JavaFX Implementierung Ihnen überlassen.

Sie könnten auch interessiert sein an a video about how chapter 2.10 (alles zieht alles an) sieht aus wie. Es ist wirklich nicht viel zu programmieren, wenn man so etwas erreichen möchte. Das code is also available. Es verwendet die Point2D-Klasse, wenn Sie damit besser vertraut sind. Sie sollten Point2D jedoch nicht verwenden, da Einschränkungen bestehen und Sie ständig neue Point2D-Objekte erstellen müssen, die durch eine benutzerdefinierte Implementierung der Vector-Klasse vermieden werden können.

Answer 2

Ich würde es Physik zentriert tun: Wenn Sie solche Dynamik machen, sollten Sie Ihre Geschwindigkeit und Koordinaten aus Ihren Beschleunigungen bekommen.

Jedes Programm Tick berechnet neue Beschleunigung (mit der Masse des Balls, die Schwerkraftkonstante, verschiedene Koeffizienten wie der Elastizitätskoeffizient oder Reibung mit Luft eins), alle diese Vektoren.

Dann würden Sie grundsätzlich diese Vektoren integrieren: Beschleunigung -> Geschwindigkeit -> Koordinaten.

Nachdem dies getan ist, alles, was Sie brauchen, ist Ihre Beschleunigung zu optimieren, nur auf diesen Vektor, um Ihren Ball schneller/langsamer zu bewegen, höher oder nicht springen, und so weiter.

Vielleicht möchten Euler integration überprüfen den Job

Vector position, velocity, acceleration; 

public void eulerIntegration(double dt){ 
    //TODO create the calculate acceleration method using your ball model 
    acceleration = calculateAcceleration(); 
    velocity = acceleration * dt; 
    position = velocity * dt; 
}