Java实例---俄罗斯方块

代码分析

定义格子

 package com.ftl.tetris;
 /**
  * 定义格子
  */

 import java.awt.image.BufferedImage;

 public class Cell {

     private int row;
     private int col;
     private BufferedImage image;

     /**
      * 构造方法，传递参数
      * @param row  定义行
      * @param col  定义列
      * @param image
      */
     public Cell(int row, int col, BufferedImage image) {
         super();
         this.row = row;
         this.col = col;
         this.image = image;
     }

     /**
      * drop函数，控制下降
      * @return
      */
     public void drop(){
         row++;
     }

     /**
      * 右移
      */
     public void moveRight()
     {
         col++;
     }

     /**
      * 左移
      */
     public void moveLeft(){
         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 String toString(){
         return row + "," + col;
     }

 }

定义方块

 package com.ftl.tetris;

 import java.util.Arrays;
 import java.util.Random;

 import javax.swing.plaf.nimbus.State;

 /**
  * 4格方块,7种形态
  */

 public abstract class Tetromino {
     protected Cell[] cells = new Cell[4];   //四个格子，静态方法
     protected State[] states;

     public State[] getStates() {
         return states;
     }

     public void setStates(State[] states) {
         this.states = states;
     }

     /*旋转状态序列号， states = index % states.length*/
     protected int index = 10000;

     /**
      * 内部类
      */

     protected class State{

         int row0,col0,row1,col2,row2,col1,row3,col3;

         public State(int row0, int col0, int row1, int col2, int row2,
                 int col1, int row3, int col3) {
             this.row0 = row0;
             this.col0 = col0;
             this.row1 = row1;
             this.col2 = col2;
             this.row2 = row2;
             this.col1 = col1;
             this.row3 = row3;
             this.col3 = col3;
         }
     }

     /**
      * 向右旋转
      */
     public void roateRight(){
         //取得变化的下个数据状态
         //取得当前轴的row,col
         //旋转后的数据= (row,col) + states[n]
         this.index++;
         State s = states[index % states.length];
         System.out.println("index++" + this.index + "\tstates长度：" + states.length + "\t取余数 " + (index % states.length));
         Cell o = cells[0];
         int row = o.getRow();
         int col = o.getCol();
         cells[1].setRow(row + s.row1);
         cells[2].setRow(row + s.row2);
         cells[3].setRow(row + s.row3);
         cells[1].setCol(col + s.col1);
         cells[2].setCol(col + s.col2);
         cells[3].setCol(col + s.col3);
     }
     /**
      * 左旋转
      */
     public void roateLeft(){
         //取得变化的下个数据状态
         //取得当前轴的row,col
         //旋转后的数据= (row,col) + states[n]
         this.index--;
         State s = states[index % states.length];
         System.out.println("index--" + this.index + "\tstates长度：" + states.length + "\t取余数 " + (index % states.length));
         Cell o = cells[0];
         int row = o.getRow();
         int col = o.getCol();
         cells[1].setRow(row + s.row1);
         cells[2].setRow(row + s.row2);
         cells[3].setRow(row + s.row3);
         cells[1].setCol(col + s.col1);
         cells[2].setCol(col + s.col2);
         cells[3].setCol(col + s.col3);
     }

     /**
      * 工厂方法，产生四个随机方块
      */
     public static Tetromino getOne() {
         Random random = new Random();
         int type = random.nextInt(7);
         switch (type) {
         case 0:
             return new T();
         case 1:
             return new I();
         case 2:
             return new S();
         case 3:
             return new J();
         case 4:
             return new L();
         case 5:
             return new Z();
         case 6:
             return new O();
         }
         return null;
     }

     /**
      * 方块落下一个格子
      */
     public void softDorp() {
         for (int i = 0; i < cells.length; i++) {
             cells[i].drop();
         }
     }

     /**
      * 方块落左移一个格子
      */
     public void moveLeft() {
         for (int i = 0; i < cells.length; i++) {
             cells[i].moveLeft();
         }
     }

     /**
      * 方块落右移一个格子
      */
     public void moveRight() {
         for (int i = 0; i < cells.length; i++) {
             cells[i].moveRight();
         }
     }

     public Cell[] getCells() {
         return cells;
     }

     public void setCells(Cell[] cells) {
         this.cells = cells;
     }

     /**
      * 打印每个格子的行列信息
      */
     public String toString() {
         return Arrays.toString(cells);
     }

 }

 /**
  * T格子
  *
  * @author Administrator
  *
  */
 class T extends Tetromino{
     public T() {
         cells[0] = new Cell(0, 4, Tetris.T );
         cells[1] = new Cell(0, 3, Tetris.T);
         cells[2] = new Cell(0, 5, Tetris.T);
         cells[3] = new Cell(1, 4, Tetris.T);
         states = new State[4];
         states[0] = new State(0,0,0,-1,0,1,1,0);
         states[1] = new State(0,0,-1,0,1,0,0,-1);
         states[2] = new State(0,0,0,1,0,-1,-1,0);
         states[3] = new State(0,0,1,0,-1,0,0,1);
     }
 }

 /**
  * I格子
  *
  * @author Administrator
  *
  */
 class I extends Tetromino {
     public I() {
         cells[0] = new Cell(0, 4, Tetris.I);
         cells[1] = new Cell(0, 3, Tetris.I);
         cells[2] = new Cell(0, 5, Tetris.I);
         cells[3] = new Cell(0, 6, Tetris.I);
         states = new State[]{
             new State(0,0,0,-1,0,1,0,2),
             new State(0,0,-1,0,1,0,2,0),
             };
     }
 }

 /**
  * Z格子
  *
  * @author Administrator
  *
  */
 class Z extends Tetromino {
     public Z() {
         cells[0] = new Cell(1, 4, Tetris.Z);
         cells[1] = new Cell(0, 3, Tetris.Z);
         cells[2] = new Cell(0, 4, Tetris.Z);
         cells[3] = new Cell(1, 5, Tetris.Z);
         states = new State[]{
                 new State(0,0,-1,-1,-1,0,0,1),
                 new State(0,0,-1,1,0,1,1,0),
                 };
     }
 }

 /**
  * L格子
  *
  * @author Administrator
  *
  */
 class L extends Tetromino {
     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);
         states = new State[]{
                 new State(0,0,0,1,0,-1,-1,1),
                 new State(0,0,1,0,-1,0,1,1),
                 new State(0,0,0,-1,0,1,1,-1),
                 new State(0,0,-1,0,1,0,-1,-1),
                 };
     }
 }

 /**
  * S格子
  *
  * @author Administrator
  *
  */
 class S extends Tetromino {
     public S() {
         cells[0] = new Cell(1, 4, Tetris.S);
         cells[1] = new Cell(1, 3, Tetris.S);
         cells[2] = new Cell(0, 4, Tetris.S);
         cells[3] = new Cell(0, 5, Tetris.S);
         states = new State[]{new State(0,0,0,-1,-1,0,-1,1),new State(0,0,-1,0,0,1,1,1)};
     }
 }

 /**
  * J格子
  *
  * @author Administrator
  *
  */
 class J extends Tetromino {
     public J() {
         cells[0] = new Cell(0, 4, Tetris.J);
         cells[1] = new Cell(0, 3, Tetris.J);
         cells[2] = new Cell(0, 5, Tetris.J);
         cells[3] = new Cell(1, 5, Tetris.J);
         states = new State[]{
                 new State(0,0,0,-1,0,1,1,1),
                 new State(0,0,-1,0,1,0,1,-1),
                 new State(0,0,0,1,0,-1,-1,-1),
                 new State(0,0,1,0,-1,0,-1,1),
                 };
     }
 }

 /**
  * O格子
  *
  * @author Administrator
  *
  */
 class O extends Tetromino {
     public O() {
         cells[0] = new Cell(0, 4, Tetris.O);
         cells[1] = new Cell(0, 5, Tetris.O);
         cells[2] = new Cell(1, 4, Tetris.O);
         cells[3] = new Cell(1, 5, Tetris.O);
     }
 }

