Pong: Reverse ball at top and bottom boundaries of window

Question

I am a beginner at coding, and hoped to create a game of pong. I am pretty close, both paddles move, and the ball bounces off of them when they intersect. But I'm having a bit of trouble reversing the trajectory of the ball once it passes the top and bottom of the screen. I thought I had a fix for this but it doesn't seem to be working.

Any help would be much appreciated. Code below.

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

You're checking if the ball's height is exactly equal to zero (or the window's height). The odds of render being called and the ball exactly hitting 0 are low. You should actually check if the ball has already gone past 0 and then change its velocity.

It's actually slightly more complicated than that, because if the ball goes past 0, you change the velocity, and then something happens to slow the ball, it's possible that render could happen again while the ball is still outside the frame causing its velocity to invert and move away from the screen again. This will cause it to continually vibrate outside the window, with its velocity reversing every frame.

There's a lot of additional error checking you could do, making sure the ball's velocity is always correct and doing more complicated geometry to make the ball actually bounce off the wall even when it moves through the wall in a single frame.