Pong: Inverser la balle aux limites supérieure et inférieure de la fenêtre

Question

Je suis un débutant au codage, et espère créer une partie de pong. Je suis assez proche, les deux pagaies bougent, et la balle rebondit sur elles lorsqu'elles se croisent. Mais j'ai un peu de mal à inverser la trajectoire de la balle une fois qu'elle passe le haut et le bas de l'écran. Je pensais que j'avais une solution, mais ça ne semble pas fonctionner.

Toute aide serait grandement appréciée. Code ci-dessous.

import java.util.Random; 
import java.util.logging.Level; 
import java.util.logging.Logger; 

import org.newdawn.slick.Animation; 
import org.newdawn.slick.AppGameContainer; 
import org.newdawn.slick.BasicGame; 
import org.newdawn.slick.Color; 
import org.newdawn.slick.GameContainer; 
import org.newdawn.slick.Graphics; 
import org.newdawn.slick.Image; 
import org.newdawn.slick.Input; 
import org.newdawn.slick.SlickException; 
import org.newdawn.slick.SpriteSheet; 
import org.newdawn.slick.geom.Rectangle; 

public class PongAttempt extends BasicGame{ 
Image player1Img; 
Image player2Img; 
Image ball; 

float ballx = 500; 
float bally = 500; 

float x = 0; 
float y = 0; 

float bx = 100; 
float by = 40; 

float velocityx = -.10f; 
float velocityy = 0f; 

float player1Vel = 0; 
float player2Vel = 0; 

Rectangle player1Dim; 
Rectangle player2Dim; 
Rectangle ballDim; 

public PongAttempt(String gamename){super(gamename);} 

@Override 
public void init(GameContainer gc) throws SlickException { 

    player1Img = new Image("res/troll.png"); 
    player2Img = new Image("res/troll.png"); 
    ball = new Image("res/ball.png"); 

    player1Dim = new Rectangle(x, y, player1Img.getWidth(), player1Img.getHeight()); 
    player2Dim = new Rectangle(bx, by, player2Img.getWidth(), player2Img.getHeight()); 
    ballDim = new Rectangle(ballx, bally, ball.getWidth(), ball.getHeight()); 

    bx = gc.getWidth() - player2Img.getWidth(); 
    by = 0; 

    ballx = gc.getWidth()/2; 
    bally = gc.getHeight()/2; 

} 


@Override 
public void update(GameContainer gc, int i) throws SlickException { 

} 

@Override 
public void render(GameContainer gc, Graphics g) throws SlickException 
{ 

    g.setBackground(Color.black); 

    //Player 1 move and generate boundaries 

    if(gc.getInput().isKeyDown(Input.KEY_W) && y > 0) { 
     y = y - 0.2f; 
     player1Vel = -0.2f; 
    } 
    if(gc.getInput().isKeyDown(Input.KEY_S) && y < (gc.getHeight() - player1Img.getHeight())) { 
     y = y + 0.2f; 
     player1Vel = 0.2f; 
    } 



    //Player 2 Move and generate boundaries 

    if(gc.getInput().isKeyDown(Input.KEY_O) && by > 0) { 
     player2Vel = -0.2f; 
     by = by + player2Vel; 
    } 
    if(gc.getInput().isKeyDown(Input.KEY_L) && by < (gc.getHeight() - player2Img.getHeight())) { 
     player2Vel = 0.2f; 
     by = by + player2Vel; 
    } 


    if(gc.getInput().isKeyDown(Input.KEY_ESCAPE)){ 
     gc.exit(); 
    } 

    player1Dim.setX(x); 
    player1Dim.setY(y); 

    player2Dim.setX(bx); 
    player2Dim.setY(by); 

    ballDim.setX(ballx); 
    ballDim.setY(bally); 


    if(ballDim.intersects(player1Dim)){ 
     velocityx = velocityx * -1; 
     velocityy = player1Vel; 
    } 

    if(ballDim.intersects(player2Dim)){ 
     velocityx = velocityx * -1; 
     velocityy = player2Vel; 
    } 

    //This is where I tried to get the ball to bounce off the top and bottom 

if(ballx == 0 - ball.getHeight()){ 
     velocityx = velocityx * -1; 
    } 

    if(ballx == gc.getHeight() - ball.getHeight()){ 
     velocityx = velocityx * -1; 
    } 

    ballx = ballx + velocityx; 
    bally = bally + velocityy; 

    player1Img.draw(x, y); 
    player2Img.draw(bx, by); 
    ball.draw(ballx, bally); 

} 

public static void main(String[] args) 
{ 
    try 
    { 
     AppGameContainer appgc; 
     appgc = new AppGameContainer(new PongAttempt("Simple Slick Game")); 
     appgc.setDisplayMode(appgc.getScreenWidth(), appgc.getScreenHeight(), true); 
     appgc.start(); 
    } 
    catch (SlickException ex) 
    { 
     Logger.getLogger(PongAttempt.class.getName()).log(Level.SEVERE, null, ex); 
    } 
} 
} 

Answer 1

Vous vérifiez si la hauteur de la boule est exactement égale à zéro (ou à la hauteur de la fenêtre). Les chances de rendre l'appel et la balle exactement frappant 0 sont faibles. Vous devriez vérifier si la balle est déjà passée au-dessus de 0 et ensuite changer sa vitesse. C'est en fait un peu plus compliqué que ça, parce que si la balle dépasse 0, vous changez la vitesse, et puis il se passe quelque chose pour ralentir la balle, il est possible que le rendu se reproduise alors que la balle est toujours hors du cadre. sa vitesse à inverser et s'éloigner de l'écran à nouveau. Cela l'amènera à vibrer continuellement à l'extérieur de la fenêtre, sa vitesse étant inversée à chaque image. Il y a beaucoup de vérification d'erreur supplémentaire que vous pouvez faire, en vous assurant que la vitesse de la balle est toujours correcte et en faisant une géométrie plus compliquée pour que la balle rebondisse sur le mur même lorsqu'elle se déplace dans un seul cadre.