The Breakout Game

(complete version)
Chapter 11
 Overview
• This chapter reviews all the material so far.
• This includes:
– event handling,
– menus,
– inheritance,
– loops,
– the enum construct,
– arrays and ArrayList,
– multi-class solutions,
– and so on.
• This includes moving the ball using a timer, moving the paddle
using the mouse and using keys, destroying bricks when the ball
 Overview of the Game
• We will have a Game menu that can be used to start a new
game and pause/restore the current game.
• A Ball Color menu will be used to select the color of the ball.
Possible ball colors will be enumerated in an enum construct.
• A Ball Speed menu will be used to change the speed of the ball.
Possible ball speeds will be enumerated in an enum construct.
• A blue paddle will be displayed a the bottom. Can be moved
with keys or mouse.
• Bricks will be displayed in a grid and destroyed when hit.
• A player life is lost when the ball goes bellow the paddle.
 Game Design
• Read over game description and identify nouns. These are
class candidates or enum candidates. For example, see the
red nouns from previous slide.
• We will create super class BreakoutShape and subclasses Ball,
Paddle, and Brick. The reason is that all three classes
represent a rectangular object (or surrounded by a rectangle).
• Note that there are many ways to implement the game. We
just choose one possible way (strive to follow good software
design practices).
 The BreakoutShape Class
• Each of the shapes has a rectangle. We will define a
RectangularShape object inside the BreakoutShape class.
RectangularShape is an abstract class and a super class of
both Rectatngle2D and Ellipse2D.
• Every BreakoutShape object will also have a color and a fill.
• We will also include a move method that moves the shape by
the specified amount.
• The setFrame method changes the coordinates of a
RectangularShape. There are also getX, getY, getWidth, and
getHeight methods that return the top left corner and the size
of the rectangular shape.
import java.awt.*;
import java.awt.geom.*;
public class BreakoutShape {
private Color color;
private boolean fill;
private RectangularShape shape;
public BreakoutShape(RectangularShape shape,
Color color, boolean fill) {
this.shape = shape;
this.color = color;
this.fill = fill;
}
public Color getColor() {
return color;
}
public void changeColor(Color color) {
this.color = color;
}
public void draw(Graphics2D g2) {
g2.setPaint(color);
g2.draw(shape);
if (fill) {
 g2.fill(shape);
}
}

public double getX() {

return shape.getX();
}

public double getY() {

return shape.getY();
}

public double getHeight() {

return shape.getHeight();
}

public double getWidth() {

return shape.getWidth();
}

public void move(int dx, int dy) {

shape.setFrame(getX()+dx, getY()+dy, getWidth(), getHeight());
}
}
 The Ball Class
• Inherits from BreakoutShape.
• Has a move method that moves the balls.
• Saves dx and dy, the amount by which to move the ball in X
and Y direction.
• The constructor of the Ball class takes as input the
surrounding panel.
• When the Ball hits the walls of the panel, it bounces by
changing the value of dx and/or dy.
import java.awt.*;
import java.awt.geom.*;

public class Ball extends BreakoutShape {

private static final int SIZE = 10;
private static final int START_X = 200;
private static final int START_Y = 400;

private int dx = 1;
private int dy = -1;
private BreakoutPanel panel;

public Ball(Color color, BreakoutPanel panel) {

super(new Ellipse2D.Double(START_X, START_Y, SIZE,
SIZE), color, true);
this.panel = panel;
}
 public void move() {
if (getX() + dx < 0) {//left wall
dx = 1;
} //right wall
if (getX() + getWidth() + dx > panel.getWidth()) {
dx = -1;
} //top wall
if (getY() + dy < 0) {
dy = 1;
} //bottom wall
if (getY()+getHeight()+dy > panel.getHeight()){
dy = -1;
}
super.move(dx, dy);//actual move happens here
}
}
 Completing the First Version
