Tetris Game using Java Swing

[R Ferreira]

I completed the final exercise from chapter 11 in the book "Learning Java through Games by Lubomir Stanchev".

I worked under the assumption that a block will only collide with another block or the edges of the screen if its not hidden, and I used blocks because after the Tetris shape hits the bottom of the screen, or another block, the Tetris(composed by four blocks) explodes(like in AutoCAD explode feature) and every block contained in the Tetris will be saved in an ArrayList that gets constantly iterated in search for a completed row. This was my way of implementing it, using what I've learned so far about OOP.

The main class, that just adds the frame and runs the program.

import java.awt.EventQueue;

/*
 * Create a version of the Tetris game. Different shapes
 * can fall from the top of the screen. Allow the player to
 * move the shapes using the arrow keys. Each shape should
 * consist of four blocks, where the possible shapes are
 * shown in Figure 11.3. Pressing the key Space should
 * rotate the shape. Pressing the down key should move the
 * shape down to its place. The playing area should be 10
 * blocks wide and 40 blocks high. When a horizontal line
 * becomes full, the line should be removed from the screen.
 * Feel free to create levels. For example, the user can
 * move to the next level after removing 10 lines. As the
 * levels increase, the bricks should drop faster. Create
 * a way to score the performance of the player and display
 * the score in the top right corner of the screen outside
 * the playing area. The game ends when the playing area is
 * full and a shape cannot drop from the top of the screen.
 */

class Project {
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				TetrisFrame frame = new TetrisFrame();
			}
		});
	}
}

The Frame class, that adds the panel and sets the size of the window and the playing area.

import javax.swing.*;

public class TetrisFrame extends JFrame {
	public static final int WIDTH = 156;	//10 blocks wide (10 * 15 = 150 + 6 from window)
	public static final int HEIGHT = 628;	//40 blocks high (40 * 15 = 600 + 28 from window)
	
	TetrisPanel panel = new TetrisPanel();
	
	TetrisFrame() {
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setSize(WIDTH, HEIGHT);
		setResizable(false);
		setVisible(true);
		add(panel);
	}
}

The Block class. Since a Tetris shape contains four blocks, I created this class, attempting a bottoms-up design. Only thing tricky about this class are the virtual future block methods, in which I return a block with new coordinates in the direction I want to move it(left, right or down), in order to intersect the virtual block with any other block before they overlap each other.

import java.awt.*;
import java.awt.geom.*;

public class Block {
	public static final int SIZE = 15;
	private RectangularShape shape;
	private Color color;
	private boolean active;
	private TetrisPanel panel;
	
	Block(double x, double y, Color color, TetrisPanel panel) {
		shape = new Rectangle2D.Double(x, y, SIZE, SIZE);
		this.color = color;
		active = true;
		this.panel = panel;
	}
	
	//virtual future block one block below 
	public Block futureDownPosition() {
		return new Block(shape.getX(), shape.getY() + shape.getHeight(), color, panel);
	}
	
	//virtual future block one block to the left
	public Block futureLeftPosition() {
		return new Block(shape.getX() - shape.getWidth(), shape.getY(), color, panel);
	}
	
	//virtual future block one block to the right
	public Block futureRightPosition() {
		return new Block(shape.getX() + shape.getWidth(), shape.getY(), color, panel);
	}
	
	protected boolean isActive() {
		return active;
	}
	
	protected double getX() {
		return shape.getX();
	}
	
	protected double getY() {
		return shape.getY();
	}
	
	protected void display() {
		if (! active) {
			active = true;
		}
	}
	
	protected void hide() {
		if (active) {
			active = false;
		}
	}
	
	protected boolean intersects(Block other) {
		if (active) {
			return shape.intersects((Rectangle2D.Double) other.shape);
		} else {
			//if the block is hidden
			return false;
		}
	}
	
	public void moveLeft() {
		shape.setFrame(shape.getX() - SIZE, shape.getY(), shape.getWidth(), shape.getHeight());
	}
	
	public void moveRight() {
		shape.setFrame(shape.getX() + SIZE, shape.getY(), shape.getWidth(), shape.getHeight());
	}
	
	public void moveDown() {
		shape.setFrame(shape.getX(), shape.getY() + shape.getHeight(), shape.getWidth(), shape.getHeight());
	}
	
	public boolean isNotAtScreenBottom() {
		//if the block is not already at the bottom of the screen
		return (shape.getMaxY() + shape.getHeight()) <= panel.getHeight();
	}
	
	public boolean isNotAtScreenLeftLimit() {
		//if the block is not already at the left edge of the screen
		return shape.getMinX() - shape.getWidth() >= 0;
	}
	
	public boolean isNotAtScreenRightLimit() {
		//if the block is not already at the right edge of the screen
		return shape.getMaxX() + shape.getWidth() <= panel.getWidth();
	}
	
	public void draw(Graphics2D g2) {
		//if its not hidden
		if (active) {
			g2.setColor(color);
			g2.fill(shape);
		}
	}
}

