Java俄羅斯方塊目錄：

簡要分析：

俄羅斯方塊的規則在這裡就不細說了，大家都知道，控制方塊的移動，到底即停，當方塊能填滿一行時，便消除那一行的方塊，並計分...

我們將用JPanel來完成整個遊戲的製作。

首先我們來看看遊戲執行時的圖片。

（遊戲圖片 ）

上圖是遊戲製作過程中我截的一張圖片，從上圖中，我們可以把遊戲分為多個區域：

1）正在下落的四格方塊

2）下一個下落的四格方塊

3）遊戲有一個主場景區，即左邊的網格線區域

4）計分割槽，暫時還沒繪製

根據俄羅斯方塊的規則，我們知道，一個四格方塊，是可以左右和往下移動的，並且還能變換形狀。

然後我們在來看一張圖片：

（經典俄羅斯方塊的方塊形狀）

從上圖我們可以看出來，每個方塊都由四個小方格通過不同的排列組成，並且，我們可以把遊戲主場景區想象成用二維陣列來表示的區域，事實上，確實是用二維陣列來製作遊戲主區域。

在這裡，我們暫且把這個區域稱為------牆（Wall）

把每個小方格稱為------單元格（Cell）

每個不同的形狀其實就是4個單元格按不同順序組合而來，所以，我們可以用不同的座標來表示不同的形狀。

我們可以根據四格方塊的不同形狀，給他們一個名字：I，T，L，J，S，Z，O

所以，在這裡我們用面向物件的思想，分別定義Cell類，和七個四格方塊類。

Cell()類：

    共同特徵：行號，列號，圖片

    共同行為：向左，向右，向下移動，提供JavaBean相關規範，JavaBean規範就是程式設計師在定義類時，預設遵守的一種規範如：

1.     新增兩個構造器，無參，全參
2. 屬性一般都是私有化（封裝）
3. 提供公有（public）的get/set方法
4. 重寫toString()方法，toString方法預設返回地址資訊，重寫後用來描述屬性的資訊
5. 重寫equals方法和hashCode方法

import java.awt.image.BufferedImage;

/*
 * 俄羅斯方塊中的最小單位:方格(細胞)
 * 特徵(屬性):
 * 		row--行號
 * 		col--列號
 * 		image--對應的圖片
 *  行為(方法)
 *  	left()
 *  	right()
 *  	drop()
 */
public class Cell {
	private int row;
	private int col;
	private BufferedImage image;
	
	@Override
	public String toString() {
		return "(" + row + ", " + col + ")";
	}

	public int getRow() {
		return row;
	}

	public void setRow(int row) {
		this.row = row;
	}

	public int getCol() {
		return col;
	}

	public void setCol(int col) {
		this.col = col;
	}

	public BufferedImage getImage() {
		return image;
	}

	public void setImage(BufferedImage image) {
		this.image = image;
	}

	public Cell() {}
	
	public Cell(int row, int col, BufferedImage image) {
		this.row = row;
		this.col = col;
		this.image = image;
	}
	
	/*向左移動*/
	public void left() {
		col--;
	}
	/*向右移動*/
	public void right() {
		col++;
	}
	/*向下移動*/
	public void drop() {
		row++;
	}
}
 

根據每個四格方塊的共性，即移動等。我們可以讓七個四格方塊繼承一個父類------Tetromino類，用於描述四格方塊的行為，左移，右移，下落，生成一個方塊。

Tetromino()類程式碼：

共同特徵：cells--四個小方塊（用陣列表示）--許可權修飾詞protected

共同行為：向左，向右，向下移動，提供JavaBean規範

新增randomOne()方法---用來隨機生成一個四格方塊

import java.util.Arrays;

/*
 * 四格方塊
 * 屬性:
 * 		--cells----四個方塊
 * 行為:
 * 		moveLeft()
 * 		moveRight()
 * 		softDrop()
 */