• When creating non trivial software, we always want to start
with a small version.
• Test the small version and make sure it works before adding
more features.
• This way, it is easier to isolate errors.
• We will create a main class that creates a BreakoutFrame
window.
• The BreakoutFrame window sets the size of the window, makes
it not resizable, and adds a panel (of type BreakoutPanel) to it.
• The ball is created in the BreakoutPanel class. A timer is also
created that calls the move method on the ball periodically.
public class Breakout {
public static void main(String[] args) {
BreakoutFrame frame = new BreakoutFrame();
frame.setVisible(true);
}
}
import javax.swing.*;
import java.awt.event.*;

public class BreakoutFrame extends JFrame {

private static final int HEIGHT = 600;
private static final int WIDTH = 488;
private BreakoutPanel panel = new BreakoutPanel();

public BreakoutFrame() {
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setLocation(100,100);
setSize(WIDTH, HEIGHT);
add(panel);
setResizable(false);
}
}
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class BreakoutPanel extends JPanel {
private javax.swing.Timer timer;
private Ball ball;
public BreakoutPanel() {
ball = new Ball(Color.red,this);
timer = new javax.swing.Timer(10, new ActionListener(){
public void actionPerformed(ActionEvent e) {
ball.move();
repaint();
}
});
timer.start();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
ball.draw(g2);
}
}
 Adding the Paddle
• The Paddle class will also inherit from the class BreaoutShape.
• The move method will allow us to move the paddle by the
specified amount (paddle can only move left or right).
• We will add a key and mouse listener to the panel to control
the paddle.
• Note that the mouse listener will need to remember the
previous position of the mouse and will move the paddle by
the difference of the current and previous positions.
• We will use the code e.getKeyCode()==KeyEvent.VK_RIGHT
to check if the right arrow on the keyboard is pressed.
public class Paddle extends BreakoutShape {
private static final int START_X = 200;
private static final int START_Y = 430;
private static final int WIDTH = 50;
private static final int HEIGHT = 10;
private static final int SPEED = 10;
private BreakoutPanel panel;
public Paddle(Color color, BreakoutPanel panel) {
super(new Rectangle2D.Double(START_X,
Paddle.START_Y, Paddle.WIDTH, Paddle.HEIGHT),
color, true);
this.panel = panel;
}

public void move(int dx) {

if ((getX() + dx >= 0) && (getX() + dx + WIDTH <=
panel.getWidth())) {
move(dx, 0);
}
}
 public void moveRight() {
move(SPEED);
}

public void moveLeft() {

move(-SPEED);
}
}

---------------------------------------

public class BreakoutPanel extends JPanel {

private Paddle paddle;
public BreakoutPanel() {
...
paddle = new Paddle(Color.BLUE, this);
addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if(e.getKeyCode()==KeyEvent.VK_LEFT){
paddle.moveLeft();
}
if (e.getKeyCode()==KeyEvent.VK_RIGHT) {
paddle.moveRight();
}
repaint();
}
});
addMouseMotionListener(new MouseMotionAdapter() {
boolean firstTime = true;
int oldX;
public void mouseMoved(MouseEvent e) {
if (firstTime) {
oldX = e.getX();
firstTime = false;
}
paddle.move(e.getX() - oldX);
oldX = e.getX();
repaint();
}
});
 Bouncing the Ball off the Paddle
• We do not want the ball to intersect the paddle.
• We will therefore create a virtual ball. This will be where the
ball will move if there are no obstacles.
• If the virtual ball intersects the paddle, then we must bounce
the ball, that is, change its Y direction.
• We will also change the X direction of the ball. If the ball hits
the left side of the paddle, then it will bounce to the left.
Otherwise, it will bounce to the right.
• We will also add the goUp, goDown, goLeft, and goRight
methods to the Ball class in order to be able to directly control
the direction of the ball.
 New Version of Ball Class
