3

私はブレイクアウト ゲームに取り組んでおり、レンガの衝突以外はほぼすべて完了しています。ボールは壁で跳ね返り、うまくパドルしますが、レンガになるとボールはまっすぐに通り抜けます。問題はメイン クラスの checkBrick() 部分にあると確信していますが、どうすればよいかわかりません。

メインクラス:

import java.awt.*;
import java.awt.event.KeyEvent;
import java.applet.*;
import java.util.Random;
import javax.swing.JOptionPane;

public class Breakout extends Applet implements Runnable {
    Ball ball = new Ball();
    Paddle paddle = new Paddle(135, 375);
    Brick[] brick = new Brick[50];
    private int bX[] = new int[50];
    private int bY[] = new int[50];
    private int bW[] = new int[50];
    private int bH[] = new int[50];
    Thread t;
    Random trajectory = new Random();
    boolean lose;
    Image buffer = null;

    // The life cycle of the Applet
    // Sets up window
    public void init() {
        setSize(377, 500);
        buffer = createImage(377, 500);
        // setBackground(Color.black);
        System.out.println("init()");
    }

    public void start() {
        if (t == null) {
            t = new Thread(this);
            t.start();
        }
        System.out.println("start()");
    }

    public void run() {
        System.out.println("run()");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        while (!lose) {
            ball.move();
            paddle.move();
            checkWall();
            checkPaddle();
            checkBrick();
            ball.move();

            repaint();

            try {
                Thread.sleep(30);
            } catch (InterruptedException ex) {
            }
            Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        }

        JOptionPane.showMessageDialog(null, "Game Over");
        System.out.println("Termintated");
        System.exit(0);
    }

    public void stop() {
        System.out.println("stop()");
    }

    public void destroy() {
        System.out.println("destroy()");
    }

    public void paint(Graphics g) {
        Graphics screen = null;
        screen = g;
        g = buffer.getGraphics();

        g.setColor(Color.black);
        g.fillRect(0, 0, 377, 500);
        createBricks(g);
        createPaddle(g);
        createBall(g);

        screen.drawImage(buffer, 0, 0, this);
    }

    public void update(Graphics g) {
        paint(g);
    }

    private void createBricks(Graphics g) {
        int brickIndex = 0;
        int brickX = 15, brickY = 160;
        int brickW = 30, brickH = 10;
        for (int i = 0; i <= 4; i++) {
            brickX = 15;
            brickY -= 20;

            for (int n = 0; n < 10; n++) {
                brick[brickIndex] = new Brick();
                brick[brickIndex].setBounds(brickX, brickY, brickW, brickH);
                bX[brickIndex] = brick[brickIndex].x();
                bY[brickIndex] = brick[brickIndex].y();
                bW[brickIndex] = brick[brickIndex].w();
                bH[brickIndex] = brick[brickIndex].h();
                brick[brickIndex].setColor(i);
                brick[brickIndex].paint(g);
                brickIndex++;
                brickX += 35;
            }
        }

    }

    private void createPaddle(Graphics g) {
        paddle.paint(g);

    }

    private void createBall(Graphics g) {
        ball.paint(g);
    }

    private void checkWall() {
        // If ball hits right wall it will bounce
        if ((ball.getX() + ball.getR()) >= 380) {
            ball.setVX(trajectory.nextInt(2) + -3);
        }

        // If ball hits left wall it will bounce
        if ((ball.getX() - ball.getR()) < -10) {
            ball.setVX(trajectory.nextInt(4) + 1);
        }

        // If ball hits ceiling it will bounce
        if ((ball.getY() + ball.getR()) < 12)
            ball.setVY(trajectory.nextInt(5) + 1);

        // If ball goes through floor it will subtract a life
        if ((ball.getY() + ball.getR()) > 515)
            lose = true;

    }

    private void checkBrick() {
        for (int i = 0; i < 50; i++) {
            int tempX, tempY, tempW, tempH;
            tempX = bX[i];
            tempY = bY[i];
            tempW = bW[i];
            tempH = bH[i];

            if ((ball.getX() + ball.getR()) < (tempX + tempW)
                    && (ball.getX() + ball.getR()) >= tempX) {
                if ((ball.getY() + ball.getR()) > (tempY + tempH)
                        && (ball.getY() + ball.getR()) <= tempY) {
                    System.out.println("Brick " + i + " has been hit.");
                }
            }
        }
    }