public class Tetromino {
	protected Cell[] cells=new Cell[4];
	/*四格方塊向左移動
	 * 實際上：就是每個方塊向左移動
	 */
	
	/*四格方塊向左移動*/
	public void moveLeft() {
		for(Cell c:cells)
			c.left();
	}
	/*四格方塊向右移動*/
	public void moveRight() {
		for(Cell c:cells)
			c.right();
	}
	/*四格方塊向下移動*/
	public void softDrop() {
		for(Cell c:cells)
			c.drop();
	}
	@Override
	public String toString() {
		return "[" + Arrays.toString(cells) + "]";
	}
	/*隨機生成一個四格方塊*/
	public static Tetromino randomOne() {
		Tetromino t = null;
		int num=(int)(Math.random()*7);//random的範圍是0.00-0.99(即包含0不包含1)
		switch (num) {
		case 0:t=new T();break;
		case 1:t=new O();break;
		case 2:t=new I();break;
		case 3:t=new J();break;
		case 4:t=new L();break;
		case 5:t=new S();break;
		case 6:t=new Z();break;
		}
		return t;
	}
}

然後在建立7個小方塊的類，來繼承Tetromino類，也就是把他們的共同點寫到一個父類中，子類在描述各自的特性。

根據父類Tetromino，定義出七種子類，給屬性賦具體元素。

L類程式碼：

public class L extends Tetromino{
	/*
	 * 提供構造器進行初始化
	 * L型的四格方塊的位置
	*/
	public L() {
		cells[0]=new Cell(0,4,Tetris.L);
		cells[1]=new Cell(0,3,Tetris.L);
		cells[2]=new Cell(0,5,Tetris.L);
		cells[3]=new Cell(1,3,Tetris.L);
	}
}

其他6個按照方塊所在的座標編寫，點選檢視座標，這樣一來，便寫好了最基本的類。

然後在建立一個主類，這個類就是遊戲的入口，也是遊戲的所有邏輯所在。

Tetris類程式碼：

提供靜態屬性，載入靜態資源，遊戲圖片，場景等--靜態程式碼塊

1. 面板會自動呼叫繪製方法paint(Graphics g)
2. 重寫paint方法，繪製圖片背景，繪製網格和嵌入牆中的方塊。
3. 繪製網格和嵌入牆中的方塊。paintWall(Graphics g)
       提供屬性wall---是一個Cell型別的二維陣列，20行，10列
       屬性CELL_SIZE---一個方塊的寬度
   
4. 提供屬性
       currentOne---正在下落的四格方塊
       nextOne---下一個將要下落的四格方塊
   
5. 提供繪製正在下落的方塊的方法
       paintCurrentOne(Graphics g)
       在重寫的paint方法中取呼叫
   
6. 編寫start()方法，用於封裝遊戲主要邏輯

import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

/*
 * 俄羅斯方塊的主類:
 * 前提：必須是一塊麵板Jpanel,可以嵌入視窗
 * 面板上自帶一個畫筆，有一個功能：自動繪製
 * 其實是呼叫了JPanel裡的paint()方法
 * 
 * 
 * (1)載入靜態資源
 */
public class Tetris extends JPanel{
	
	/*屬性：正在下落的四格方塊*/
	private Tetromino currentOne = Tetromino.randomOne();
	/*屬性：將要下落的四格方塊*/
	private Tetromino nextOne = Tetromino.randomOne();
	/*屬性：牆,20行 10列的 表格  寬度為26*/
	private Cell[][] wall=new Cell[20][10];
	private static final int CELL_SIZE=26;
	