The TetrisShape class, which is the abstract class from which all other shapes will be created. This class works a lot like the Block class, only 10 times more difficult, because it works with a two dimension array of blocks. The same methods as the Block class just iterate the array and call the Block methods with the same name, like, hide(), draw(), move(), etc.. The intersect method iterates all the active blocks in the TetrisShape and checks if any of them intersect with another Block (not another TetrisShape, because the Tetris will be transformed into blocks after the player no longer controls them). I spend a lot of time in this class, because of a shallow copy problem with the virtual future Tetris shapes, I tried to used the cloneable interface but failed, so I tried something easier: iterate the Tetris, looking for all the blocks that are active, and save them into an ArrayList, then, I can change the coordinates of the blocks, moving them in any direction.. Created methods that receive an ArrayList to work around the shallow copy issue. Also, for the rotation of the Tetris, I rotate it, then I save the active blocks in a new ArrayList, and return the original Tetris to its previous rotation. I then use the copy of the future rotation of the Tetris to check for collisions. All Tetris share the same methods, except the ones that display and rotate the shape, so I made those abstract.

import java.awt.*;
import java.util.ArrayList;

public abstract class TetrisShape {
	public static final int SIZE = 15;
	public static final int START_X = 3;	//start middle of the screen
	public static final int START_Y = 1;	//start at row 1 so it doesn't overlap the score message 
	public static final int MAX_ROWS = 4;
	public static final int MAX_COLUMNS = 4;
	
	protected Block[][] space;
	protected Color color;
	protected TetrisPanel panel;
	
	TetrisShape(Color color, TetrisPanel panel) {
		space = new Block[MAX_ROWS][MAX_COLUMNS];
		this.color = color;
		this.panel = panel;
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				space[row][column] = new Block(((row + START_X) * SIZE), ((column + START_Y) * SIZE), color, panel);
				space[row][column].hide();
			}
		}
		
		displayRandomRotation();
	}

	protected abstract void displayRotationOne();
	
	protected abstract boolean isRotationOneActive();
	
	protected abstract void displayRotationTwo();
	
	protected abstract boolean isRotationTwoActive();
	
	protected abstract void displayRotationThree();
	
	protected abstract boolean isRotationThreeActive();
	
	protected abstract void displayRotationFour();
	
	protected abstract boolean isRotationFourActive();
	
	public abstract void nextRotation();
	
	protected void displayRandomRotation() {
		double randomDouble = Math.random();
		if (randomDouble < 0.25) {
			displayRotationOne();
		} else if (randomDouble < 0.5) {
			displayRotationTwo();
		} else if (randomDouble < 0.75) {
			displayRotationThree();
		} else {
			displayRotationFour();
		}
	}
	
	public void previousRotation() {
		if (isRotationOneActive()) {
			hide();
			displayRotationFour();
		} else if (isRotationTwoActive()) {
			hide();
			displayRotationOne();
		} else if (isRotationThreeActive()) {
			hide();
			displayRotationTwo();
		} else if (isRotationFourActive()) {
			hide();
			displayRotationThree();
		}
	}
	
	protected void hide() {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				space[row][column].hide();
			}
		}
	}
	
	public boolean isNotAtScreenBottom() {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				//only check those blocks that aren't hidden
				if (space[row][column].isActive()) {
					//if one of the bricks is at bottom of the screen
					if (! space[row][column].isNotAtScreenBottom()) {
						return false;
					}
				}
			}
		}
		return true;
	}
	
	protected boolean isNotAtScreenBottom(ArrayList<Block> virtualBlocks) {
		for (Block block : virtualBlocks) {
			//only check those blocks that aren't hidden
			if (block.isActive()) {
				//if one of the bricks is at the bottom of the screen
				if (! block.isNotAtScreenBottom()) {
					return false;
				}
			}
		}
		//no bricks on the virtual down shape are at the bottom
		return true;
	}
	
	public boolean isNotAtScreenLeftLimit() {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				//only check those blocks that aren't hidden
				if (space[row][column].isActive()) {
					//if one of the bricks is at the screen left limit
					if (! space[row][column].isNotAtScreenLeftLimit()) {
						return false;
					}
				}
			}
		}
		return true;
	}
	
	protected boolean isNotAtScreenLeftLimit(ArrayList<Block> virtualBlocks) {
		for (Block block : virtualBlocks) {
			//only check those blocks that aren't hidden
			if (block.isActive()) {
				//if one of the bricks is at the screen left limit
				if (! block.isNotAtScreenLeftLimit()) {
					return false;
				}
			}
		}
		//no bricks on the virtual left shape are at the screen left limit
		return true;
	}
	
	public boolean isNotAtScreenRightLimit() {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				//only check those blocks that aren't hidden
				if (space[row][column].isActive()) {
					//if one of the bricks is at the screen right limit
					if (! space[row][column].isNotAtScreenRightLimit()) {
						return false;
					}
				}
			}
		}
		return true;
	}
	
	protected boolean isNotAtScreenRightLimit(ArrayList<Block> virtualBlocks) {
		for (Block block : virtualBlocks) {
			//only check those blocks that aren't hidden
			if (block.isActive()) {
				//if one of the bricks is at the screen right limit
				if (! block.isNotAtScreenRightLimit()) {
					return false;
				}
			}
		}
		//no bricks on the virtual right shape are at the screen right limit
		return true;
	}
	
	public void moveLeft() {
		if (isNotAtScreenLeftLimit()) {
			for (int row = 0; row < MAX_ROWS; row++) {
				for (int column = 0; column < MAX_COLUMNS; column++) {
					space[row][column].moveLeft();
				}
			}
		}
	}
	
	public void moveRight() {
		if (isNotAtScreenRightLimit()) {
			for (int row = 0; row < MAX_ROWS; row++) {
				for (int column = 0; column < MAX_COLUMNS; column++) {
					space[row][column].moveRight();					
				}
			}
		}
	}
	
	public void moveDown() {
		if (isNotAtScreenBottom()) {
			for (int row = 0; row < MAX_ROWS; row++) {
				for (int column = 0; column < MAX_COLUMNS; column++) {
					space[row][column].moveDown();
				}
			}
		}
	}
	
	//if one block from this shape intercepts any other block
	public boolean intercepts(Block other) {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				if (space[row][column].isActive()) {
					if (space[row][column].intersects(other)) {
						return true;
					}
				}
			}
		}
		return false;
	}
	
	public ArrayList<Block> virtualDownPosition() {
		ArrayList<Block> virtualBlocks = activeBlocks();
		for (Block block : virtualBlocks) {
			block.moveDown();
		}
		return virtualBlocks;
	}
	
	public ArrayList<Block> virtualLeftPosition() {
		ArrayList<Block> virtualBlocks = activeBlocks();
		for (Block block : virtualBlocks) {
			block.moveLeft();
		}
		return virtualBlocks;
	}
	
	public ArrayList<Block> virtualRightPosition() {
		ArrayList<Block> virtualBlocks = activeBlocks();
		for (Block block : virtualBlocks) {
			block.moveRight();
		}
		return virtualBlocks;
	}
	
	public ArrayList<Block> virtualNextRotation() {
		nextRotation();
		ArrayList<Block> virtualBlocks = activeBlocks();
		previousRotation();
		return virtualBlocks;
	}
	
	//returns only the blocks that are active in the shape
	public ArrayList<Block> activeBlocks() {
		ArrayList<Block> activeBlocks = new ArrayList<Block>();
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				if (space[row][column].isActive()) {
					activeBlocks.add(new Block(space[row][column].getX(), space[row][column].getY(), color, panel));
				}
			}
		}
		return activeBlocks;
	}
	
	public void draw(Graphics2D g2) {
		for (int row = 0; row < MAX_ROWS; row++) {
			for (int column = 0; column < MAX_COLUMNS; column++) {
				space[row][column].draw(g2);
			}
		}
	}

}

