Pong: Reverse Ball an der oberen und unteren Grenze des Fensters

Question

Ich bin ein Anfänger bei der Codierung und hoffte, ein Spiel von Pong zu erstellen. Ich bin ziemlich nah, beide Paddel bewegen sich und der Ball prallt von ihnen ab, wenn sie sich kreuzen. Aber ich habe ein paar Probleme damit, die Flugbahn des Balls umzukehren, sobald er oben und unten auf dem Bildschirm ist. Ich dachte, ich hätte eine Lösung dafür, aber es scheint nicht zu funktionieren.

Jede Hilfe würde sehr geschätzt werden. Code unten.

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

Sie überprüfen, ob die Höhe des Balls genau gleich Null ist (oder die Höhe des Fensters). Die Chancen des Renderings werden aufgerufen und der Ball genau schlägt 0 ist niedrig. Sie sollten eigentlich überprüfen, ob der Ball bereits über 0 hinausgegangen ist und dann seine Geschwindigkeit ändern.

Es ist eigentlich etwas komplizierter als das, denn wenn der Ball über 0 geht, ändern Sie die Geschwindigkeit, und dann etwas passiert, um den Ball zu verlangsamen, ist es möglich, dass Render wieder passieren kann, während der Ball noch außerhalb des Rahmens verursacht seine Geschwindigkeit zu invertieren und weg von dem Bildschirm wieder zu bewegen. Dies wird dazu führen, dass es kontinuierlich außerhalb des Fensters vibriert, wobei seine Geschwindigkeit jeden Frame umkehrt.

Es gibt viele zusätzliche Fehlerüberprüfungen, die Sie durchführen können. Stellen Sie sicher, dass die Ballgeschwindigkeit immer korrekt ist und die Geometrie komplizierter ist, damit der Ball tatsächlich von der Wand abprallt, auch wenn er sich in einem Frame durch die Wand bewegt.