	//載入方塊圖片
	public static  BufferedImage T;
	public static  BufferedImage I;
	public static  BufferedImage O;
	public static  BufferedImage J;
	public static  BufferedImage L;
	public static  BufferedImage S;
	public static  BufferedImage Z;
	public static  BufferedImage background;
	public static  BufferedImage gameover;
	static {
		try {
			/*
			 * getResource(String url)
			 * url:載入圖片的路徑
			 * 相對位置是同包下
			 */
			T = ImageIO.read(Tetris.class.getResource("T.png"));
			I = ImageIO.read(Tetris.class.getResource("I.png"));
			O = ImageIO.read(Tetris.class.getResource("O.png"));
			J = ImageIO.read(Tetris.class.getResource("J.png"));
			L = ImageIO.read(Tetris.class.getResource("L.png"));
			S = ImageIO.read(Tetris.class.getResource("S.png"));
			Z = ImageIO.read(Tetris.class.getResource("Z.png"));
			background = ImageIO.read(Tetris.class.getResource("tetris.png"));
			gameover = ImageIO.read(Tetris.class.getResource("game-over.png"));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/*
	 * 重寫JPanel類中的paint(Graphics g)方法
	 * 
	 */
	public void paint(Graphics g) {
		//繪製背景
		/*
		 * g:畫筆
		 * g.drawImage(image,x,y,null)
		 * image:繪製的圖片
		 * x:開始繪製的橫座標
		 * y:開始繪製的縱座標
		 */
		g.drawImage(background, 0,0, null);
		//平移座標軸
		g.translate(15, 15);
		//繪製牆
		paintWall(g);
		//繪製正在下落的四格方塊
		paintCurrentOne(g);
		//繪製下一個將要下落的四格方塊
		paintNextOne(g);
	}
	/*
	 * 繪製下一個將要下落的四格方塊
	 * 繪製到面板的右上角的相應區域
	 * @param g
	 */
	public void paintNextOne(Graphics g) {
		//獲取nextOne物件的四個元素
		Cell[] cells = nextOne.cells;
		for(Cell c:cells) {
			//獲取每一個元素的行號和列號
			int row = c.getRow();
			int col = c.getCol();
			//橫座標
			int x = col*CELL_SIZE+260;
			//縱座標
			int y = row*CELL_SIZE+26;
			g.drawImage(c.getImage(),x,y,null);
		}
	}
	
	/*繪製正在下落的四格方塊
	 * 取出陣列的元素
	 * 繪製元素的圖片
	 * 橫座標x
	 * 縱座標y 
	 */
	public void paintCurrentOne(Graphics g){
		Cell[] cells = currentOne.cells;
		for(Cell c:cells)
		{
			int x = c.getCol()*CELL_SIZE;
			int y = c.getRow()*CELL_SIZE;
			g.drawImage(c.getImage(),x,y,null);
		}
	}
	public void paintWall(Graphics a) {
		//外層迴圈控制行數
		for(int i=0;i<20;i++)
		{
			//內層迴圈控制列數
			for(int j=0;j<10;j++)
			{
				int x = j*CELL_SIZE;
				int y = i*CELL_SIZE;			
				Cell cell=wall[i][j];
				if(cell==null)
				{
					a.drawRect(x, y, CELL_SIZE, CELL_SIZE);
				}
				else
				{
					a.drawImage(cell.getImage(),x,y,null);
				}
			}
		}
	}
	
	/*
	 * 封裝了遊戲的主要邏輯
	 */
	public void start() {
		//開啟鍵盤監聽事件
		
		KeyListener l = new KeyAdapter() {
			/*
			 * KeyPressed()
			 * 是鍵盤按鈕 按下去所呼叫的方法
			 */
			@Override
			public void keyPressed(KeyEvent e) {
				// 獲取一下鍵子的代號
				int code = e.getKeyCode();
				switch (code) {
				case KeyEvent.VK_DOWN:
					softDropAction();
					break;
				case KeyEvent.VK_LEFT:
					moveLeftAction();
					break;
				case KeyEvent.VK_RIGHT:
					moveRightAction();
					break;
				case KeyEvent.VK_UP:
				
					break;
				default:
					break;
				}
				//按一次重新繪製一次
				repaint();
			}
			

			
		};
		//面板新增監聽事件物件
		this.addKeyListener(l);
		//面板物件設定成焦點
		this.requestFocus();
		
		while(true) {
			/*
			 * 當程式執行到此，會進入睡眠狀態，
			 * 睡眠時間為300毫秒,單位為毫秒
			 * 300毫秒後，會自動執行後續程式碼
			 */
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				// 抓取打斷異常
				e.printStackTrace();
			}

			if(canDrop()) {
				currentOne.softDrop();
			}
			else {
				landToWall();
				//將下一個下落的四格方塊賦值給正在下落的變數
				currentOne = nextOne;
				nextOne = Tetromino.randomOne();
			}
			/*
			 * 下落之後，要重新進行繪製，才會看到下落後的位置
			 * repaint方法，也是JPanel類中提供的
			 * 此方法中呼叫了paint方法
			 */
			repaint();
			elimination();
		}
	}
	
	
	/*
	 * 使用Right鍵控制四格方塊右移
	 */
	public void moveRightAction() {
		currentOne.moveRight();
		if(outOfBounds()||coincide())
			currentOne.moveLeft();
	}

	/*
	 * 使用Left鍵控制四格方塊左移
	 */
	public void moveLeftAction() {
		currentOne.moveLeft();
		if(outOfBounds()||coincide()) {
			currentOne.moveRight();
		}
	}
	private boolean coincide() {
		Cell[] cells = currentOne.cells;
		for(Cell c:cells) {
			int row = c.getRow();
			int col = c.getCol();
			if(wall[row][col]!=null)
				return true;
		}
		return false;
	}
	public boolean outOfBounds() {
		Cell[] cells = currentOne.cells;
		for(Cell c:cells) {
			int col = c.getCol();
			if(col<0||col>9)
				return true;
		}
		return false;
	}
	
	/*
	 * 使用Down鍵控制四格方塊的下落
	 */
	public void softDropAction() {
		if(canDrop()) {
			currentOne.softDrop();
		}
		else {
			landToWall();
			currentOne = nextOne;
			nextOne = Tetromino.randomOne();
		}
	}
	public boolean canDrop() {
		Cell[] cells = currentOne.cells;
		/* 
		 * 
		 */
		for(Cell c:cells) {
			/* 獲取每個元素的行號,列號
			 * 判斷：
			 * 只要有一個元素的下一行上有方塊
			 * 或者只要有一個元素到達最後一行
			 * 就不能再下落了
			 */
			int row = c.getRow();
			int col = c.getCol();
			if (row==19) {//判斷是否到達底部
				return false;
			}
			else if(wall[row+1][col]!=null) {//判斷下方是否有方塊
				return false;
			}
			
		}
		return true;
	}
	/*
	 * 當不能再下落時，需要將四格方塊嵌入到牆中
	 * 也就是儲存到二維陣列中相應的位置上
	 */
	public void landToWall() {
		Cell[] cells = currentOne.cells;
		for(Cell c:cells) {
			//獲取最終的行號和列號
			int row = c.getRow();
			int col = c.getCol();
			wall[row][col] = c;
		}
	}
	/*啟動遊戲的入口  遊戲開始*/
	public static void main(String[] args) {
		//1:建立一個視窗物件
		JFrame frame=new JFrame("玩玩俄羅斯方塊");
		
		//建立遊戲介面,即畫板(面板)
		Tetris panel = new Tetris();
		//將面板嵌入視窗
		frame.add(panel);
		
		//2:設定為可見
		frame.setVisible(true);
		//3:設定視窗的尺寸
		frame.setSize(535, 595);
		//4:設定視窗居中
		frame.setLocationRelativeTo(null);
		//5:設定視窗關閉,即程式中止
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				
		//遊戲的主要邏輯封裝在start方法中
		panel.start();
	}
}

未完待續。。。