    private void checkPaddle() {
        // Check for paddle
        if ((ball.getX() + ball.getR()) < (paddle.getX() + 100)
                && (ball.getX() + ball.getR()) >= paddle.getX() + 5) {
            if ((ball.getY() + ball.getR()) > (paddle.getY() - 5)
                    && (ball.getY() + ball.getR()) <= (paddle.getY() + 5)) {
                ball.setVX((trajectory.nextInt(7) + -2) + 1);
                ball.setVY(trajectory.nextInt(1) + -3);
            }
        }
    }

    // Key Detectors
    public boolean keyDown(Event e, int key) {
        if (key == Event.RIGHT) {
            paddle.setVX(0);
            if ((paddle.getX() + 100) < 377)
                paddle.setVX(10);
        }
        if (key == Event.LEFT) {
            paddle.setVX(0);
            if (paddle.getX() > 0)
                paddle.setVX(-10);
        }

        return true;
    }

    // To make sure it doesn't just keep moving one way
    public boolean keyUp(Event e, int key) {
        paddle.setVX(0);
        return true;
    }
}

ボールクラス:

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;

public class Ball 
{
    private int x, y; //Position
    private int vx, vy; //Velocity
    private int r; //radius

    //constructor
    public Ball()
    {
        x = 177;
        y = 315;
        vx = 0;
        vy = 5;
        r = 15;
    }

    public void paint(Graphics g)
    {
        g.setColor(Color.white);
        g.fillOval(x, y, r, r);

    }

    //returns the x of origin 
    public int getX()
    {
        return x;
    }

    //returns the y of origin
    public int getY()
    {
        return y;
    }
    public int getVX()
    {
        return vx;
    }

    //returns the y of origin
    public int getVY()
    {
        return vy;
    }

    //returns the radius r of the ball
    public int getR()
    {
        return r;
    }

    //sets the velocity of x to a different value
    public void setVX(int vx)
    {
        this.vx = vx;
    }

    //sets the velocity of y to a different value
    public void setVY(int vy)
    {
        this.vy = vy;
    }

    //sets the x value
    public void setX(int x)
    {
        this.x = x;
    }

    //sets the y value
    public void setY(int y)
    {
        this.y = y;
    }

    //starts making the ball move by changing its coords
    public void move()
    {
        x+= vx;
        y+= vy;
    }

}

パドルクラス:

import java.awt.Color;
import java.awt.Graphics;

public class Paddle {

    // declares variables for x and y coordinates
    int x, y;
    //The velocity of to move paddle
    int vx;

    // constructor that takes in x and y coordinates for paddle
    public Paddle(int x, int y) 
    {
        this.x = x;
        this.y = y;
    }

    public void paint(Graphics g) 
    {
        // paints paddle
        g.setColor(Color.WHITE);
        g.fillRect(x, y, 100, 15);
        g.setColor(Color.GREEN);
        g.drawRect(x, y, 100, 15);
    }

    // gets x coordinate of paddle
    public int getX() {
        return x;
    }

    // sets x coordinate of paddle
    public void setX(int x) {
        this.x = x;
    }

    // gets y coordinate of paddle
    public int getY() {
        return y;
    }

    // sets y coordinate of paddle
    public void setY(int y) {
        this.y = y;
    }

    public void setVX(int vx)
    {
        this.vx = vx;
    }
    //Moves the paddle
    public void move()
    {
        x+=vx;
    }
}

レンガクラス:

import java.awt.Color;
import java.awt.Graphics;


public class Brick 
{
    private Color color =(Color.cyan);
    private int x, y, w, h;

    public Brick()
    {
        //Garbage values that are there just for declaration
        x = 0;
        y = 0;
        w = 10;
        h = 10;
    }