游戏主程序

 package com.ftl.tetris;

 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Timer;
 import java.util.TimerTask;

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

 /**
  * 俄罗斯方块
  *
  * @author FTL1012
  *
  */
 public class Tetris extends JPanel {
     private int score; // 分数
     private int lines; // 行数
     private Cell[][] walls; // 定义背景
     private Tetromino tetromino; // 正在下降的格子
     private Tetromino nextOne; // 下一个下降的格子

     public static final int ROWS = 20; // 背景墙的行数
     public static final int COLS = 10; // 背景墙的列数
     private static final int CELL_SIZE = 26;  //间距
     private static final int FONT_COLOR= 0x667799;  //字体颜色
     private static final int FONT_SIZE = 30;

     private Timer timer;    //定时调度
     private int speed;
     private int level;
     private int index;

     //游戏运行状态
     private int state;
     private static final int RUNNING = 0;
     private static final int PAUSE = 1;
     private static final int GAME_OVER = 2;

     /**
      * 背景图片
      *
      * @param args
      */
     private static BufferedImage background;
     public static BufferedImage T;
     public static BufferedImage S;
     public static BufferedImage I;
     public static BufferedImage L;
     public static BufferedImage J;
     public static BufferedImage O;
     public static BufferedImage Z;
     public static BufferedImage gameOver;
     public static BufferedImage pause;

     /**
      * 静态代码块加载图片
      */
     static {
         try {
             background = ImageIO.read(Tetris.class.getResource("tetris.png"));
             gameOver = ImageIO.read(Tetris.class.getResource("gameover.png"));
             pause = ImageIO.read(Tetris.class.getResource("pause.png"));
             T = ImageIO.read(Tetris.class.getResource("T.png"));
             I = ImageIO.read(Tetris.class.getResource("I.png"));
             L = ImageIO.read(Tetris.class.getResource("L.png"));
             O = ImageIO.read(Tetris.class.getResource("O.png"));
             S = ImageIO.read(Tetris.class.getResource("S.png"));
             J = ImageIO.read(Tetris.class.getResource("J.png"));
             Z = ImageIO.read(Tetris.class.getResource("Z.png"));
         } catch (IOException e) {
             // TODO 自动生成的 catch 块
             e.printStackTrace();
         }
     }

     /**
      * 画背景，画墙，画正在下落的方块，画下一个方块
      */
     @Override
     public void paint(Graphics g) {
         // TODO 自动生成的方法存根
         g.drawImage(background, 0, 0, null);
         g.translate(15, 15); // 坐标系平移15个像素

         //打印背景
         paintWall(g);
         //打印下落的方块
         paintTetromino(g);
         //打印即将下落的方块
         paintNextmino(g);
         //绘制分数
         paintScore(g);
         //绘制游戏状态
         paintState(g);
     }

     /**
      * 绘制游戏状态
      */
     private void paintState(Graphics g) {
         switch (state) {
         case PAUSE:
             g.drawImage(pause, -15, -15, null);
             break;
         case GAME_OVER:
             g.drawImage(gameOver, -15, -15, null);
             break;
         }
     }

     /**
      * 绘制分数
      * @param g
      */
     private void paintScore(Graphics g) {
         int x = 290;
         int y = 160;
         g.setColor(new Color(FONT_COLOR));
         Font font = g.getFont();
         font = new Font(font.getName(),font.getStyle(),FONT_SIZE);
         g.setFont(font);
         String str = null;
         str = "SCORE:" + score;
         g.drawString(str, x, y);
         y += 56;
         str = "LINES:" + lines;
         g.drawString(str, x, y);
         y += 56;
         str = "LEVEL:" + level;
         g.drawString(str, x, y);
     }

     /**
      * 启动Action方法，初始化数组Walls,
      * @param args
      */
     public void action()
     {
         walls = new Cell[ROWS][COLS];
         walls[2][2] = new Cell(2,2,T);    //将强的第二行第二列设置为T方块的一个格子(2,2)
         tetromino = Tetromino.getOne();   //正在下落的方块
         nextOne = Tetromino.getOne();     //下一个即将下落的方块

         this.state = RUNNING;
         //增加键盘监听控制
         KeyAdapter l = new KeyAdapter() {

             @Override
             public void keyPressed(KeyEvent e) {
                 // TODO 自动生成的方法存根
 //                int key = e.getKeyCode();
 //                switch (key) {
 //                case KeyEvent.VK_DOWN:
 //                    softDorpAction();
 //                    break;
 //                case KeyEvent.VK_RIGHT:
 //                    moveRightAction();
 //                    break;
 //                case KeyEvent.VK_LEFT:
 //                    moveLeftAction();
 //                    break;
 //                case KeyEvent.VK_SPACE:
 //                    hardDropAction();
 //                    break;
 //                case KeyEvent.VK_UP:
 //                    rotateRightAction();
 //                    break;
 //                }
                 int key = e.getKeyCode();
                 switch (state) {
                 case GAME_OVER:
                     processGameOverKey(key);
                     break;
                 case PAUSE:
                     processPauseKey(key);
                     break;
                 case RUNNING:
                     processRunningKey(key);
                     break;
                 }
                 repaint();
             }
         };
         //点击按钮的时候，按钮获得焦点，对应处理一些逻辑
         this.requestFocus();
         this.addKeyListener(l);

         //定时方法
         this.timer = new Timer();
         this.timer.schedule(new TimerTask() {
             public void run() {
                 speed = 40 - (lines / 2);
                 speed = speed < 1 ? 1 : speed;
                 level = 41 - speed;
                 if(state == RUNNING && index % speed == 0){
                 softDorpAction();
                 }
                 index++;
                 repaint();
             }
         }, 10, 13);
     }

     /**
      * 运行按钮
      * @param key
      */
     private void processRunningKey(int key) {
         switch (key) {
         case KeyEvent.VK_Q:
             System.exit(0);
             break;
         case KeyEvent.VK_DOWN:
             softDorpAction();
             break;
         case KeyEvent.VK_RIGHT:
             moveRightAction();
             break;
         case KeyEvent.VK_LEFT:
             moveLeftAction();
             break;
         case KeyEvent.VK_SPACE:
             hardDropAction();
             break;
         case KeyEvent.VK_UP:
             rotateRightAction();
             break;
         case KeyEvent.VK_P:
             this.state = PAUSE;
             break;
         }

     }

     /**
      * 停止按钮
      * @param key
      */
     private void processPauseKey(int key) {
         switch (key) {
         case KeyEvent.VK_Q:
             System.exit(0);
             break;
         case KeyEvent.VK_C:
             index = 0;
             this.state = RUNNING;
             break;
         }

     }

     /**
      * 游戏结束，重新开始
      * @param key
      */
     private void processGameOverKey(int key) {
         switch (key) {
         case KeyEvent.VK_Q:
             System.exit(0);            //退出游戏
             break;
         case KeyEvent.VK_S:
             this.lines = 0;
             this.score = 0;
             this.walls = new Cell[ROWS][COLS];
             this.tetromino = Tetromino.getOne();
             this.nextOne = Tetromino.getOne();
             this.state = RUNNING;
 //            this.index = 0;
             break;
         }
     }

     /**
      * 绘制正在下落的方块
      * @param args
      */
     public void paintTetromino(Graphics g)
     {
         if(tetromino == null)
         {
             return;  //结束方法
         }
         //将每个格子的row 和 col转换为x,y，然后贴图
         Cell[] cells = tetromino.cells;
         for(int i = 0; i < cells.length; i++)
         {
             //cell 为每一个盒子
             Cell cell = cells[i];
             int x = cell.getCol() * CELL_SIZE;
             int y = cell.getRow() * CELL_SIZE;
             g.drawImage(cell.getImage(), x-1, y-1, null);
         }
     }

     /**
      * 画下一个即将下落的方块
      */
     public void paintNextmino(Graphics g)
     {
         if(nextOne == null)
         {
             return;  //结束方法
         }
         //将每个格子的row 和 col转换为x,y，然后贴图
         Cell[] cells = nextOne.cells;
         for(int i = 0; i < cells.length; i++)
         {
             //cell 为每一个盒子
             Cell cell = cells[i];
             int x = (cell.getCol() + 10)* CELL_SIZE;
             int y = (cell.getRow() + 1) * CELL_SIZE;
             g.drawImage(cell.getImage(), x-1, y-1, null);
         }
     }

     /**
      * 画墙
      *
      * @param args
      */
     private void paintWall(Graphics g) {
         // TODO 自动生成的方法存根
         for (int row = 0; row < walls.length; row++) {
             // line表示墙上的每一行
             Cell[] line = walls[row];
             for (int col = 0; col < line.length; col++) {
                 // cell表示墙上的每一个格子
                 Cell cell = line[col];
                 int x = col * CELL_SIZE;
                 int y = row * CELL_SIZE;
                 //如果cell为空，则表示没有格子
                 if(cell == null){
                     g.drawRect(x, y, CELL_SIZE, CELL_SIZE);
                 }
                 //如果不为空，表示有格子，显示各自，x-1,y-1为了不让重叠，为了美观
                 else
                 {
                     g.drawImage(cell.getImage(), x-1, y-1, null);
                 }
 //                g.drawString(row+"," + col,x,y+CELL_SIZE);
             }

         }
     }

     /**
      * 判断是否出界
      */
     private boolean outOfBounds(){
         Cell[] cells = tetromino.cells;
         for(int i = 0; i < cells.length; i++)
         {
             Cell cell = cells[i];
             int col = cell.getCol();
             if(col < 0 || col >= COLS )
             {
                 return true;
             }
         }
         return false;
     }

     /**
      * 判断是否重合
      */
     private boolean coinclude() {
         Cell[] cells = tetromino.cells;
         for (int i = 0; i < cells.length; i++) {
             Cell cell = cells[i];
             int row = cell.getRow();
             int col = cell.getCol();
             if (row >= 0 && row < ROWS && col >= 0 && col <= COLS
                     && walls[row][col] != null) {
                 return true;  //重合
             }
         }
         return false;
     }

     /**
      * 判断右边是否出界
      * @param args
      */
     public void moveRightAction(){
         tetromino.moveRight();
         if(this.outOfBounds() || this.coinclude())
         {
             tetromino.moveLeft();
         }
     }

     /**
      * 判断左边是否出界
      * @param args
      */
     public void moveLeftAction(){
         tetromino.moveLeft();
         if(this.outOfBounds() || this.coinclude())
         {
             tetromino.moveRight();
         }
     }

     /**
      * 判断游戏是否结束：
      *
      */

     private boolean isGameOver(){
         //如果下一个放开没有出场位置，游戏结束
         //就是： 下一个出场方块每个ge子都有对于的墙上如果有格子
         Cell[] cells = nextOne.cells;
         for(Cell cell:cells){
             int row = cell.getRow();
             int col = cell.getCol();
             if(walls[row][col] != null){
                 return true;
             }
         }
         return false;
     }

     /**
      * 选择控制--右边
      */
     private void rotateRightAction() {
         tetromino.roateRight();
         if(this.outOfBounds() || this.coinclude()){
             tetromino.roateLeft();
         }

     }

     private static int[] scoreTable = {0,1,10,50,100};

     /**
      *销毁行
      */
     public void destoryLines()
     {
         int lines = 0;
         //循环墙上的每一行，如果每一行都有格子，表示行满
         for(int row = 0; row < walls.length; row++){
             if(this.fullCells(row)){
                 deleteRow(row);
                 lines++;
             }
         }
         this.score += scoreTable[lines];
         this.lines += lines;
     }

     /**
      * 删除某行
      *
      */
     public void deleteRow(int row)    {
         for(int i = row; i >=1; i--)
         {
             System.arraycopy(walls[i-1], 0, walls[i], 0, COLS);
         }
         Arrays.fill(walls[0], null);
     }

     /**
      * 判断行是否满了
      */
     public boolean fullCells(int row){
         Cell[] line = walls[row];//获取每一个格子的行
         for(Cell cell:line)
         {
             if(cell == null)
             {
                 return false;    //未满
             }
         }
         return true;
     }

     /**
      * 格子落地
      */
     public void landIntoWall(){
         //获取正在下落的四个格子
         Cell[] cells = tetromino.cells;
         for(int i = 0; i< cells.length; i++)
         {
             Cell cell = cells[i];
             int row = cell.getRow();
             int col = cell.getCol();
             //格子放在相应的位置
             walls[row][col] = cell;
         }
     }

     /**
      * 判断是否可以继续下落
      * @param args
      */

     private boolean canDrop(){
         Cell[] cells = tetromino.cells;
         //到达最后一行
         for (int i = 0; i < cells.length; i++) {
             Cell cell = cells[i];
             int row = cell.getRow();
             if( row == ROWS - 1)
             {
                 return false;     //不能下落
             }
         }
         //下一行有格子
         for(Cell cell:cells    )
         {
             int row = cell.getRow() + 1;
             int col = cell.getCol();
             if( row >= 0 && row < ROWS && col >=0 && col <=COLS
                     && walls[row][col] != null)
             {
                 return false;
             }
         }
         return true;
     }

     /**
      *下落流控制
      */
     public void softDorpAction() {
         if(this.canDrop()){
             tetromino.softDorp();
         }else{
             this.landIntoWall();
             this.destoryLines();
             this.tetromino = this.nextOne;
             this.nextOne = Tetromino.getOne();
         }
     }

     public void hardDropAction()
     {
         while(this.canDrop()){
             this.softDorpAction();
         }
         landIntoWall();
         destoryLines();
         tetromino = nextOne;
         nextOne = Tetromino.getOne();
     }

     public static void main(String[] args) {
         JFrame jf = new JFrame();
         Tetris tetris = new Tetris();
         tetris.setBackground(new Color(0x0000ff));
         jf.add(tetris);
         jf.setSize(530, 580);
         jf.setLocationRelativeTo(null);
         jf.setTitle("Go Fighting——FTL");
         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         jf.setVisible(true);

         tetris.action();
     }

 }

游戏截图

源码下载

附：程序略有小bug,感兴趣的朋友可以改改

点击下载