The TetrisShapeI class, which was the first I implemented and also the hardest, since its the largest one. Since I'm working with a 4x4 array even when the shape is only 1x4 or 4x1, I had to spend a little time on the method to rotate the shape, in order to prevent the shape from rotating and going out of bounds or colliding with another block.

import java.awt.Color;

public class TetrisShapeI extends TetrisShape {

	TetrisShapeI(Color color, TetrisPanel panel) {
		super(color, panel);
	}
	
	protected void displayRotationOne() {
		space[0][1].display();
		space[1][1].display();
		space[2][1].display();
		space[3][1].display();
	}
	
	protected boolean isRotationOneActive() {
		return (space[0][1].isActive() && space[1][1].isActive() && space[2][1].isActive() && space[3][1].isActive());
	}
	
	protected void displayRotationTwo() {
		space[2][0].display();
		space[2][1].display();
		space[2][2].display();
		space[2][3].display();
	}
	
	protected boolean isRotationTwoActive() {
		return (space[2][0].isActive() && space[2][1].isActive() && space[2][2].isActive() && space[2][3].isActive());
	}
	
	protected void displayRotationThree() {
		space[0][2].display();
		space[1][2].display();
		space[2][2].display();
		space[3][2].display();
	}
	
	protected boolean isRotationThreeActive() {
		return (space[0][2].isActive() && space[1][2].isActive() && space[2][2].isActive() && space[3][2].isActive());
	}
	
	protected void displayRotationFour() {
		space[1][0].display();
		space[1][1].display();
		space[1][2].display();
		space[1][3].display();
	}
	
	protected boolean isRotationFourActive() {
		return (space[1][0].isActive() && space[1][1].isActive() && space[1][2].isActive() && space[1][3].isActive());
	}
	
	public void nextRotation() {
		if (isRotationOneActive()) {
			//if the current shape is not at the bottom of the screen AND the virtual down position is not at the bottom either
			if (isNotAtScreenBottom() && isNotAtScreenBottom(virtualDownPosition())) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenLeftLimit() && isNotAtScreenRightLimit() && isNotAtScreenLeftLimit(virtualLeftPosition())) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationFour();
			}
		} else if (isRotationFourActive()) {
			if (isNotAtScreenLeftLimit() && isNotAtScreenRightLimit() && isNotAtScreenRightLimit(virtualRightPosition())) {
				hide();
				displayRotationOne();
			}
		}
	}
	
}