public class Ball extends BreakoutShape {
private static final int SIZE = 10;
private static final int START_X = 200;
private static final int START_Y = 400;

private BreakoutPanel panel;

private int dx = 1;
private int dy = -1;

public Ball(Color color,BreakoutPanel panel) {

super(new Ellipse2D.Double(Ball.START_X, Ball.START_Y,
Ball.SIZE, Ball.SIZE), color, true);
this.panel = panel;
}

private Ball(Color color, Ellipse2D.Double ellipse){

super(ellipse,color,true);
}
public Ball getVirtualBall(){
return new Ball( super.getColor(),
new Ellipse2D.Double(getX()+dx,getY()+dy,SIZE,SIZE));
}

public void move() {

if (getX() + dx < 0) {
dx = 1;
}
if (getX() + getWidth() + dx > panel.getWidth()) {
dx = -1;
}
if (getY() + dy < 0) {
dy = 1;
}
if (getY()+getHeight() +dy > panel.getHeight()){
dy = -1;
}
super.move(dx, dy);
}
 public void goUp(){
dy = -1;
}

public void goDown(){

dy = 1;
}

public void goLeft(){

dx = -1;
}

public void goRight(){

dx = 1;
}
}
 Checking for Collisions
• We want to be able to check if the ball intersects with the
paddle or bricks.
• There is a method intersects that works on a RectangularShape
object. The method takes as input a Rectangle2D object.
• We will use this method to add an intersects method to the
BreakoutShape class.

class BreakoutShape{
...
public boolean intersects(BreakoutShape other) {
return shape.intersects(other.shape.getBounds());
}
...
}
 Updating the BreakoutPanel Class
• Before moving the ball, we will create a virtual ball.
• If the virtual ball intersects the paddle, then we will bounce
the ball off the paddle.
• We will also check if the ball hits the left or right side of the
paddle and bounce the ball to the left or right, respectively.
public BreakoutPanel() { ...
public BreakoutPanel(){ ...
timer = new javax.swing.Timer(10, new TimeListener());
}
class TimeListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Ball newBall = ball.getVirtualBall();
if (newBall.intersects(paddle)) {
ball.goUp();
if (newBall.getX()+newBall.getWidth() / 2 <
paddle.getX() + paddle.getWidth() / 2) {
ball.goLeft();
} else {
ball.goRight();
}
} else if (ball.getY() > //ball bellow paddle
paddle.getY() - paddle.getHeight()) {
System.exit(0);
}
ball.move();
repaint();
} } }
 The Player Class
• We will draw a stickman for every life.
• We will start with three lives. Every time a life is lost, a
stickman will be removed from the panel.
• When there are no stickmen, the game is over.

import java.awt.*;
import java.io.File;
import javax.imageio.ImageIO;

public class Player {

private static int INITIAL_NUM_LIVES = 3;
private static int IMAGE_Y_POSITION = 450;
private static int IMAGE_H_GAP = 5;
private int numLives;
 public Player() {
this.numLives = INITIAL_NUM_LIVES;
}
public void killPlayer() {
numLives--;
}
public boolean isAlive() {
return (numLives > 0);
}
public void draw(Graphics2D g2) {
try {
Image image = ImageIO.read(new File("player.gif"));
for (int x = 0; x < numLives; x++) {
g2.drawImage(image, x * (image.getWidth(null) +
IMAGE_H_GAP), IMAGE_Y_POSITION, null);
}
} catch (Exception newException) {
}
}
}
 Rewriting BreakoutPanel Class (again)
• We will modify the paintComonent method to display the
stickman. class BreakoutPanel{
private Player player = new Player();
...
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (!player.isAlive()) {
showMessage("GAME OVER!", g2);
return;
}
player.draw(g2);
ball.draw(g2);
paddle.draw(g2);
}
 When Ball Goes Under Paddle
class TimeListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Ball newBall = ball.getVirtualBall();
if (newBall.intersects(paddle)) {
ball.goUp();
if (newBall.getX() + newBall.getWidth() / 2 <
paddle.getX() + paddle.getWidth() / 2) {
ball.goLeft();
} else {
ball.goRight();
}
} else if (ball.getY() >
paddle.getY() - paddle.getHeight()) {
ball.goUp();
player.killPlayer();
}
ball.move();
repaint();}}}
 Adding the Menus
