Tetris Game in Java

One of the most common computer games ever created is the Tetris game. Nowadays we can play this game on mobile too. The game was designed, as well as created by Alexey Pajitnov in 1985. He was a Russian Programmer. A lot of different variation has come to this game has come in the market. However, in this tutorial, we will be creating a basic Tetris game.

Tetris game is known as a block puzzle falling game. In a Tetris game, we have a total of seven different shapes known as Tetrominoes. Those seven Tetrominoes are Line-shape, Z-shape, S-shape, L-shape, T-shape, Square-shape, and a Mirrored L-shape. All the mentioned shapes are composed of only four squares. The shapes will fall down the board. The aim of a player playing the Tetris game is to rotate and move shapes so that they get fit as much as they can. If a complete row is formed, that row is destroyed, and the score is incremented. Until we top out, the Tetris game is played.

FileName: Window.java

// important import statement
import javax.swing.JFrame;

public class Window
{

// fields for width and height of the frame
// these fields should never be changed knowingly or 
// unknowingly across the whole program. Hence, they 
// are declared as final
public static final int WIDTH = 445; 
public static final int HEIGHT = 629;

private Board boardObj;
private Title titleObj;
private JFrame windowFrame;

public Window()
{

// creating an object of the class JFrame
windowFrame = new JFrame("Tetris");
// setting the width and height
windowFrame.setSize(WIDTH, HEIGHT);

// after pressing the x button the frame should close
windowFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
windowFrame.setLocationRelativeTo(null);
windowFrame.setResizable(false);	

// creating a new object of the class Board
boardObj = new Board();
// creating a new Title Object
titleObj = new Title(this);

// addinng the key listener
windowFrame.addKeyListener(boardObj);

// adding the mousemotion listener
windowFrame.addMouseMotionListener(titleObj);

// adding the mouse listener
windowFrame.addMouseListener(titleObj);

windowFrame.add(titleObj);

// setting the visibility to true
windowFrame.setVisible(true);
}

public void startTetris()
{
windowFrame.remove(titleObj);
windowFrame.addMouseMotionListener(boardObj);
windowFrame.addMouseListener(boardObj);
windowFrame.add(boardObj);
boardObj.sttGame();
windowFrame.revalidate();
}

// main method
public static void main(String[] argvs) 
{


// creating an anonymous object of the class Window
new Window();
}

}

FileName: Title.java

// important import statements
import java.awt.Graphics;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseListener;
import java.io.IOException;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
import javax.imageio.ImageIO;
import javax.swing.Timer;

public class Title extends JPanel implements MouseMotionListener, MouseListener
{

private static final long serialVerUID = 1L;

// for x and y coordinates
private int mousX, mousY;
private Rectangle bnds;
private boolean lftClick = false;
private BufferedImage ttle;
private BufferedImage instt;
private BufferedImage ply;
private Window win;
private BufferedImage[] playBtn = new BufferedImage[2];
private Timer tmr;


public Title(Window win)
{
try 
{
ttle = ImageIO.read(Board.class.getResource("/Title.png" ));
instt = ImageIO.read(Board.class.getResource("/arrow.png" ));
ply = ImageIO.read(Board.class.getResource("/play.png" ));
} 
catch (IOException obj) 
{
obj.printStackTrace();
}
tmr = new Timer(1000 / 60, new ActionListener()
{

@Override
public void actionPerformed(ActionEvent ae) 
{
repaint();
}

});
tmr.start();
mousX = 0;
mousY = 0;

playBtn[0] = ply.getSubimage(0, 0, 100, 80);
playBtn[1] = ply.getSubimage(100, 0, 100, 80);

bnds = new Rectangle(Window.WIDTH / 2 - 50, Window.HEIGHT / 2 - 100, 100, 80);
this.win = win;



}

public void paintComponent(Graphics gr)
{
super.paintComponent(gr);

if(lftClick && bnds.contains(mousX, mousY))
{
win.startTetris();
}

gr.setColor(Color.BLACK);

gr.fillRect(0, 0, Window.WIDTH, Window.HEIGHT);

gr.drawImage(ttle, Window.WIDTH / 2 - ttle.getWidth() / 2, Window.HEIGHT / 2 - ttle.getHeight() / 2 - 200, null);
gr.drawImage(instt, Window.WIDTH / 2 - instt.getWidth() / 2, Window.HEIGHT / 2 - instt.getHeight() / 2 + 150, null);

if(bnds.contains(mousX, mousY))
{
gr.drawImage(playBtn[0], Window.WIDTH / 2 - 50, Window.HEIGHT / 2 - 100, null);
}
else
{
gr.drawImage(playBtn[1], Window.WIDTH / 2 - 50, Window.HEIGHT / 2 - 100, null);
}


}

// methods of various events
@Override
public void mouseClicked(MouseEvent me) 
{	
}

@Override
public void mousePressed(MouseEvent me) 
{
if(me.getButton() == MouseEvent.BUTTON1)
{
lftClick = true;
}
}

@Override
public void mouseReleased(MouseEvent me) 
{
if(me.getButton() == MouseEvent.BUTTON1)
{
lftClick = false;
}
}

@Override
public void mouseEntered(MouseEvent me) 
{

}

@Override
public void mouseExited(MouseEvent me) 
{
}

@Override
public void mouseDragged(MouseEvent me) 
{
mousX = me.getX();
mousY = me.getY();
}

@Override
public void mouseMoved(MouseEvent me) 
{
mousX = me.getX();
mousY = me.getY();
}	
}