The TetrisShapeT class

import java.awt.Color;

public class TetrisShapeT extends TetrisShape {

	TetrisShapeT(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[1][1].display();
		space[2][1].display();
		space[3][1].display();
		space[2][2].display();
	}

	protected boolean isRotationOneActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[3][1].isActive() && space[2][2].isActive());
	}

	protected void displayRotationTwo() {
		space[2][0].display();
		space[1][1].display();
		space[2][1].display();
		space[2][2].display();
	}

	protected boolean isRotationTwoActive() {
		return (space[2][0].isActive() && space[1][1].isActive() && space[2][1].isActive() && space[2][2].isActive());
	}

	protected void displayRotationThree() {
		space[2][0].display();
		space[1][1].display();
		space[2][1].display();
		space[3][1].display();
	}

	protected boolean isRotationThreeActive() {
		return (space[2][0].isActive() && space[1][1].isActive() && space[2][1].isActive() && space[3][1].isActive());
	}

	protected void displayRotationFour() {
		space[2][0].display();
		space[2][1].display();
		space[3][1].display();
		space[2][2].display();
	}

	protected boolean isRotationFourActive() {
		return (space[2][0].isActive() && space[2][1].isActive() && space[3][1].isActive() && space[2][2].isActive());
	}
	
	public void nextRotation() {
		if (isRotationOneActive()) {
			//if the current shape is not at the bottom of the screen
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenRightLimit()) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			//if the current shape is not at the bottom of the screen or the row before
			if (isNotAtScreenBottom() && isNotAtScreenBottom(virtualDownPosition())) {
				hide();
				displayRotationFour();
			}
		} else if (isRotationFourActive()) {
			if (isNotAtScreenLeftLimit()) {
				hide();
				displayRotationOne();
			}
		}
	}

}

The TetrisShapeO class

import java.awt.Color;

public class TetrisShapeO extends TetrisShape {

	TetrisShapeO(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[1][1].display();
		space[2][1].display();
		space[1][2].display();
		space[2][2].display();
	}

	protected boolean isRotationOneActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	protected void displayRotationTwo() {
		space[1][1].display();
		space[2][1].display();
		space[1][2].display();
		space[2][2].display();		
	}

	protected boolean isRotationTwoActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	protected void displayRotationThree() {
		space[1][1].display();
		space[2][1].display();
		space[1][2].display();
		space[2][2].display();		
	}

	protected boolean isRotationThreeActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	protected void displayRotationFour() {
		space[1][1].display();
		space[2][1].display();
		space[1][2].display();
		space[2][2].display();		
	}

	protected boolean isRotationFourActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	public void nextRotation() {
		if (isRotationOneActive()) {
			hide();
			displayRotationTwo();
		} else if (isRotationTwoActive()) {
			hide();
			displayRotationThree();
		} else if (isRotationThreeActive()) {
			hide();
			displayRotationFour();
		} else if (isRotationFourActive()) {
			hide();
			displayRotationOne();
		}
	}

}

The TetrisShapeL class

import java.awt.Color;

public class TetrisShapeL extends TetrisShape {

	TetrisShapeL(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[1][0].display();
		space[1][1].display();
		space[1][2].display();
		space[2][2].display();
	}

	protected boolean isRotationOneActive() {
		return (space[1][0].isActive() && space[1][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	protected void displayRotationTwo() {
		space[1][1].display();
		space[2][1].display();
		space[3][1].display();
		space[1][2].display();
	}

	protected boolean isRotationTwoActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[3][1].isActive() && space[1][2].isActive());
	}

	protected void displayRotationThree() {
		space[1][1].display();
		space[2][1].display();
		space[2][2].display();
		space[2][3].display();
	}

	protected boolean isRotationThreeActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[2][2].isActive() && space[2][3].isActive());
	}

	protected void displayRotationFour() {
		space[0][2].display();
		space[1][2].display();
		space[2][2].display();
		space[2][1].display();
	}
	
	protected boolean isRotationFourActive() {
		return (space[0][2].isActive() && space[1][2].isActive() && space[2][2].isActive() && space[2][1].isActive());
	}

	public void nextRotation() {
		if (isRotationOneActive()) {
			if (isNotAtScreenRightLimit()) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			if (isNotAtScreenLeftLimit()) {
				hide();
				displayRotationFour();
			}
		} else if (isRotationFourActive()) {
			hide();
			displayRotationOne();
		}
	}

}

The TetrisShapeJ class

import java.awt.Color;

public class TetrisShapeJ extends TetrisShape {

	TetrisShapeJ(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[2][0].display();
		space[2][1].display();
		space[2][2].display();
		space[1][2].display();
	}