• We will have menus for starting/stopping the game, ball color,
and ball speed.
• For ball color and ball speed, we will create enum types and
enumerate possible options.
• For starting/stopping the game, we will add start/pause
methods to the panel.
• The menus will be, of course, in the frame class. The frame class
will call panel methods as necessary.
• We will also have panel methods for changing the color and size
of the ball.
• We will use the setAccelerator method on menu items to add
accelerator keys (e.g. Ctrl+S starts a game).
public enum BallColor { public enum BallSpeed {
Red(Color.RED), FAST(1),
Blue(Color.BLUE), NORMAL(10),
Green(Color.GREEN); SLOW(20);
private Color color; private int speed;

BallColor(Color color) { BallSpeed(int speed) {

this.color = color; this.speed = speed;
} }
int speed(){
Color color() { return speed;
return color; }
} }
}
import javax.swing.*;
import java.awt.event.*;

public class BreakoutFrame extends JFrame {

private static final int HEIGHT = 600;
private static final int WIDTH = 488;
private BreakoutPanel panel = new BreakoutPanel();
public BreakoutFrame() {
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
displayMenu();
setLocation(100, 100);
setSize(WIDTH, HEIGHT);
add(panel);
setResizable(false);
}
public void displayMenu() {
JMenuBar menuBar = new JMenuBar();
menuBar.add(new GameMenu());
menuBar.add(new ColorMenu());
menuBar.add(new SpeedMenu());
setJMenuBar(menuBar);
}
private class GameMenu extends JMenu {

public GameMenu() {
super("Game");
JMenuItem startGameMI = new JMenuItem("Start",'S');
startGameMI.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_S, InputEvent.CTRL_MASK));
JMenuItem pauseMI = new JMenuItem("Pause", 'P');
pauseMI.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,
InputEvent.CTRL_MASK));
JMenuItem quitMI = new JMenuItem("Quit");
startGameMI.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.start();
}
});
pauseMI.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.pause();
}
});
quitMI.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}});
add(startGameMI);
add(pauseMI);
add(quitMI);
}
}
private class ColorMenu extends JMenu {
public ColorMenu() {
super("Ball Color");
for (BallColor color : BallColor.values()) {
JMenuItem menuItem = new JMenuItem(color.name()+" Ball");
menuItem.addActionListener(new BallColorListener(color));
add(menuItem);
}
}
}
private class BallColorListener implements ActionListener {
private BallColor color;
public void actionPerformed(ActionEvent e) {
panel.changeBallColor(color);
}
public BallColorListener(BallColor color) {
this.color = color;
}
}
 private class SpeedMenu extends JMenu {
public SpeedMenu() {
super("Ball Speed");
for (BallSpeed s : BallSpeed.values()) {
JMenuItem menuItem = new JMenuItem(s.name());
menuItem.addActionListener(new BallSpeedListener(
s.speed()));
add(menuItem);
}
}
}
private class BallSpeedListener implements
ActionListener {
private int speed;
public void actionPerformed(ActionEvent e) {
panel.changeBallSpeed(speed);
}
public BallSpeedListener(int speed) {
this.speed = speed;
}
}
}
 The BreakoutPanel Class (new revision)
• We will be able to start/stop the game from menus.
• The start method will check if there is a timer. If there is no timer,
then one will be created and the timer will be started. The
method also checks if there are no lives left. If this is the case,
then the lives will be replenished and a brand new game will be
started.
• The pause method will call the stop method on the timer
(assuming there is a timer). The stop method stops the timer.
• We also need to introduce a new variable: gameStarted. It will
keep track if the game is started.
• The changeBallSpeed method will can the setDelay method of
the Timer class to change the frequency of the timer.
public class BreakoutPanel extends JPanel {
private javax.swing.Timer timer;
private Ball ball;
private Paddle paddle;
private Player player;
private boolean gameStarted = false;
...
public void start() {
gameStarted = true;
if (timer != null) {
timer.stop();
}
if (!player.isAlive()) {
player = new Player(); //restart the game
ball = new Ball(Color.RED, this);
}
timer= new javax.swing.Timer(BallSpeed.NORMAL.speed(),
new BreakoutPanel.TimeListener());
timer.start();
repaint();
}
public void pause() {
if (timer == null) {
return;
}
timer.stop();
}
public void changeBallColor(BallColor color) {
ball.changeColor(color.color());
repaint();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;

if (!player.isAlive()) {
showMessage("GAME OVER!", g2);
gameStarted = false;
} else {
ball.draw(g2);
paddle.draw(g2);
}
 if (gameStarted) {
player.draw(g2);
}
}

public void changeBallSpeed(int speed) {

timer.setDelay(speed);
}
...
}
 Adding the Bricks
