Java 中的俄罗斯方块游戏

2025年3月17日 | 阅读 15 分钟

俄罗斯方块游戏是历史上最常见的电脑游戏之一。如今我们也可以在手机上玩这个游戏。这个游戏是由俄罗斯程序员 Alexey Pajitnov 于 1985 年设计并创作的。市面上出现了许多不同的俄罗斯方块变体。然而，在本教程中，我们将创建一个基础的俄罗斯方块游戏。

俄罗斯方块游戏是一款块状益智掉落游戏。在俄罗斯方块游戏中，我们总共有七种不同的形状，称为七格骨牌。这七种七格骨牌是直线形、Z 形、S 形、L 形、T 形、方形和镜像 L 形。所有提到的形状都只由四个正方形组成。这些形状会从棋盘上落下。玩俄罗斯方块游戏的玩家的目标是旋转和移动形状，以便尽可能多地将它们堆叠起来。如果形成了一个完整的行，该行将被消除，得分将增加。俄罗斯方块游戏会一直玩到玩家“顶出”（即方块堆积到顶端）为止。

文件名： 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();
}

}

文件名： 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();
}	
}

文件名： 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;
}

}

文件名： 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;
}
}

文件名： 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;
}
}