	protected boolean isRotationOneActive() {
		return (space[2][0].isActive() && space[2][1].isActive() && space[2][2].isActive() && space[1][2].isActive());
	}

	protected void displayRotationTwo() {
		space[1][1].display();
		space[1][2].display();
		space[2][2].display();
		space[3][2].display();
	}

	protected boolean isRotationTwoActive() {
		return (space[1][1].isActive() && space[1][2].isActive() && space[2][2].isActive() && space[3][2].isActive());
	}

	protected void displayRotationThree() {
		space[2][1].display();
		space[1][1].display();
		space[1][2].display();
		space[1][3].display();
	}

	protected boolean isRotationThreeActive() {
		return (space[2][1].isActive() && space[1][1].isActive() && space[1][2].isActive() && space[1][3].isActive());
	}

	protected void displayRotationFour() {
		space[0][1].display();
		space[1][1].display();
		space[2][1].display();
		space[2][2].display();
	}

	protected boolean isRotationFourActive() {
		return (space[0][1].isActive() && space[1][1].isActive() && space[2][1].isActive() && space[2][2].isActive());
	}

	public void nextRotation() {
		if (isRotationOneActive()) {
			if (isNotAtScreenRightLimit()) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			if (isNotAtScreenLeftLimit()) {
				hide();
				displayRotationFour();
			}
		} else if (isRotationFourActive()) {
			hide();
			displayRotationOne();
		}
	}

}

The TetrisShapeS class

import java.awt.Color;

public class TetrisShapeS extends TetrisShape {

	TetrisShapeS(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[1][2].display();
		space[2][2].display();
		space[2][1].display();
		space[3][1].display();
	}

	protected boolean isRotationOneActive() {
		return (space[1][2].isActive() && space[2][2].isActive() && space[2][1].isActive() && space[3][1].isActive());
	}

	protected void displayRotationTwo() {
		space[1][1].display();
		space[1][2].display();
		space[2][2].display();
		space[2][3].display();
	}

	protected boolean isRotationTwoActive() {
		return (space[1][1].isActive() && space[1][2].isActive() && space[2][2].isActive() && space[2][3].isActive());
	}

	protected void displayRotationThree() {
		space[0][2].display();
		space[1][2].display();
		space[1][1].display();
		space[2][1].display();
	}

	protected boolean isRotationThreeActive() {
		return (space[0][2].isActive() && space[1][2].isActive() && space[1][1].isActive() && space[2][1].isActive());
	}

	protected void displayRotationFour() {
		space[1][0].display();
		space[1][1].display();
		space[2][1].display();
		space[2][2].display();
	}

	protected boolean isRotationFourActive() {
		return (space[1][0].isActive() && space[1][1].isActive() && space[2][1].isActive() && space[2][2].isActive());
	}

	public void nextRotation() {
		if (isRotationOneActive()) {
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenLeftLimit()) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			hide();
			displayRotationFour();
		} else if (isRotationFourActive()) {
			if (isNotAtScreenRightLimit()) {
				hide();
				displayRotationOne();
			}
		}
	}

}

The TetrisShapeZ class

import java.awt.Color;

public class TetrisShapeZ extends TetrisShape {

	TetrisShapeZ(Color color, TetrisPanel panel) {
		super(color, panel);
	}

	protected void displayRotationOne() {
		space[1][1].display();
		space[2][1].display();
		space[2][2].display();
		space[3][2].display();
	}

	protected boolean isRotationOneActive() {
		return (space[1][1].isActive() && space[2][1].isActive() && space[2][2].isActive() && space[3][2].isActive());
	}

	protected void displayRotationTwo() {
		space[2][1].display();
		space[2][2].display();
		space[1][2].display();
		space[1][3].display();
	}

	protected boolean isRotationTwoActive() {
		return (space[2][1].isActive() && space[2][2].isActive() && space[1][2].isActive() && space[1][3].isActive());
	}

	protected void displayRotationThree() {
		space[0][1].display();
		space[1][1].display();
		space[1][2].display();
		space[2][2].display();
	}

	protected boolean isRotationThreeActive() {
		return (space[0][1].isActive() && space[1][1].isActive() && space[1][2].isActive() && space[2][2].isActive());
	}

	protected void displayRotationFour() {
		space[2][0].display();
		space[2][1].display();
		space[1][1].display();
		space[1][2].display();
	}

	protected boolean isRotationFourActive() {
		return (space[2][0].isActive() && space[2][1].isActive() && space[1][1].isActive() && space[1][2].isActive());
	}

	public void nextRotation() {
		if (isRotationOneActive()) {
			if (isNotAtScreenBottom()) {
				hide();
				displayRotationTwo();
			}
		} else if (isRotationTwoActive()) {
			if (isNotAtScreenLeftLimit()) {
				hide();
				displayRotationThree();
			}
		} else if (isRotationThreeActive()) {
			hide();
			displayRotationFour();
		} else if (isRotationFourActive()) {
			if (isNotAtScreenRightLimit()) {
				hide();
				displayRotationOne();
			}
		}
	}

}

