Department of Computer Science and Engineering 2022-2023

Subject Name
ADVANCED JAVA PROGRAMMING (AJP)

Topic
BREAKOUT GAME USING JAVA

Class
CW-5I (COMPUTER SCIENCE AND ENGINEERING)

Name of Students
AYAAN AHMED TAJ

Project In Charge Head of Department

K.P.MOHURLE S.A.REWATKAR

1
 INDEX

Sr Content Page no.

no.
1. Introduction 3

2. Methodology 5

3. Program 7

4. Output 18

5. Resources 19

6. Learning out of the project 20

7. Applications 21

8. Future Scope 22

9. Conclusion 23

INTRODUCTION
A breakout game in Java is a classic arcade-style game where the player controls a paddle at
the bottom of the screen to bounce a ball and break a wall of bricks. The goal is to clear all
the bricks from the screen by hitting them with the ball. Here's a simple outline of how you
might create a basic breakout game in Java:

2
Setting Up the Game Window:

Use a graphics library like Swing or JavaFX to create a window for the game.

Set up the dimensions, background, and any necessary game settings.

Game Elements:

Create classes for game entities such as the paddle, ball, and bricks.

Define their properties such as position, size, and speed.

Game Loop:

Implement a game loop that continuously updates and renders the game.

Update the ball's position based on its velocity.

Check for collisions between the ball and the paddle, as well as the ball and the bricks.

User Input:

Capture user input (keyboard) to move the paddle left and right.

Update the paddle's position accordingly within the game loop.

Collision Detection and Response:

Detect collisions between the ball and game elements (paddle, bricks, walls).

Adjust the ball's direction when it hits different surfaces (angles for bricks, reflection for
paddle).

Brick Destruction:

When the ball collides with a brick, remove the brick from the game.

Update the player's score based on the number of bricks destroyed.

Winning and Losing:

3
Check conditions to determine if the player has won (all bricks are destroyed) or lost (ball
goes below the paddle).

Graphics and Rendering:

Render the game elements on the screen using the chosen graphics library.

Update the display within the game loop to reflect changes in position and state.

Sound Effects and Music:

Enhance the gameplay experience with sound effects for collisions, brick destruction, and
other events.

Add background music to make the game more engaging.

Game Over and Restart:

Implement logic to handle game over and allow the player to restart the game.

Remember that this is a simplified overview, and creating a complete and polished breakout
game involves more details and considerations. You can find tutorials, resources, and sample
code online to help you implement each aspect of the game. As you gain more experience,
you can also explore adding additional features like power-ups, different levels, and more
complex gameplay mechanics.

METHODOLOGY

Creating a breakout game as a microproject in Java can be simplified while still covering the
essential aspects. Here's a streamlined methodology:

4
Setup and Initialization: Set up the game window and initialize the game components such as
the ball, paddle, and bricks.

Game Loop: Implement a game loop that repeatedly updates the game state and renders it on
the screen.

Input Handling: Capture user input to control the paddle's movement using keyboard events.

Collision Detection: Detect collisions between the ball, paddle, and bricks. Update ball
direction and remove bricks upon collision.

Physics and Movement: Implement basic physics to control the ball's movement, bouncing
off walls, paddle, and bricks.

Brick Generation: Create a simple grid of bricks using arrays or collections. Each brick can
have a basic state (e.g., present or destroyed).

Scoring: Update and display the player's score based on the number of bricks destroyed.

Win/Loss Condition: Implement conditions to determine when the player wins (all bricks
destroyed) or loses (ball goes below the paddle).

Graphics and Rendering: Draw the game elements (ball, paddle, bricks) onto the screen using
basic graphics functions.

5
Game Over and Restart: Provide an option to restart the game after winning or losing.

Simple User Interface: Create a basic user interface with buttons for starting, restarting, and
exiting the game.

Comments and Documentation: Add comments to your code explaining important sections
and functions. Write a brief documentation outlining how to play the game and control the
paddle.

PROGRAM

PROGRAM FOR CREATING A BREAKOUT GAME:-

import javax.swing.*;

6
import java.awt.*;

import java.awt.event.*;

