Java项目--俄罗斯方块

Java项目--俄罗斯方块

百度盘链接

链接：http://pan.baidu.com/s/1mhQ9SYc 密码：9ujo

一、心得

二、游戏实例

游戏截图

目录结构

三、代码

1、主界面 Tetris.java

 package com.hsj.tetris;

 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
 import java.util.Arrays;
 import java.util.Timer;
 import java.util.TimerTask;

 import javax.imageio.ImageIO;
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 /**
  * 俄罗斯方块游戏面板
  *
  */
 public class Tetris extends JPanel {
     /** 正在下落方块 */
     private Tetromino tetromino;
     /** 下一个下落方块 */
     private Tetromino nextOne;
     /** 行数 */
     public static final int ROWS = 20;
     /** 列数 */
     public static final int COLS = 10;
     /** 墙 */
     private Cell[][] wall = new Cell[ROWS][COLS];
     /** 消掉的行数 */
     private int lines;
     /** 分数 */
     private int score;

     public static final int CELL_SIZE = 26;

     private static Image background;//背景图片
     public static Image I;
     public static Image J;
     public static Image L;
     public static Image S;
     public static Image Z;
     public static Image O;
     public static Image T;
     static{//加载静态资源的，加载图片
         //建议将图片放到 Tetris.java 同包中!
         //从包中加载图片对象，使用Swing API实现
 //        Toolkit toolkit = Toolkit.getDefaultToolkit();
 //        background = toolkit.getImage(
 //                Tetris.class.getResource("tetris.png"));
 //        T = toolkit.getImage(Tetris.class.getResource("T.png"));
 //        S = toolkit.getImage(Tetris.class.getResource("S.png"));
 //        Z = toolkit.getImage(Tetris.class.getResource("Z.png"));
 //        L = toolkit.getImage(Tetris.class.getResource("L.png"));
 //        J = toolkit.getImage(Tetris.class.getResource("J.png"));
 //        I = toolkit.getImage(Tetris.class.getResource("I.png"));
 //        O = toolkit.getImage(Tetris.class.getResource("O.png"));
         //import javax.imageio.ImageIO;
         try{
             background = ImageIO.read(
                 Tetris.class.getResource("tetris.png"));
             T=ImageIO.read(Tetris.class.getResource("T.png"));
             I=ImageIO.read(Tetris.class.getResource("I.png"));
             S=ImageIO.read(Tetris.class.getResource("S.png"));
             Z=ImageIO.read(Tetris.class.getResource("Z.png"));
             L=ImageIO.read(Tetris.class.getResource("L.png"));
             J=ImageIO.read(Tetris.class.getResource("J.png"));
             O=ImageIO.read(Tetris.class.getResource("O.png"));
         }catch(Exception e){
             e.printStackTrace();
         }
     }

     public void action(){
         //tetromino = Tetromino.randomTetromino();
         //nextOne = Tetromino.randomTetromino();
         //wall[19][2] = new Cell(19,2,Tetris.T);
         startAction();
         repaint();
         KeyAdapter l = new KeyAdapter() {
             public void keyPressed(KeyEvent e) {
                 int key = e.getKeyCode();
                 if(key == KeyEvent.VK_Q){
                     System.exit(0);//退出当前的Java进程
                 }
                 if(gameOver){
                     if(key==KeyEvent.VK_S){
                         startAction();
                     }
                     return;
                 }
                 //如果暂停并且按键是[C]就继续动作
                 if(pause){//pause = false
                     if(key==KeyEvent.VK_C){    continueAction();    }
                     return;
                 }
                 //否则处理其它按键
                 switch(key){
                 case KeyEvent.VK_RIGHT: moveRightAction(); break;
                 case KeyEvent.VK_LEFT: moveLeftAction(); break;
                 case KeyEvent.VK_DOWN: softDropAction() ; break;
                 case KeyEvent.VK_UP: rotateRightAction() ; break;
                 case KeyEvent.VK_Z: rotateLeftAction() ; break;
                 case KeyEvent.VK_SPACE: hardDropAction() ; break;
                 case KeyEvent.VK_P: pauseAction() ; break;
                 }
                 repaint();
             }
         };
         this.requestFocus();
         this.addKeyListener(l);
     }

     public void paint(Graphics g){
         g.drawImage(background, 0, 0, null);//使用this 作为观察者
         g.translate(15, 15);//平移绘图坐标系
         paintTetromino(g);//绘制正在下落的方块
         paintWall(g);//画墙
         paintNextOne(g);
         paintScore(g);
     }
     public static final int FONT_COLOR = 0x667799;
     public static final int FONT_SIZE = 0x20;
     private void paintScore(Graphics g) {
         Font f = getFont();//获取当前的 面板默认字体
         Font font = new Font(
                 f.getName(), Font.BOLD, FONT_SIZE);
         int x = 290;
         int y = 162;
         g.setColor(new Color(FONT_COLOR));
         g.setFont(font);
         String str = "SCORE:"+this.score;
         g.drawString(str, x, y);
         y+=56;
         str = "LINES:"+this.lines;
         g.drawString(str, x, y);
         y+=56;
         str = "[P]Pause";
         if(pause){str = "[C]Continue";}
         if(gameOver){    str = "[S]Start!";}
         g.drawString(str, x, y);
     }

     private void paintNextOne(Graphics g) {
         Cell[] cells = nextOne.getCells();
         for(int i=0; i<cells.length; i++){
             Cell c = cells[i];
             int x = (c.getCol()+10) * CELL_SIZE-1;
             int y = (c.getRow()+1) * CELL_SIZE-1;
             g.drawImage(c.getImage(), x, y, null);
         }
     }

     private void paintTetromino(Graphics g) {
         Cell[] cells = tetromino.getCells();
         for(int i=0; i<cells.length; i++){
             Cell c = cells[i];
             int x = c.getCol() * CELL_SIZE-1;
             int y = c.getRow() * CELL_SIZE-1;
             //g.setColor(new Color(c.getColor()));
             //g.fillRect(x, y, CELL_SIZE, CELL_SIZE);
             g.drawImage(c.getImage(), x, y, null);
         }
     }

     //在 Tetris 类 中添加 方法 paintWall
     private void paintWall(Graphics g){
         for(int row=0; row<wall.length; row++){
             //迭代每一行, i = 0 1 2 ... 19
             Cell[] line = wall[row];
             //line.length = 10
             for(int col=0; col<line.length; col++){
                 Cell cell = line[col];
                 int x = col*CELL_SIZE;
                 int y = row*CELL_SIZE;
                 if(cell==null){
                     //g.setColor(new Color(0));
                     //画方形
                     //g.drawRect(x, y, CELL_SIZE, CELL_SIZE);
                 }else{
                     g.drawImage(cell.getImage(), x-1, y-1, null);
                 }
             }
         }
     }
     /**
      * 在 Tetris(俄罗斯方块) 类中增加方法
      * 这个方法的功能是：软下落的动作 控制流程
      * 完成功能：如果能够下落就下落，否则就着陆到墙上，
      *   而新的方块出现并开始落下。
      */
     public void softDropAction(){
         if(tetrominoCanDrop()){
             tetromino.softDrop();
         }else{
             tetrominoLandToWall();
             destroyLines();//破坏满的行
             checkGameOver();
             tetromino = nextOne;
             nextOne = Tetromino.randomTetromino();
         }
     }
     /** 销毁已经满的行，并且计分
      * 1）迭代每一行
      * 2）如果（检查）某行满是格子了 就销毁这行
      **/
     public void destroyLines(){
         int lines = 0;
         for(int row = 0; row<wall.length; row++){
             if(fullCells(row)){
                 deleteRow(row);
                 lines++;
             }
         }
         // lines = ?
         this.lines += lines;//0 1 2 3 4
         this.score += SCORE_TABLE[lines];
     }
     private static final int[] SCORE_TABLE={0,1,10,30,200};
     //                                      0 1  2  3  4

     public boolean fullCells(int row){
         Cell[] line = wall[row];
         for(int i=0; i<line.length; i++){
             if(line[i]==null){//如果有空格式就不是满行
                 return false;
             }
         }
         return true;
     }
     public void deleteRow(int row){
         for(int i=row; i>=1; i--){
             //复制 [i-1] -> [i]
             System.arraycopy(wall[i-1], 0, wall[i], 0, COLS);
         }
         Arrays.fill(wall[0], null);
     }

     /** 检查当前的4格方块能否继续下落 */
     public boolean tetrominoCanDrop(){
         Cell[] cells = tetromino.getCells();
         for(int i = 0; i<cells.length; i++){
             Cell cell = cells[i];
             int row = cell.getRow(); int col = cell.getCol();
             if(row == ROWS-1){return false;}//到底就不能下降了
         }
         for(int i = 0; i<cells.length; i++){
             Cell cell = cells[i];
             int row = cell.getRow(); int col = cell.getCol();
             if(wall[row+1][col] != null){
                 return false;//下方墙上有方块就不能下降了
             }
         }
         return true;
     }
     /** 4格方块着陆到墙上 */
     public void tetrominoLandToWall(){
         Cell[] cells = tetromino.getCells();
         for(int i=0; i<cells.length; i++){
             Cell cell = cells[i];
             int row = cell.getRow();
             int col = cell.getCol();
             wall[row][col] = cell;
         }
     }

     public void moveRightAction(){
         tetromino.moveRight();
         if(outOfBound() || coincide()){
             tetromino.moveLeft();
         }
     }
     public void moveLeftAction(){
         tetromino.moveLeft();
         if(outOfBound() || coincide()){
             tetromino.moveRight();
         }
     }
     /** ... */
     private boolean outOfBound(){
         Cell[] cells = tetromino.getCells();
         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 coincide(){
         Cell[] cells = tetromino.getCells();
         //for each 循环、迭代，简化了"数组迭代书写"
         for(Cell cell: cells){//Java 5 以后提供增强版for循环
             int row = cell.getRow();
             int col = cell.getCol();
             if(row<0 || row>=ROWS || col<0 || col>=COLS ||
                     wall[row][col]!=null){
                 return true; //墙上有格子对象，发生重合
             }
         }
         return false;
     }
     /** 向右旋转动作 */
     public void rotateRightAction(){
         //旋转之前
         //System.out.println(tetromino);
         tetromino.rotateRight();
         //System.out.println(tetromino);
         //旋转之后
         if(outOfBound() || coincide()){
             tetromino.rotateLeft();
         }
     }

     /** Tetris 类中添加的方法 */
     public void rotateLeftAction(){
         tetromino.rotateLeft();
         if(outOfBound() || coincide()){
             tetromino.rotateRight();
         }
     }
     public void hardDropAction(){
         while(tetrominoCanDrop()){
             tetromino.softDrop();
         }
         tetrominoLandToWall();
         destroyLines();
         checkGameOver();
         tetromino = nextOne;
         nextOne = Tetromino.randomTetromino();
     }

     private boolean pause;
     private boolean gameOver;
     private Timer timer;
     /** Tetris 类中添加的方法, 用于启动游戏 */
     public void startAction(){
         clearWall();
         tetromino = Tetromino.randomTetromino();
         nextOne = Tetromino.randomTetromino();
         lines = 0; score = 0;    pause=false; gameOver=false;
         timer = new Timer();
         timer.schedule(new TimerTask(){
             public void run() {
                 softDropAction();
                 repaint();
             }
         }, 700, 700);
     }

     private void clearWall(){
         //将墙的每一行的每个格子清理为null
         for(int row=0; row<ROWS; row++){
             Arrays.fill(wall[row], null);
         }
     }

     /** 在Tetris 类中添加方法  */
     public void pauseAction(){
         timer.cancel(); //停止定时器
         pause = true;
         repaint();
     }
     public void continueAction(){
         timer = new Timer();
         timer.schedule(new TimerTask() {
             public void run() {
                 softDropAction();
                 repaint();
             }
         }, 700, 700);
         pause = false;
         repaint();
     }
     /** 在 Tetris 类中添加 方法 */
     public void checkGameOver(){
         if(wall[0][4]==null){
             return;
         }
         gameOver = true;
         timer.cancel();
         repaint();
     }

     public static void main(String[] args) {
         JFrame frame = new JFrame();
         Tetris tetris = new Tetris();
         frame.add(tetris);
         frame.setSize(525, 550);
         frame.setUndecorated(false);//true去掉窗口框！
         frame.setTitle("俄罗斯方块");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         //Location 位置 RelativeTo相对于
         frame.setLocationRelativeTo(null);//使当前窗口居中
         frame.setVisible(true);
         tetris.action();
     }
 }

二、Cell.java

 package com.fry.tetris;

 import java.awt.Image;

 /**
  * 格子
  * 每一个小格子，就有所在的行 列 和图片
  */
 public class Cell {
     private int row;
     private int col;
     //private int color;
     private Image image;//格子的贴图

     public Cell() {
     }

     public Cell(int row, int col, Image image) {
         super();
         this.row = row;
         this.col = col;
         this.image = image;
     }

     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 Image getImage() {
         return image;
     }

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

     public void moveRight(){
         col++;
         //System.out.println("Cell moveRight()" + col);
     }

     public void moveLeft(){
         col--;
     }

     public void moveDown(){
         row++;
     }

     @Override
     public String toString() {
         return "["+row+","+col+"]";
     }
 }

三、功能实现 Tetromino.java

package com.fry.tetris;

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

/**
 * 4格方块
 */
public class Tetromino {
    protected Cell[] cells = new Cell[4];
    /** 保存旋转的相对于轴位置状态 */
    protected State[] states;

    /** 随机生成 4格方块, 使用简单工厂方法模式!
     * randomTetromino 随机生成一个四格方块
     * 这个方面的返回值是多态的!
     * */
    public static Tetromino randomTetromino(){
        Random r = new Random();
        int type = r.nextInt(7);
        switch(type){
        case 0: return new T();
        case 1: return new I();
        case 2: return new J();
        case 3: return new L();
        case 4: return new O();
        case 5: return new S();
        case 6: return new Z();
        }
        return null;
    }

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

    /** 下落 */
    public void softDrop(){
        for(int i=0; i<cells.length; i++){
            cells[i].moveDown();
        }
    }
    public void moveRight(){
        //System.out.println("moveRight()");
        for(int i=0; i<cells.length; i++){
            this.cells[i].moveRight();
        }
    }
    public void moveLeft(){
        for(int i=0; i<cells.length; i++){
            cells[i].moveLeft();
        }
    }
    private int index = 100000;
    /** 在 Tetromino 上添加方法  */
    public void rotateRight() {
        index++;//index = 10001
        // index % states.length = 10001 % 4 = 1
        State s = states[index%states.length];//s1
        // [0] + s1 = [1]
        Cell o = cells[0];//获取当前的轴
        //轴与相对位置的和作为旋转以后的格子位置
        cells[1].setRow(o.getRow()+s.row1);
        cells[1].setCol(o.getCol()+s.col1);
        cells[2].setRow(o.getRow()+s.row2);
        cells[2].setCol(o.getCol()+s.col2);
        cells[3].setRow(o.getRow()+s.row3);
        cells[3].setCol(o.getCol()+s.col3);
    }
    /** 在 Tetromino 上添加方法  */
    public void rotateLeft() {
        index--;//index = 10001
        // index % states.length = 10001 % 4 = 1
        State s = states[index%states.length];//s1
        // [0] + s1 = [1]
        Cell o = cells[0];//获取当前的轴
        cells[1].setRow(o.getRow()+s.row1);
        cells[1].setCol(o.getCol()+s.col1);
        cells[2].setRow(o.getRow()+s.row2);
        cells[2].setCol(o.getCol()+s.col2);
        cells[3].setRow(o.getRow()+s.row3);
        cells[3].setCol(o.getCol()+s.col3);
    }

    @Override
    public String toString() {
        return Arrays.toString(cells);
    }

    /** Tetromino 类中添加的 内部类 用于记录旋转状态 */
    protected class State{
        int row0,col0,row1,col1,row2,col2,row3,col3;

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

}//Tetromino 类的结束
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[]{
                new State(0,0, 0,-1, 0,1, 1, 0),
                new State(0,0, -1,0, 1,0, 0,-1),
                new State(0,0, 0,1,  0,-1, -1,0),
                new State(0,0, 1,0, -1,0, 0,1)};
    }
}
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)};
    }
}
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)};
    }
}

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 )};
    }
}

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

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 )};
    }
}

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);
        states = new State[]{
                new State(0,0, 0,1, 1,0, 1,1 ),
                new State(0,0, 0,1, 1,0, 1,1 )};
    }
}