The panel class, where the game loop is and all the methods and variables to make it work.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.Rectangle2D;
import java.util.*;

public class TetrisPanel extends JPanel {
	public static final int MAX_ROWS = 40;
	public static final int MAX_COLUMNS = 10;
	
	//every time a line is completed
	public static final int SCORE_LINE_COMPLETED = 1000;
	//every time a shape is dropped
	public static final int SCORE_SHAPE_PLACED = 10;
	
	javax.swing.Timer timer;
	int timerDelay;
	ArrayList<Block> blocks;
	TetrisShape shape;
	String endGameMessage;
	int score;
	int level;
	int completedLines;
	
	TetrisPanel() {
		setFocusable(true);
		
		addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_LEFT) {
					//if left of the shape is not another shape
					if (! intercepts(shape.virtualLeftPosition())) {
						shape.moveLeft();
						//delete line if its complete after you move the piece
						ifLineIsComplete();
					}
				}
				if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
					//if right of the shape is not another shape
					if (! intercepts(shape.virtualRightPosition())) {
						shape.moveRight();
						//delete line if its complete after you move the piece
						ifLineIsComplete();
					}
				}
				if (e.getKeyCode() == KeyEvent.VK_DOWN) {
					//if below the shape is not another shape
					if (! intercepts(shape.virtualDownPosition())) {
						shape.moveDown();
						//delete line if its complete after you move the piece
						ifLineIsComplete();
					}
				}
				if (e.getKeyCode() == KeyEvent.VK_SPACE) {
					//if the next rotation doesn't collide with anything
					if (! intercepts(shape.virtualNextRotation())) {
						shape.nextRotation();
						//delete line if its complete after you rotate the piece
						ifLineIsComplete();
					}
				}
				repaint();
			}
		});
		
		startGame();
	}
	
	private void startGame() {
		timerDelay = 1000;	//1 second (speed of the falling shape)
		timer = new javax.swing.Timer(timerDelay, new TimeListener());
		blocks = new ArrayList<Block>();
		endGameMessage = "";
		score = 0;
		completedLines = 0;
		level = 1;
		
		shape = createRandomShape();
				
		timer.start();
	}
	
	private TetrisShape createRandomShape() {
		//create a new shape to fall from the top
		TetrisShape fallingShape = null;
		double randomDouble = Math.random();
		
		if (randomDouble < 0.145) {
			fallingShape = new TetrisShapeO(Color.RED, this);
		} else if (randomDouble < 0.29) {
			fallingShape = new TetrisShapeT(Color.BLUE, this);
		} else if (randomDouble < 0.435) {
			fallingShape = new TetrisShapeL(Color.PINK, this);
		} else if (randomDouble < 0.58) {
			fallingShape = new TetrisShapeJ(Color.GREEN, this);
		} else if (randomDouble < 0.725) {
			fallingShape = new TetrisShapeS(Color.CYAN, this);
		} else if (randomDouble < 0.87) {
			fallingShape = new TetrisShapeZ(Color.DARK_GRAY, this);
		} else if (randomDouble < 1 ) {	//less chance to spawn (only 12%)
			fallingShape = new TetrisShapeI(Color.ORANGE, this);
		}
		return fallingShape;
	}
	
	private void addCurrentShapeToList() {
		//add all the blocks from the current shape to the list of blocks
		blocks.addAll(shape.activeBlocks());
		//then, create a new shape to fall from the top
		shape = createRandomShape();
	}
	
	//returns true if the virtual future position of the shape intercepts any block
	private boolean intercepts(ArrayList<Block> virtualBlocks) {
		//iterate the list of blocks
		for (Block block : blocks) {
			//iterate the blocks in the virtual shape
			for (Block virtualBlock : virtualBlocks) {
				if (block.intersects(virtualBlock)) {
					return true;
				}
			}
		}
		
		//the blocks in the virtual future shape doesn't intercept any block on the screen
		return false;
	}
	
	private boolean lineIsFull(ArrayList<Block> blocksInRow) {		
		//if the number of blocks in the row is equal to the max number of possible blocks
		if (blocksInRow.size() == MAX_COLUMNS) {
			//get every block from the row
			for (Block block : blocksInRow) {
				//if any block in the row is hidden
				if (! block.isActive()) {
					//the line is not full
					return false;
				}
			}
			//the line is full
			return true;
		}
		//the line is not full
		return false;
	}
	
	private boolean isAnyBlockInRow(int row) {
		//if there are no blocks on the list
		if (blocks.isEmpty()) {
			return false;
		}
		//iterate the list of blocks
		for (Block block : blocks) {
			//if there is at least one block on that row
			if (block.getY() == row) {
				return true;
			}
		}
		//if there are no blocks on the list on that row
		return false;		
	}
	
	private ArrayList<Block> getBlocksInRow(int row) {
		//create the arrayList which will contain the blocks in the row
		ArrayList<Block> blocksInRow = new ArrayList<Block>();
		//if there is a block in the row
		if (isAnyBlockInRow(row)) {
			//iterate the list of blocks
			for (Block block : blocks) {
				//if there is a block in the list of blocks, that is located in the row
				if (block.getY() == row) {
					blocksInRow.add(block);
				}
			}
		}
		return blocksInRow;
	}
	
	private void removeLine(int row) {
		for (Block block : blocks) {
			//hide all the blocks from that row
			if (block.getY() == row) {
				block.hide();
			}
		}
	}
	
	private void moveDownAllBlocksAbove(int row) {
		for (Block block : blocks) {
			//if the block is below the row
			if (block.getY() > row) {
				//skip to the next cycle
				continue;
			}
			//move the block one position down
			block.moveDown();
		}
	}
	
	private boolean isGameOver() {
		//check if any of the first six rows are occupied
		for (int row = 0; row < 6; row++) {
			//get the blocks in the rows where the falling shape is created
			ArrayList<Block> blocksInRow = getBlocksInRow(TetrisShape.SIZE * row);
			
			for (Block block : blocksInRow) {
				//if any of the starting blocks are occupied, then the game is over
				if (block.getX() == (TetrisShape.SIZE * 3)) {
					return true;
				}
				if (block.getX() == (TetrisShape.SIZE * 4)) {
					return true;
				}
				if (block.getX() == (TetrisShape.SIZE * 5)) {
					return true;
				}
				if (block.getX() == (TetrisShape.SIZE * 6)) {
					return true;
				}
			}
		}
		//the game is not over yet
		return false;
	}
	
	private void increaseScore() {
		score += SCORE_SHAPE_PLACED * level;
	}
	
	private void increaseLevel() {
		level++;
		timerDelay /= 2;
		timer.setDelay(timerDelay);
	}
	
	private void showMessageCenter(String str, Graphics2D g2) {
		Font myFont = new Font("SansSerif", Font.BOLD, 20);
		g2.setColor(Color.BLACK);
		g2.setFont(myFont);
		Rectangle2D textBox = myFont.getStringBounds(str, g2.getFontRenderContext());
		g2.drawString(str, (int) (getWidth() / 2 - textBox.getWidth() / 2), (int) (getHeight() / 2));
	}
	
	private void showScore(Graphics2D g2) {
		String scoreStr = "Level: " + level + "           Score: " + score;
		Font myFont = new Font("SansSerif", Font.BOLD, 10);
		g2.setColor(Color.BLACK);
		g2.setFont(myFont);
		Rectangle2D textBox = myFont.getStringBounds(scoreStr, g2.getFontRenderContext());
		g2.drawString(scoreStr, 0, (int) textBox.getHeight());
	}
	
	private void ifLineIsComplete() {
		ArrayList<Integer> deletedRows = new ArrayList<Integer>();
		//search every row for a complete line
		for (int row = 0; row <= MAX_ROWS ; row++) {
			int currentRow = (TetrisShape.SIZE * row);
			//get all the blocks in the current row
			ArrayList<Block> blocksInRow = (getBlocksInRow(currentRow));
			//if there is a block in the row
			if (! blocksInRow.isEmpty()) {
				//if the line is full
				if (lineIsFull(blocksInRow)) {
					//delete the line
					removeLine(currentRow);
					//save the row coordinate that got deleted
					deletedRows.add(Integer.valueOf(currentRow));
					//increase score
					score += SCORE_LINE_COMPLETED;
					completedLines++;
					//when 10 lines get completed
					if ((completedLines % 10) == 0) {
						increaseLevel();
					}
				}
			}
		}
		
		for (Integer i : deletedRows) {
			//move one step down all the blocks above the deleted row
			moveDownAllBlocksAbove(i.intValue());
		}
	}
	
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2 = (Graphics2D) g;
		
		//draw the current shape
		shape.draw(g2);
		
		//draw all the shapes in the screen
		for (Block block: blocks) {
			block.draw(g2);
		}
		//draw the endGame message
		showMessageCenter(endGameMessage, g2);
		//draw score
		showScore(g2);
	}
	
	class TimeListener implements ActionListener {

		public void actionPerformed(ActionEvent e) {
			//if the game is over
			if (isGameOver()) {
				endGameMessage = "Game Over";
				//stop game
				timer.stop();
			}
			
			if (shape.isNotAtScreenBottom()) {
				//if below the shape is another block
				if (intercepts(shape.virtualDownPosition())) {
					addCurrentShapeToList();
					increaseScore();
				}
				
				shape.moveDown();
			} else {
				//when the shape hits the bottom of the screen
				addCurrentShapeToList();
				increaseScore();
			}
			
			//checks if a line is complete, if it is, it will delete it and
			//move down all the blocks above the line that was deleted and
			//increase the score appropriately
			ifLineIsComplete();
			
			//update everything on the screen
			repaint();
		}
	}
}