class MapGenerator {

public int map [][];

public int brickWidth;

public int brickHeight;

// this creates the brick of size 3x7

public MapGenerator(int row, int col) {

map = new int [row][col];

for (int i = 0; i < map.length; i++) {

for (int j=0; j< map[0].length;j++) {

map[i][j] = 1;

brickWidth = 540/col;

brickHeight = 150/row;

// this draws the bricks

public void draw(Graphics2D g) {

7
 for (int i = 0; i < map.length; i++) {

for (int j=0; j< map[0].length;j++) {

if(map[i][j] > 0) {

g.setColor(new Color(0XFF8787)); // brick color

g.fillRect(j*brickWidth + 80, i*brickHeight + 50,

brickWidth, brickHeight);

g.setStroke(new BasicStroke(4));

g.setColor(Color.BLACK);

g.drawRect(j*brickWidth + 80, i*brickHeight + 50,

brickWidth, brickHeight);

// this sets the value of brick to 0 if it is hit by the ball

public void setBrickValue(int value, int row, int col) {

map[row][col] = value;

class GamePlay extends JPanel implements KeyListener, ActionListener {

8
private boolean play = true;

private int score = 0;

private int totalBricks = 21;

private Timer timer;

private int delay = 8;

private int playerX = 310;

private int ballposX = 120;

private int ballposY = 350;

private int ballXdir = -1;

private int ballYdir = -2;

private MapGenerator map;

public GamePlay() {

map = new MapGenerator(3, 7);

addKeyListener(this);

setFocusable(true);

setFocusTraversalKeysEnabled(false);

timer = new Timer(delay, this);

9
 timer.start();

public void paint(Graphics g) {

//background color

g.setColor(Color.YELLOW);

g.fillRect(1, 1, 692, 592);

map.draw((Graphics2D)g);

g.fillRect(0, 0, 3, 592);

g.fillRect(0, 0, 692, 3);

g.fillRect(691, 0, 3, 592);

g.setColor(Color.blue);

g.fillRect(playerX, 550, 100, 12);

g.setColor(Color.RED); // ball color

g.fillOval(ballposX, ballposY, 20, 20);

g.setColor(Color.black);

g.setFont(new Font("MV Boli", Font.BOLD, 25));

10
g.drawString("Score: " + score, 520, 30);

if (totalBricks <= 0) { // if all bricks are destroyed then you win

play = false;

ballXdir = 0;

ballYdir = 0;

g.setColor(new Color(0XFF6464));

g.setFont(new Font("MV Boli", Font.BOLD, 30));

g.drawString("You Won, Score: " + score, 190, 300);

g.setFont(new Font("MV Boli", Font.BOLD, 20));

g.drawString("Press Enter to Restart.", 230, 350);

if(ballposY > 570) { // if ball goes below the paddle then you lose

play = false;

ballXdir = 0;

ballYdir = 0;

g.setColor(Color.BLACK);

g.setFont(new Font("MV Boli", Font.BOLD, 30));

g.drawString("Game Over, Score: " + score, 190, 300);

g.setFont(new Font("MV Boli", Font.BOLD, 20));

11
 g.drawString("Press Enter to Restart", 230, 350);

g.dispose();

@Override

public void actionPerformed(ActionEvent arg0) {

timer.start();

if(play) {

// Ball - Pedal interaction

if(new Rectangle(ballposX, ballposY, 20, 20).intersects(new

Rectangle(playerX, 550, 100, 8))) {

ballYdir = - ballYdir;

for( int i = 0; i<map.map.length; i++) { // Ball - Brick interaction

for(int j = 0; j<map.map[0].length; j++) { // map.map[0].length

is the number of columns

if(map.map[i][j] > 0) {

int brickX = j*map.brickWidth + 80;

int brickY = i*map.brickHeight + 50;

int brickWidth= map.brickWidth;

int brickHeight = map.brickHeight;

12
 Rectangle rect = new Rectangle(brickX, brickY,
brickWidth, brickHeight);

Rectangle ballRect = new Rectangle(ballposX,

ballposY, 20,20);

Rectangle brickRect = rect;

if(ballRect.intersects(brickRect) ) {

map.setBrickValue(0, i, j);

totalBricks--;

score+=5;

if(ballposX + 19 <= brickRect.x ||

ballposX +1 >= brickRect.x + brickRect.width)

ballXdir = -ballXdir;

else {

ballYdir = -ballYdir;

ballposX += ballXdir;

13
 ballposY += ballYdir;

if(ballposX < 0) { // if ball hits the left wall then it bounces back

ballXdir = -ballXdir;

if(ballposY < 0) { // if ball hits the top wall then it bounces back

ballYdir = -ballYdir;

if(ballposX > 670) { // if ball hits the right wall then it bounces back

ballXdir = -ballXdir;

repaint();

@Override

public void keyTyped(KeyEvent arg0) {

14
 @Override

public void keyPressed(KeyEvent arg0) {

if(arg0.getKeyCode() == KeyEvent.VK_RIGHT) { // if right arrow key is

pressed then paddle moves right

if(playerX >= 600) {

playerX = 600;

} else {

moveRight();

if(arg0.getKeyCode() == KeyEvent.VK_LEFT) { // if left arrow key is pressed

then paddle moves left

if(playerX < 10) {

playerX = 10;

} else {

moveLeft();

if(arg0.getKeyCode() == KeyEvent.VK_ENTER) { // if enter key is pressed

then game restarts

if(!play) {

15
 play = true;

ballposX = 120;

ballposY = 350;

ballXdir = -1;

ballYdir = -2;

score = 0;

totalBricks = 21;

map = new MapGenerator(3,7);

repaint();

public void moveRight() { // paddle moves right by 50 pixels

play = true;

playerX += 50;

public void moveLeft() { // paddle moves left by 50 pixels

play = true;

playerX -= 50;

16
 @Override

public void keyReleased(KeyEvent arg0) {

class Main {

public static void main(String[] args) {

JFrame obj = new JFrame();

GamePlay gamePlay = new GamePlay();

obj.setBounds(10, 10, 700, 600);

obj.setTitle("Brick Breaker");

obj.setResizable(false);

obj.setVisible(true);

obj.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

obj.add(gamePlay);

17
RESOURCES REQUIRED

18
SR.NO RESOURCES MATERIAL SPECIFICATIONS
.
1. Computer Windows 11
2. Internet Wikipedia
3. Textbook Advanced java
programming

LEARNING OUT OF THIS PROJECT

19
Creating a Breakout game using Java can be a great learning project. It involves concepts like
game loops, collision detection, and graphics rendering. You'll need to handle player input,
manage game objects, and update the display. As you work on it, you'll gain valuable
experience in programming, problem-solving, and game development. Don't hesitate to ask if
you need any specific guidance or help while working on your project.

APPLICATIONS

20
Developing a Breakout game using Java as a microproject can have several applications:

1. Programming Skills: It's a practical way to apply Java programming concepts, including
classes, objects, inheritance, and event handling.

2. Game Development: Creating a game introduces you to game development concepts such
as game loops, collision detection, and physics simulations.

3. Problem Solving: You'll face challenges like managing game state, designing levels, and
optimizing performance, which help improve your problem-solving skills.

4. Graphics and Animation: Implementing graphics and animations enhances your

understanding of rendering techniques and visual feedback.

5. User Interaction: Developing player controls and game mechanics will give you insights
into user interaction design.

6. Software Engineering: Planning and structuring the game's components demonstrate

software engineering principles like modularity and maintainability.

7. Portfolio Enhancement: Completed projects like this can be included in your portfolio to
showcase your skills to potential employers or collaborators.

8. Learning Experience: The process of researching, learning, and implementing will provide
hands-on experience, making your learning more engaging and memorable.

Remember, the skills you gain from this microproject can be transferrable to more complex
game projects and software development tasks.

FUTURE SCOPE

21
The future scope of a breakout game could involve incorporating advanced graphics,
immersive virtual reality or augmented reality experiences, multiplayer modes, innovative
power-ups, dynamic levels generated by AI, and integration with emerging technologies like
haptic feedback or motion sensing for more interactive gameplay. The game could also be
expanded to different platforms, such as mobile devices, consoles, and even smart glasses, to
reach a wider audience and take advantage of evolving hardware capabilities.

CONCLUSION

22
The breakout game has proven to be a timeless classic with its simple yet addictive gameplay.
Its potential for innovation and adaptation remains promising in the future. Whether through
enhanced visuals, new gameplay mechanics, or integration with cutting-edge technologies,
the breakout game's enduring appeal suggests that it will continue to captivate players for
generations to come.

23