FileName: Board.java

// important import statements
import java.awt.Color;
import java.awt.BasicStroke;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseListener;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.awt.event.MouseEvent;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.LineUnavailableException;
import javax.swing.JPanel;
import javax.imageio.ImageIO;
import javax.swing.Timer;
import javax.sound.sampled.Clip;

public class Board extends JPanel implements KeyListener, MouseListener, MouseMotionListener
{

private static final long serialVerUID = 1L;

private Clip msic;

private BufferedImage blcks;
private BufferedImage bkground;
private BufferedImage paus;
private BufferedImage rfresh;

//the dimensions of the board (the area of playing the game)

private final int brdHeight = 20;
private final int brdWidth = 10;

// the size of block used in the Tetris game

private final int blckSize = 30;

private int[][] board = new int[brdHeight][brdWidth];

// array for all of the shapes that are possible in the game

private Shape[] diffShapes = new Shape[7];

// for the current shape

private static Shape currShape;

// for the next shape
private static Shape nxtShape;

// for the game loop

private Timer timerLooper;

private int FPS = 60;

private int delay = 1000 / FPS;

// variables for the mouse events

private int mousX; 
private int mousY; 

private boolean lftClick = false;

private Rectangle stpBounds;
private Rectangle rfreshBounds;

// a boolean fields that is true when the 
// pause button is pressed
private boolean gmPaused = false;

// a boolean field that is true when the top
// row is occupied
private boolean gmOver = false;

// buttons press lapse

private Timer btnLapse = new Timer(300, new ActionListener()
{

@Override
public void actionPerformed(ActionEvent ae) 
{
btnLapse.stop();
}});

// for handling the total score

private int totalScore = 0;


public Board()
{
// loading the Assets
blcks = ImageLoader.loadImage("/tiles.png");

bkground = ImageLoader.loadImage("/background.png");
paus = ImageLoader.loadImage("/pause.png");
rfresh = ImageLoader.loadImage("/refresh.png");

msic = ImageLoader.loadMusic("/music.wav");

msic.loop(Clip.LOOP_CONTINUOUSLY);

mousX = 0;
mousY = 0;

stpBounds = new Rectangle(350, 500, paus.getWidth(), paus.getHeight() + paus.getHeight() / 2);
rfreshBounds = new Rectangle(350, 500 - rfresh.getHeight() - 20, rfresh.getWidth(), rfresh.getHeight() + rfresh.getHeight() / 2);

// creating the game timerLooper

timerLooper = new Timer(delay, new GameLooper());

// creating the differnt Tetrominoes 

diffShapes[0] = new Shape(new int[][]
{
{1, 1, 1, 1}   // creating a linear shape
}, blcks.getSubimage(0, 0, blckSize, blckSize), this, 1);

diffShapes[1] = new Shape(new int[][]
{
{1, 1, 1},
{0, 1, 0},   // creating a T shape
}, blcks.getSubimage(blckSize, 0, blckSize, blckSize), this, 2);

diffShapes[2] = new Shape(new int[][]
{
{1, 1, 1},
{1, 0, 0},   // creating a L shape
}, blcks.getSubimage(blckSize * 2, 0, blckSize, blckSize), this, 3);

diffShapes[3] = new Shape(new int[][]{
{1, 1, 1},
{0, 0, 1},   // creating a J shape;
}, blcks.getSubimage(blckSize * 3, 0, blckSize, blckSize), this, 4);

diffShapes[4] = new Shape(new int[][]
{
{0, 1, 1},
{1, 1, 0},   // creating a S shape;
}, blcks.getSubimage(blckSize * 4, 0, blckSize, blckSize), this, 5);

diffShapes[5] = new Shape(new int[][]
{
{1, 1, 0},
{0, 1, 1},   // creating a Z shape;
}, blcks.getSubimage(blckSize * 5, 0, blckSize, blckSize), this, 6);

diffShapes[6] = new Shape(new int[][]
{
{1, 1},
{1, 1},   // creating a square shape;
}, blcks.getSubimage(blckSize * 6, 0, blckSize, blckSize), this, 7);


}

private void update()
{	
// pressing the pause button toggles the game state
// if the the player is playing the game, then the game is paused
// if the game is already paused, then the game starts
if(stpBounds.contains(mousX, mousY) && lftClick && !btnLapse.isRunning() && !gmOver)
{
btnLapse.start();
gmPaused = !gmPaused;
}

// pressing the refresh button starts the game from the beginning
if(rfreshBounds.contains(mousX, mousY) && lftClick)
{
sttGame();
}
if(gmPaused || gmOver)
{
return;
}
currShape.update();
}


public void paintComponent(Graphics gr)
{
super.paintComponent(gr);

gr.drawImage(bkground, 0, 0, null);


for(int r = 0; r < board.length; r++)
{
for(int c = 0; c < board[r].length; c++)
{

if(board[r][c] != 0)
{
// drawing the tetromino that are currently residing on the board, after they have fall down
gr.drawImage(blcks.getSubimage((board[r][c] - 1) * blckSize, 0, blckSize, blckSize), c * blckSize, r * blckSize, null);
}				

}
}
for(int r = 0; r < nxtShape.getCoords().length; r++)
{
for(int c = 0; c < nxtShape.getCoords()[0].length; c++)
{
if(nxtShape.getCoords()[r][c] != 0)
{
// drawing the next shape on the board, on the top right hand side
gr.drawImage(nxtShape.getBlock(), c * 30 + 320, r * 30 + 50, null);	
}
}		
}
currShape.render(gr);

if(stpBounds.contains(mousX, mousY))
{
gr.drawImage(paus.getScaledInstance(paus.getWidth() + 3, paus.getHeight() + 3, BufferedImage.SCALE_DEFAULT), stpBounds.x + 3, stpBounds.y + 3, null);
}
else
{
gr.drawImage(paus, stpBounds.x, stpBounds.y, null);
}

if(rfreshBounds.contains(mousX, mousY))
{
// when the mouse hovers over the refresh button, it shifts a bit 
gr.drawImage(rfresh.getScaledInstance(rfresh.getWidth() + 3, rfresh.getHeight() + 3, BufferedImage.SCALE_DEFAULT), rfreshBounds.x + 3, rfreshBounds.y + 3, null);
}
else
{
// when the mouse goes away the refresh button, regains its place
gr.drawImage(rfresh, rfreshBounds.x, rfreshBounds.y, null);
}

if(gmPaused)
{
// if the pause button is pressed 
// game should be paused and the GAME PAUSED 
// message is displayed on the screen
String gmPausedString = "GAME PAUSED";

// message is in the white color
gr.setColor(Color.WHITE);

// setting the font
gr.setFont(new Font("Georgia", Font.BOLD, 30));

// displaying the message
gr.drawString(gmPausedString, 35, Window.HEIGHT / 2);
}
if(gmOver)
{
// when the Game is over, the GAME OVER message is displayed
String gmOverString = "GAME OVER";
// message is in the white color
gr.setColor(Color.WHITE);

// setting the font
gr.setFont(new Font("Georgia", Font.BOLD, 30));

// displaying the message
gr.drawString(gmOverString, 50, Window.HEIGHT / 2);
}	

// color is white for displaying score
gr.setColor(Color.WHITE);

// font is Georgia for displaying the score
gr.setFont(new Font("Georgia", Font.BOLD, 20));

// displaying the String "SCORE"
gr.drawString("SCORE", Window.WIDTH - 125, Window.HEIGHT / 2);

// displaying the total score
gr.drawString(totalScore + "", Window.WIDTH - 125, Window.HEIGHT / 2 + 30);

Graphics2D gr2d = (Graphics2D)gr;

gr2d.setStroke(new BasicStroke(2));
gr2d.setColor(new Color(0, 0, 0, 100));

// for drawing the horizontal lines across the board
for(int i = 0; i <= brdHeight; i++)
{
gr2d.drawLine(0, i * blckSize, brdWidth * blckSize, i * blckSize);
}

// for drawing the vertical lines across the board
for(int i = 0; i <= brdWidth; i++)
{
gr2d.drawLine(i * blckSize, 0, i * blckSize, brdHeight * 30);
}
}

// a method that randomly determines the next Tetrominoes 
// that is going to come in the game using the Math.random() method
public void setNxtShape()
{
int idx = (int)(Math.random() * diffShapes.length);
nxtShape = new Shape(diffShapes[idx].getCoords(), diffShapes[idx].getBlock(), this, diffShapes[idx].getColor());
}


public void setCurrShape()
{
// the next Tetromino found 
// is the current shape
currShape = nxtShape;
setNxtShape();

// We know that the current Tetromino will fall down and 
// will occupy some of the playing area. Therefore, it 
// is important to check whether the playing area is filled
// upto the top row or not. If yes, then the game is over.
for(int r = 0; r < currShape.getCoords().length; r++)
{
for(int c = 0; c < currShape.getCoords()[0].length; c++)
{
if(currShape.getCoords()[r][c] != 0)
{
if(board[currShape.getY() + r][currShape.getX() + c] != 0)
{
// if the control reaches here, then it means the game is over.
gmOver = true;
}
}
}		
}

}


public int[][] getBoard()
{
return board;
}

@Override
public void keyPressed(KeyEvent ke) 
{
if(ke.getKeyCode() == KeyEvent.VK_UP)
{
// for rotating the shape
// up arrow key is pressed.
currShape.rotateShape();
}
if(ke.getKeyCode() == KeyEvent.VK_RIGHT)
{
// for moving the Tetromino in the 
// right direction, the right arrow key is pressed
currShape.setDeltaX(1);
}
if(ke.getKeyCode() == KeyEvent.VK_LEFT)
{
// for moving the Tetromino in the 
// left direction, the left arrow key is pressed
currShape.setDeltaX(-1);
}
if(ke.getKeyCode() == KeyEvent.VK_DOWN)
{

// when the down arrow key is pressed and released,
// the tetrominos will fall quickly towards
// bottom
currShape.speedUp();
}
}
@Override
public void keyReleased(KeyEvent ke) 
{
if(ke.getKeyCode() == KeyEvent.VK_DOWN)
{
// when the down arrow key is released
// the speed with which the tetromino is falling down
// goes back to the normal
currShape.speedDown();
}
}

@Override
public void keyTyped(KeyEvent ke) 
{

}

public void sttGame()
{
// start game occurs after the stop game.
stpGame();

// in the start game, next tetromino is determined
// and the current tetromino is also determined
setNxtShape();
setCurrShape();
// as the game is going to start, the gmOver variable is set to false
// and the timer starts
gmOver = false;
timerLooper.start();

}
public void stpGame()
{
// in the stop game,
// totalScore is set to zero,
// and the playing aread is cleared
totalScore = 0;

for(int r = 0; r < board.length; r++)
{
for(int c = 0; c < board[r].length; c++)
{
board[r][c] = 0;
}
}
timerLooper.stop();
}


class GameLooper implements ActionListener
{

@Override
public void actionPerformed(ActionEvent ae) 
{
update();
repaint();
}

}


// getting the coordinates of the mouse events
@Override
public void mouseDragged(MouseEvent me) 
{
mousX = me.getX();
mousY = me.getY();
}

@Override
public void mouseMoved(MouseEvent me) 
{
mousX = me.getX();
mousY = me.getY();
}

@Override
public void mouseClicked(MouseEvent me) 
{

}

@Override
public void mousePressed(MouseEvent me) 
{
if(me.getButton() == MouseEvent.BUTTON1)
{
lftClick = true;
}
}

@Override
public void mouseReleased(MouseEvent me) 
{
if(me.getButton() == MouseEvent.BUTTON1)
{
lftClick = false;
}
}

@Override
public void mouseEntered(MouseEvent me) 
{

}

@Override
public void mouseExited(MouseEvent me) 
{

}

// incrementing the total score by 1
public void addScore()
{
totalScore = totalScore + 1;
}

}