I invested about 30 hours to get this working, because I got stuck getting the collisions to work properly and the method to delete a line and move all the blocks above.. after the first shape was working, implementing the other 6 took me like 20 minutes. And they all worked well, in fact I could expand the game and add any 4x4 or smaller shape and it will work. If I were to improve this program, I would change the draw method in the Block class and choose a better looking block, maybe add an image and use that instead. Also, the game has no sound, does native Java handle sounds? either way, its out of my league at the moment lol.

[R Ferreira]

A picture of the game

[Rob Camick]

Interesting project. Tetris seems to be an interesting game to try to implement, I also did a basic implementation

Also, the game has no sound, does native Java handle sounds?

Here is a simple example that demonstrates how to play a .wav file:

import java.awt.event.*;
import javax.swing.*;
import javax.sound.sampled.*;
import java.net.URL;
import java.io.*;

class TestSound {

  public static void main(String[] args) throws Exception {
    URL urlToSound = new URL("file:c:/java/gun1.wav");
//    URL urlToSound = new URL("file:c:/java/flyby1.wav");
    AudioInputStream ais = AudioSystem.getAudioInputStream(urlToSound);
    final Clip clip = AudioSystem.getClip();
    clip.open(ais);
    JButton button = new JButton("Bird Sounds");
    button.addActionListener( new ActionListener(){
        public void actionPerformed(ActionEvent ae) {
          clip.setFramePosition(0);
          clip.start();
        }
      } );
    JOptionPane.showMessageDialog(null, button);
  }
}