• The code for creating the bricks is the same as before.
• The difference is that we need to check if the virtual ball
intersects one (or two) of the bricks and bounce the ball
accordingly.
• If the ball intersects two bricks, then they must be adjacent
(horizontally or vertically) and we will merge them into a
single big brick and bounce the ball off this brick. Of course,
the big brick will not be displayed.
• The method add can be used to merge two rectangles.
public class Brick extends BreakoutShape {
private static final int HEIGHT = 10;
private static final int WIDTH = 30;
private static final int BRICK_H_GAP = 2;
private static final int BRICK_V_GAP = 2;
public Brick(int row, int col, Color color) {
super(new Rectangle2D.Double(BRICK_H_GAP +
row * (BRICK_H_GAP + Brick.WIDTH),
BRICK_V_GAP + col * (BRICK_V_GAP + Brick.HEIGHT),
WIDTH, HEIGHT), color, true);
}
private Brick(Rectangle2D rectangle, Color color){
super(rectangle,color,true);
}
public Brick add(Brick other){
Rectangle2D rectangle1 = super.getBounds();
Rectangle2D rectangle2 = other.getBounds();
rectangle1.add(rectangle2);
return new Brick(rectangle1,super.getColor());
}
}
 New Version of the BreakoutShape Class
• When the virtual ball intersects a brick, we want to determine
if the ball is to the left, to the right, below, or above the brick.
We will bounce the ball accordingly.
• We will modify the BreakoutShape class and add the
methods.
public class BreakoutShape {
private Color color;
private boolean fill;
private RectangularShape shape;
...
public boolean below(BreakoutShape other) {
return getY() >= other.getY() + other.getHeight();
}

public boolean above(BreakoutShape other) {

return getY() + getHeight() <= other.getY();
}

public boolean leftOf(BreakoutShape other) {

return getX() + getWidth() <= other.getX();
}

public boolean rightOf(BreakoutShape other) {

return getX() >= other.getX() + other.getWidth();
}
}
 BreakoutPanel (final version)
• We create an ArrayList where we store the bricks that
intersect the virtual ball.
• Then we bounce the ball off these bricks and then we delete
the bricks.
• Note that we cannot directly remove a brick when we find
that it intersects the virtual ball.
• The reason is that in a for-each for loop we cannot remove
elements of the ArrayList that is iterated.
• If we do so, we will get ConcurrentModificationException.
public class BreakoutPanel extends JPanel {
private static final int NUM_BRICK_ROWS = 10;
private static final int NUM_BRICK_COLUMNS = 30;
private javax.swing.Timer timer;
private Ball ball;
private ArrayList<Brick> bricks;
private Paddle paddle;
private Player player;
private boolean gameStarted = false;

public BreakoutPanel() {
ball = new Ball(BallColor.Red, this);
paddle = new Paddle(Color.BLUE, this);
bricks = new ArrayList<>();
player = new Player();
createBricks();
addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
String s = KeyEvent.getKeyText(e.getKeyCode());
if (e.getKeyCode() == KeyEvent.VK_LEFT) {
paddle.moveLeft();
}
 if (s.equals("Right")) {
paddle.moveRight();
}
repaint();
}
});
setFocusable(true);
addMouseMotionListener(new MouseMotionAdapter() {
boolean firstTime = true;
int oldX;

public void mouseMoved(MouseEvent e) {

if (firstTime) {
oldX = e.getX();
firstTime = false;
}
paddle.move(e.getX() - oldX);
oldX = e.getX();
repaint();
}
});
}
 private Color getRandomColor() {
Color color = new Color((int) (Math.random() * 256),
(int) (Math.random() * 256), (int) (Math.random() * 256));
if (getBackground().equals(color)) {
return Color.RED;
}
return color;
}
private void createBricks() {
for (int row = 0; row < NUM_BRICK_ROWS; row++) {
for (int col = 0; col < NUM_BRICK_COLUMNS; col++) {
bricks.add(new Brick(row, col, getRandomColor()));
}
}
}
public void start() {
gameStarted = true;
if (timer != null) {
timer.stop();
}
if (!player.isAlive()) {
player = new Player();
ball = new Ball(BallColor.Red, this);
createBricks();
}
timer = new javax.swing.Timer(BallSpeed.NORMAL.speed(),
new TimeListener());
timer.start();
repaint();
}