FileName: ImageLoader.java

// important import statements
import java.io.IOException;
import java.awt.image.BufferedImage;
import javax.sound.sampled.AudioSystem;
import javax.imageio.ImageIO;
import javax.sound.sampled.Clip;


public class ImageLoader 
{

// method for loading the images
public static BufferedImage loadImage(String strPath)
{
try 
{
System.out.println(strPath);
return ImageIO.read(ImageLoader.class.getResource(strPath));
} 
catch (IOException obj) 
{
obj.printStackTrace();
System.exit(1);
}
return null;

}
// method for loading the sound
public static Clip loadMusic(String dir)
{
try
{
Clip clp = AudioSystem.getClip();
clp.open(AudioSystem.getAudioInputStream(ImageLoader.class.getResource(dir)));
return clp;
}
catch(Exception obj)
{
obj.printStackTrace();
}
return null;
}
}

FileName: Shape.java

// important import statements
import java.awt.image.BufferedImage;
import java.awt.Graphics;


public class Shape 
{

// various fields of the class Shape
private int color;

private int x;
private int y; 

private long time;
private long lastTime;

private int nrml = 600;
private int fst = 50;

private int del;

private BufferedImage blk;

private int[][] coordinates;

private int[][] ref;

private int delX;

private Board brd;

// if the tetromino is collided, then the flag is true, otherwise false
private boolean isCollided = false;
private boolean movX = false;

public Shape(int[][] coordinates, BufferedImage blk, Board brd, int color)
{
// constructor for initializing the fields
this.coordinates = coordinates;
this.blk = blk;
this.brd = brd;
this.color = color;
delX = 0;
x = 4;
y = 0;
del = nrml;
time = 0;
lastTime = System.currentTimeMillis();
ref = new int[coordinates.length][coordinates[0].length];

System.arraycopy(coordinates, 0, ref, 0, coordinates.length);

}

public void update()
{
// statements for moving the Tetrominoes from top to bottom
movX = true;
time = time + System.currentTimeMillis() - lastTime;
lastTime = System.currentTimeMillis();

// if the collision is true, then the position of the tetromino that
// has fallen down recently, should be fixed on the playing area of the board
if(isCollided)
{
for(int r = 0; r < coordinates.length; r++)
{
for(int c = 0; c < coordinates[0].length; c++)
{
if(coordinates[r][c] != 0)
{
brd.getBoard()[y + r][x + c] = color;
}
}
}

// after the position of the recently fell tetromino is fixed
// we will determine the current shape that is going to fall down
// also we will check for the completed lines (or rows). 
checkLine();
brd.setCurrShape();

}



// if we press the left arrow key or the right arrow key the
// tetrominoes should move in the left or the right direction
// In the if condition there are two sub conditions that are joined with &&
// The first sub-condition is to check whether the tetrominoes is not going beyond the 
// right side boundary and the second sub condition is for the left side boundary
// The following code snippet will not work if the flag isCollided is true
if(!(x + delX + coordinates[0].length > 10) && !(x + delX < 0))
{

// if the falling tetromino has reached the bottom or has
// collided with the other tetromino then the tetromino should not move
// hence movX is false
for(int r = 0; r < coordinates.length; r++)
{
for(int c = 0; c < coordinates[r].length; c++)
{
if(coordinates[r][c] != 0)
{
if(brd.getBoard()[y + r][x + delX + c] != 0)
{
movX = false;
}

}
}
}

if(movX)
{
// if move x is true, then we can move the tetromino 
// in the left and the right direction
x = x + delX;
}

}

if(!(y + 1 + coordinates.length > 20))
{

for(int r = 0; r < coordinates.length; r++)
{
for(int c = 0; c < coordinates[r].length; c++)
{
if(coordinates[r][c] != 0)
{	
if(brd.getBoard()[y + 1 + r][x +  c] != 0)
{
// if the control reaches here, then it means
// the the falling tetromino has collided with the other 
// tetromino
isCollided = true;
}
}
}
}

if(time > del)
{
y = y + 1;
time = 0;
}
}
else
{
// if the control reaches here it means
// the tetromino has collided with the bottom 
// area of the board
isCollided = true;
}

delX = 0;
}

public void render(Graphics gr)
{

for(int r = 0; r < coordinates.length; r++)
{
for(int col = 0; col < coordinates[0].length; col ++)
{
if(coordinates[r][col] != 0)
{
// for drawing the image of the falling tetromino on the playing area
gr.drawImage(blk, col * 30 + x * 30, r * 30 + y * 30, null);	
}
}		
}

for(int r = 0; r < ref.length; r++)
{
for(int c = 0; c < ref[0].length; c++)
{
if(ref[r][r] != 0)
{
gr.drawImage(blk, c * 30 + 320, r * 30 + 160, null);	
}	

}

}

}

// a method that checks for the completed (rows or lines)
// if it finds the completed rows / lines it deletes those lines.
private void checkLine()
{
int size = brd.getBoard().length - 1;

for(int i = brd.getBoard().length - 1; i > 0; i--)
{
int count = 0;
for(int j = 0; j < brd.getBoard()[0].length; j++)
{
if(brd.getBoard()[i][j] != 0)
{
// computing the block count that
// are filled with the tetromino
count = count + 1;
}

brd.getBoard()[size][j] = brd.getBoard()[i][j];
}
if(count < brd.getBoard()[0].length)
{
// deleting the completed row or line
size  = size - 1;

}

// if all the blocks of a row is filled with the 
// parts of tetrominoes, then we increment the score by 1
if(count == brd.getBoard()[0].length)
{
brd.addScore();
}
}
}

// a method that handles the scenario, when we press the upward
// key
public void rotateShape()
{

int[][] rotatedShape = null;

rotatedShape = transposeMatrix(coordinates);

rotatedShape = reverseRows(rotatedShape);

if((x + rotatedShape[0].length > 10) || (y + rotatedShape.length > 20))
{
return;
}

for(int row = 0; row < rotatedShape.length; row++)
{
for(int col = 0; col < rotatedShape[row].length; col ++)
{
if(rotatedShape[row][col] != 0)
{
if(brd.getBoard()[y + row][x + col] != 0)
{
return;
}
}
}
}
coordinates = rotatedShape;
}


// The method comes into picture, when the up arrow is pressed
// The method does transpose of the matrix
private int[][] transposeMatrix(int[][] mtrx)
{
int[][] tmp = new int[mtrx[0].length][mtrx.length];
for (int i = 0; i < mtrx.length; i++)
{
for (int j = 0; j < mtrx[0].length; j++)
{
tmp[j][i] = mtrx[i][j];
}
}
return tmp;
}


// a method for reversing the rows of the matrix mtrx
private int[][] reverseRows(int[][] mtrx)
{

int mdle = mtrx.length / 2;


for(int i = 0; i < mdle; i++)
{
int[] tmp = mtrx[i];

mtrx[i] = mtrx[mtrx.length - i - 1];
mtrx[mtrx.length - i - 1] = tmp;
}

return mtrx;

}


// a method for retrieving the color
public int getColor()
{
return color;
}

public void setDeltaX(int delX)
{
this.delX = delX;
}

// for speeding up the 
// falling speed of the tetrominoes
public void speedUp()
{
del = fst;
}

// for normal falling speed of the tetrominoes 
public void speedDown()
{
del = nrml;
}

public BufferedImage getBlock()
{
return blk;
}

public int[][] getCoords()
{
return coordinates;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}
}

Steps to Compile and Run the Game

The above-written program is not going to compile unless and until we provide assets to it. The audio file and the images have to be put along with the .java files. Observe the following.

The Window.java file contains the main method. Therefore, it is the file we need compile. The file contains the code that invokes the constructor of the classes mentioned in the other files. Thus, compiling the Window.java file compiles the other files too. For running the game, use the command java Window. A few snapshots of the game is mentioned below.