[Rob Camick]

My implementation is similar to yours. It doesn't implement any game logic or provide increases in speed. It only contain 4 classes

1. TetrisIcon - custom painting of an Icon to represent a single block. It is designed to look like the Tetris block found on the Tetris game in Windows 7.

2. TetrisPiece - contains a 4x4 array indication which cell of the array should be painted. It also support a generic rotation algorithm to rotate any piece

3. TetrisBoard - contains the list of individual TetrisIcons to be painted. Also contains the current TestisPiece that can be rotated, moved left/right or dropped. Is also responsible for removed a row from the board when full

4. Tetris - create the game and add initial TetrisPiece to the TetrisBoard


This forum won' t allow me to post my code here since I use "r" as a variable in some of my looping code and the forums wants me to "speak English".

If you want to take a look at my code you can find it here: http://stackoverflow.com/questions/42517544/adding-additional-shapes-in-a-tetris-project-loop-logic-assistance/42518798#42518798

[R Ferreira]

oh, so it is a lot like loading an image.. so clip.setFramePosition(0) means replay the sound from the start right? I'll try that sample code in a minute. Thanks.

You are right, your implementation is a lot like mine.. You did a better job at drawing the block though, mine is pretty basic. Also, good idea with the rotation method, I hard coded my rotations, your implementation is far better, It didn't even cross my mind, switching rows for columns..
In your implementation, when a row is completed, it gets deleted, how did you solve the problem of moving all the Tetris icons above that row?  does it do it? move all blocks above?

I see this, yet is not that clear as to what this is doing, it re adds all the columns in the board, only they are displaced one position down? You should try to comment your code more, at least the tricky parts.

for (int i = 0; i < rowsRemoved; i++)
            board.add(0, new TetrisIcon[columns]);

[Rob Camick]

You should try to comment your code more, at least the tricky parts.

Yes, I just wrote the code for fun for myself so I wasn't to worried about documentation.

 when a row is completed, it gets deleted, how did you solve the problem of moving all the Tetris icons above that row?  

The first variable of the TetrisBoard class is the "board" variable which a List. Each item in the List represents a row of TetrisPieces.

When you delete a "row" from a List the items below that row move up one position in the List.  (ie. see the for loop above the code you pasted)

So the code you quoted then shows how I add an empty row back to the top of the List so the board always contains the specified number of rows.

So the net effect is the rows below the deleted rows move up and then all the rows move down after the empty rows have been added. Of course repaint() is only invoked once so you only see all the rows in the proper place.

[R Ferreira]

so your list stores rows of Tetris pieces, while mine stores every individual piece.. so what happens under the hood is, you delete a row in the middle, and all the rows below the row you deleted go up, but then you insert a new row at the top and every row gets pushed down to its proper place, right? so all your code has to do every tick is check if a row is completed, while mine has to determine which piece belongs to which row, and then check if the row is completed. Not that you ever notice any difference in the performance I guess. Its great how there can be so many different paths to program something.

[R Ferreira]

I remember playing Tetris years ago, on the handheld devices, there was a delay once a row was completed, the completed row flashed a couple of times in another color, and then it was deleted, you could also see the gap the row left for like half a second before all the other rows above would fall down. I was thinking about implementing that behavior, but I don't see how, the timer allows me to pause the game, but since the game loop is already inside the ActionListener, I don't think its possible, right?

[Rob Camick]

Its great how there can be so many different paths to program something.  

Which is one reason why I spend time answering questions. Always learning new/different ways to do things.

but I don't see how, the timer allows me to pause the game, but since the game loop is already inside the ActionListener, I don't think its possible, right?

If you have a reference to the Timer variable then you should be able to pause it. Somewhere in the game you must speed up the Timer when you move to a new level. So you should also be able to pause it and display fancy graphics before restarting.