    //Sets color for the brick
    public void setColor(int paintC)
    {
        switch(paintC)
        {
            case 0:
                color = (Color.magenta);
                break;
            case 1:
                color = (Color.blue);
                break;
            case 2:
                color = (Color.yellow);
                break;
            case 3:
                color = (Color.orange);
                break;
            default:
                color = (Color.red);
                break;
        }
    }

    //Sets the location then size of the brick
    public void setBounds(int x, int y, int w, int h)
    {
        this.x = x;
        this.y = y;
        this.w = w;
        this.h = h;
    }

    //returns x value
    public int x()
    {
        return this.x;
    }

    //returns y value
    public int y()
    {
        return this.y;
    }

    //returns width value
    public int w()
    {
        return this.w;
    }

    //returns height value
    public int h()
    {
        return this.h;
    }


    //Sets x for the brick
    public void setX(int x)
    {
        this.x = x;
    }

    //Sets y for the brick
    public void setY(int y)
    {
        this.y = y;
    }

    public void setW(int w)
    {
        this.w = w;
    }

    public void setH(int h)
    {
        this.h = h;
    }

    public void paint(Graphics g)
    {
        g.setColor(color);
        g.fillRect(x, y, w, h);
        g.setColor(Color.green);
        g.drawRect(x, y, w, h);
    }
}
4

5 に答える 5

2

私はあなたのコードを実行し始めました。率直に言って、あなたのロジックを理解しようとするのは面倒ですが、あなたが推測しようとしているのは、ブロックがボールを「含んでいる」かどうかではなく、ボールがレンガ。

交差している場合にのみ、ボールまたはレンガがどれだけ交差しているかは気にしません...たとえば...

private void checkBrick() {

    int tx = ball.getX();
    int ty = ball.getY();
    int tw = ball.getR();
    int th = ball.getR();

    tw += tx;
    th += ty;

    for (int i = 0; i < 50; i++) {
        int tempX, tempY, tempW, tempH;
        tempX = bX[i];
        tempY = bY[i];
        tempW = bW[i];
        tempH = bH[i];

        int rw = tempW + tempX;
        int rh = tempH + tempY;

        //     overflow || intersect
        if ((rw < tempX || rw > tx) &&
            (rh < tempY || rh > ty) &&
               (tw < tx || tw > tempX) &&
               (th < ty || th > tempY)) {
            System.out.println("Hit");
        }
    }
}

今、私はこれを盗んだRectangle#intersects

基本的に、2D Graphics API のジオメトリ クラスを使用した場合、これを次のように減らすことができます。

private void checkBrick() {

    Rectangle b = new Rectangle(ball.getX(), ball.getY(), ball.getR(), ball.getR());

    for (int i = 0; i < 50; i++) {
        int tempX, tempY, tempW, tempH;
        tempX = bX[i];
        tempY = bY[i];
        tempW = bW[i];
        tempH = bH[i];

        Rectangle brick = new Rectangle(tempX, tempY, tempW, tempH);

        System.out.println("brick = " + brick);
        if (b.intersects(brick)) {
            System.out.println("Break");
        }
    }
}

そして、はい、私は実際にあなたのコードを実行しました

于 2014-01-16T04:30:45.163 に答える
0

2番目の答え（私も問題だと思う他の答えに加えて）、あなたのロジックはボールがレンガの中に含まれているかどうかを尋ねていますが、ボールを作成すると、その半径はレンガの高さよりも大きいので、修正してもそのロジックは問題を解決しません。

コードをリファクタリングして、自然言語のように読み上げられるようにする必要があります。これは、デバッグに大いに役立ちます (または、そもそもバグの記述が少なくなります!)。

ブリッククラスで：

public int bottom()
{
    return y;
}
public int top()
{
    return y + h;
}

ボールクラス：

public int bottom()
{
    return y - r;
}
public int top() {
    return y + r;
}

次にメインクラスで：

private boolean withinY(brick) {
    return (ball.bottom => brick.bottom() && ball.top =< brick.top());
}

次に、ロジックはより適切に読み取ります（疑似）：

foreach brick in wall {
    if (ball.withinY(brick) and ball.withinX(brick))
        BAM!!
}
于 2014-01-16T04:59:36.237 に答える