public void pause() {

if (timer == null) {
return;
}
timer.stop();
}

public void changeBallColor(BallColor color) {

ball.changeColor(color);
repaint();
}
public void showMessage(String s, Graphics2D g2) {
Font myFont = new Font("SansSerif",Font.BOLD+Font.ITALIC, 40);
g2.setFont(myFont);
g2.setColor(Color.RED);
Rectangle2D textBox = myFont.getStringBounds(s,
g2.getFontRenderContext());
g2.drawString(s, (int) (getWidth()/ 2-textBox.getWidth() / 2),
(int) (getHeight() / 2 - textBox.getHeight()));
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (bricks.size() == 0 && !gameStarted) {
showMessage("YOU WIN!", g2);
gameStarted = false;
} else if (!player.isAlive()) {
showMessage("GAME OVER!", g2);
gameStarted = false;
} else {
ball.draw(g2);
paddle.draw(g2);
for (Brick brick : bricks) {
brick.draw(g2);
}
}
if (gameStarted) {
player.draw(g2);
}
}

public void changeBallSpeed(int speed) {

timer.setDelay(speed);
}

class TimeListener implements ActionListener {

private void bounceBall(Ball ball, Brick brick) {
if (ball.below(brick)) {
ball.goDown();
}
if (ball.above(brick)) {
ball.goUp();
}
if (ball.leftOf(brick)) {
ball.goLeft();
}
if (ball.rightOf(brick)) {
ball.goRight();
}
}
private void bounceBall(Ball ball, ArrayList<Brick> bricks) {
if (bricks.size() == 0) {
return;
}
if (bricks.size() == 1) {
bounceBall(ball, bricks.get(0));
return;
}

Brick combinedBrick = bricks.get(0).add(bricks.get(1));

bounceBall(ball, combinedBrick);
}

public void actionPerformed(ActionEvent e) {

Ball newBall = ball.getVirtualBall();
ArrayList<Brick> bricksToBeDeleted = new ArrayList<Brick>();
for (Brick brick : bricks) {
if (brick.intersects(newBall)) {
bricksToBeDeleted.add(brick);
}
}
bounceBall(ball, bricksToBeDeleted);
for (Brick brick : bricksToBeDeleted) {
bricks.remove(brick);
}
 if (newBall.intersects(paddle)) {
ball.goUp();
if (newBall.getX() + newBall.getWidth() / 2 <
paddle.getX() + paddle.getWidth() / 2) {
ball.goLeft();
} else {
ball.goRight();
}
} else if (ball.getY() >
paddle.getY() - paddle.getHeight()) {
player.killPlayer();
ball.goUp();
}
ball.move();
repaint();
}
}
}
 Summary
• We followed the following principles when creating our design.
– Delegation: Delegate responsibilities to classes and methods.
– Short Methods: Every methods is simple and performs just
one task.
– Limit inter-class interaction: All data is declared private.
Methods that should be not be accessed outside the class
are also declared private.
– Test often: Do not write the whole program in one breath.
Create a simple feature, test it, and make sure it works
before proceeding to the next feature.