TETRIS 项目开发笔记

　　java学习一个月了，没有什么进展，期间又是复习Linux，又是看Android，瞻前顾后，感觉自己真的是贪得无厌，

学习的东西广而不精，所以写出的文章也就只能泛泛而谈。五一小长假，哪里都没有去，也不想去，刚刚无聊刷新了下

朋友圈，朋友们不是在玩，就是在吃，突然一下子感觉自己老了许多。岁月真是把杀猪刀，夺走了我们的青春，但却无

法夺走我们的激情。

　　好好复习了！

　　在老师引领下，算是把人生中的第一个Java项目敲完了，感觉对于学习OOP的朋友，应该有所帮助，先做个笔记吧

等后期有时间再添些自己的Feature。

package com.manue1.tetris;

import javax.swing.JFrame;

/**
 * 游戏窗口
 * @author Manue1
 * @version 1.0
 *
 */
public class GameFrame extends JFrame{
  
    private static final long serialVersionUID = 1L;
    private Tetris tetris;
    public GameFrame(){
        
        tetris =new Tetris();
        add(tetris);
        setSize(530,580);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }
  public static void main(String[] args){
      GameFrame frame =new GameFrame();
      frame.setVisible(true);
      frame.tetris.action();           //创建4个格子

  }

}

package com.manue1.tetris;

import java.awt.image.BufferedImage;

 /**
  * 定义格子
  * @author Manue1
  */
public class Cell extends Object{
    private int row; int col;
    private BufferedImage image;
    
    public Cell(int row, int col, BufferedImage 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 BufferedImage getImage() {
        return image;
    }

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

    @Override
    public String toString() {
        return "Cell [col=" + col + ", image=" + image + ", row=" + row + "]";
    }
    
    
    public void moveLeft(){
        col--;
    }
    public void moveRight(){
        col++;
    }
    public void moveDrop(){
        row++;
    }

    
}

package com.manue1.tetris;
import java.util.Arrays;
import java.util.Random;

/**
 * 4格方块 
 * 只能被子类使用
 * @author Manue1
 */
public abstract class Tetromino {

    protected Cell[] cells =new Cell[4];//{^,^,^,^}
    
    /*旋转状态
     * 
     */
    protected State[] states;
    /* 旋转状态的序号
     * 
     */
    protected int index =10000;
    /*内部类
     * 
     */
    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;
        }
    }
    /** 向右转 */
    public void rotateRight() {
    
        index++;
        State s = states[index % states.length];
        Cell o = cells[0];
        int row = o.getRow();
        int col = o.getCol();
        cells[1].setRow(row + s.row1);
        cells[1].setCol(col + s.col1);
        cells[2].setRow(row + s.row2);
        cells[2].setCol(col + s.col2);
        cells[3].setRow(row + s.row3);
        cells[3].setCol(col + s.col3);
    }
    
    /** 向左转 */
    public void rotateLeft() {
        index--;
        State s = states[index % states.length];
        Cell o = cells[0];
        int row = o.getRow();
        int col = o.getCol();
        cells[1].setRow(row + s.row1);
        cells[1].setCol(col + s.col1);
        cells[2].setRow(row + s.row2);
        cells[2].setCol(col + s.col2);
        cells[3].setRow(row + s.row3);
        cells[3].setCol(col + s.col3);
    }
    
    
    
    //工厂方法，随机产生4格方块

    public static Tetromino randomOne(){
        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 moveRight(){
        for(int i=0;i<cells.length ;i++){
            cells[i].moveRight();
        }
    }
    public void moveLeft(){
        for(int i=0;i<cells.length ;i++){
            cells[i].moveLeft();
        }
    }
    public void sofeDrop(){
        for(int i=0;i<cells.length ;i++){
            cells[i].moveDrop();
        }
    }
    //显示方块中每个格子的行列信息
    public String toString(){
        return Arrays.toString(cells);
    }

}

// 定义七类格子
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);
    }
}
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, 0, -1, 1),
                new State(0, 0, -1, 0, 0, 1, 1, 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) };
        }
}
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 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 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) };
        }
}

package com.manue1.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.util.Arrays;
import java.util.Timer;
import java.util.TimerTask;

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

/**
 * 俄罗斯方块面板
 * @author Manue1
 * @version 1.0
 */
public class Tetris extends JPanel {


    private static final long serialVersionUID = 1L;
    /*
     * 分数 墙 正在 下落的方块 下一个方块
     */
    public static final int FONT_COLOR=0x667799;
    public static final int FONT_SIZE=30;
    private int score;
    private int lines; // 销毁的行数
    private Cell[][] wall = new Cell[ROWS][COLS]; // 墙
    private Tetromino tetromino; // 正在下落的四格方块
    private Tetromino nextOne;
    public static final int ROWS = 20; // 行数
    public static final int COLS = 10; // 列数

    /*
     * 背景图片
     */
    private static BufferedImage background;
    private static BufferedImage overImage;
    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;

    /*
     * 静态代码块
     */
    static {
        try { // 从Tetris类所在的包中读取图片文件到内存对象
            background = ImageIO.read(Tetris.class.getResource("tetris.png"));
            overImage = ImageIO.read(Tetris.class.getResource("game-over.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"));
            J = ImageIO.read(Tetris.class.getResource("J.png"));
            L = ImageIO.read(Tetris.class.getResource("L.png"));
            O = ImageIO.read(Tetris.class.getResource("O.png"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 在Tetris类中重写 绘制方法 绘制背景图片
    public void paint(Graphics g) {
        g.drawImage(background, 0, 0, null);
        g.translate(15, 15); // 坐标系平移
        paintWall(g); // 画墙
        paintTetromino(g);
        paintnextOne(g);
        paintScore(g);//绘制分数
        if (gameOver) {
            g.drawImage(overImage, 0, 0, null);
        }
    }

    /*
     * 在Tetris添加启动方法action（）
     */
    public void action() {
        wall = new Cell[ROWS][COLS];
        tetromino = Tetromino.randomOne();
        nextOne = Tetromino.randomOne();
         
        /* 处理键盘按下事件, 在按下按键时候执行下落方法
         * 监听键盘事件   创建监听器对象，   注册监听器
         */
        
        this.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                int key = e.getKeyCode();// [c]

                if (key == KeyEvent.VK_Q) {//Q表示退出
                    System.exit(0);// 结束Java进程
                }
                if (gameOver) {
                    if (key == KeyEvent.VK_S) {//S表示开始
                        startAction();
                        repaint();
                    }
                    return;
                }
                if (pause) {// pause = true
                    if (key == KeyEvent.VK_C) {//C表示继续
                        continueAction();
                        repaint();
                    }
                    return;
                }
                
                
                
                
                switch (key) {
                case KeyEvent.VK_DOWN:
                    //tetromino.sofeDrop();
                    softDropAction();
                    
                    break;
                case KeyEvent.VK_RIGHT:
                    //tetromino.moveRight();
                    moveRightAction();
                    break;
                case KeyEvent.VK_LEFT:
                    //tetromino.moveLeft();
                    moveLeftAction();
                    break;
                case KeyEvent.VK_SPACE :
                   
                    hardDropAction();
                    break;
                case KeyEvent.VK_UP:
                    rotateRightAction();
                    break;
                case KeyEvent.VK_P://按键盘上的P表示暂停
                    pauseAction();
                    break;
                }
                repaint();// 再画一次!
            }
        });
        
        this.requestFocus();  //为面板请求焦点
    
        this.setFocusable(true); //面板可以获得焦点
        /*
         * 计时器 自动下落
         */
        timer = new Timer();
        timer.schedule(
                new TimerTask(){
            public void run(){
                //tetromino.sofeDrop();
                softDropAction();
                repaint();
            }
        },1000,1000);
      
        
    }

    public static final int CELL_SIZE = 26;

    /*
     * 画墙
     */

    private void paintWall(Graphics g) {
        for (int row = 0; row < wall.length; row++) {
            Cell[] line = wall[row];
            // line 代表墙上的每一行
            for (int col = 0; col < line.length; col++) {
                Cell cell = line[col];
                // cell 代表墙上的每个格子
                int x = col * CELL_SIZE;
                int y = row * CELL_SIZE;
                if (cell == null) {
                    g.drawRect(x, y, CELL_SIZE, CELL_SIZE);

                } else {
                    g.drawImage(cell.getImage(), x - 1, y - 1, null);

                }
                // g.drawString(row+","+col, x,y+CELL_SIZE);
            }
        }
    }

    /*
     * 正在下落 方块
     */
    public void paintTetromino(Graphics g) {
        if (tetromino == null) {return;} // 如果是空 直接不执行了 输入数据的有效性检测
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int x = cell.getCol() * CELL_SIZE;
            int y = cell.getRow() * CELL_SIZE;
            g.drawImage(cell.getImage(), x, y, null);
        }
    }
    /*
     * 下一个下落的方块
     */
    public void paintnextOne(Graphics g) {
        if (nextOne == null) {return;} // 如果是空 直接不执行了 输入数据的有效性检测
        Cell[] cells = nextOne.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int x = (cell.getCol()+10) * CELL_SIZE;
            int y = (cell.getRow()+1) * CELL_SIZE;
            g.drawImage(cell.getImage(), x, y, null);
        }
    }
    
    /*在Tetris类中添加方法
     * 检测正在下路方块是否出界
     */
     /** 检查当前正在下落的方块是否出界了 */
    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 coincide() {
        Cell[] cells = tetromino.cells;
        for (int i = 0; i < cells.length; i++) {
            Cell cell = cells[i];
            int row = cell.getRow();
            int col = cell.getCol();
            // 如果墙的row,col位置上有格子,就重叠了!
            if (row >= 0 && row < ROWS && col >= 0 && col <= COLS
                    && wall[row][col] != null) {
                return true;// 重叠
            }
        }
        return false;
    }
    /** 在Tetris 类上添加方法, 向右移动的流程控制 */
    public void moveRightAction() {
        // 尝试先向右移动, 如果发现超出了边界, 就
        // 向左移动, 修正回来.
        tetromino.moveRight();// coincide重叠
        if (outOfBounds() || coincide()) {
            tetromino.moveLeft();
        }
    }
    public void moveLeftAction() {
        tetromino.moveLeft();
        if (outOfBounds() || coincide()) {
            tetromino.moveRight();
        }
    }
   
    
    
    
    
    
    /* 下落流程控制
     * 
     */
  
    public void softDropAction() {
        if (canDrop()) {
            tetromino.sofeDrop();
        } else {
            landIntoWall();
            destoryLines();
                checkGameOverAction();
            tetromino = nextOne;
            nextOne = Tetromino.randomOne();
        }
    }
    public void hardDropAction(){
        while(canDrop()){
            tetromino.sofeDrop();
        }
         landIntoWall();
         destoryLines();
             checkGameOverAction();
         tetromino = nextOne;
         nextOne = Tetromino.randomOne();
        
    }
    
   
    
    
    private static int[] scoreTable={0,1,10,50,100};
   
    
    /* 调用删除行方法。循环让上面所有的行落下来

     */
    private void destoryLines() {
        int lines = 0;
        for (int row = 0; row < wall.length; row++) {
            if (fullCells(row)) {
                deleteRow(row);
                lines++;
            }
        }
        this.score += scoreTable[lines];
        this.lines += lines;
    }

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

    
    /* 判断行是否被填充
     * 
    */
    private boolean fullCells(int row){
        Cell[] line =wall[row];
         /*
        for(Cell cell : line){
            if(cell==null) return false;
           }
         */
        for(int i=0;i<line.length;i++){
            if(line[i]==null)return false;
        }
         return true;
    }
     
    
  
    /*下落到最低行停止
     * 
     */
    private void landIntoWall(){
        Cell[] cells=tetromino.cells;
        for(int i=0;i<cells.length;i++){
            Cell cell = cells[i];
            int row,col;
            row=cell.getRow();
            col=cell.getCol();
            wall[row][col]=cell;
        }
    }

    
    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) {// Java 5 以后可以使用
            int row = cell.getRow() + 1;
            int col = cell.getCol();
            if (row >= 0 && row < ROWS && col >= 0 && col <= COLS
                    && wall[row][col] != null) {
                return false;
            }
        }
        return true;
    }

    /*绘制分数
     * 
     */
    private void paintScore(Graphics g) {
        int x = 290;
        int y = 160;
        g.setColor(new Color(FONT_COLOR));
        Font font = g.getFont();// 取得g当前字体
        font = new Font(font.getName(), font.getStyle(), FONT_SIZE);
        g.setFont(font);// 更改了g的字体
        String str = "SCORE:" + score;
        g.drawString(str, x, y);
        y += 56;
        str = "LINES:" + 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);

     
    }

    
    
    /** 在Tetris类中添加 旋转流程控制方法 */
    public void rotateRightAction() {
        tetromino.rotateRight();
        if (outOfBounds() || coincide()) {
            tetromino.rotateLeft();
        }
    }
    
    
    
  /* 
   * 流程处理
   */
    private Timer timer;
    private boolean pause;//是否为暂停状态
    private boolean gameOver;//是否为游戏结束状态
    private long interval = 600;// 间隔时间
    
    
    /** 在Tetris类中添加 开始流程控制 */
    public void startAction() {
        pause = false;
        gameOver = false;
        score = 0;
        lines = 0;
        clearWall();
        tetromino = Tetromino.randomOne();
        nextOne = Tetromino.randomOne();
        timer = new Timer();
        timer.schedule(new TimerTask() {
            public void run() {
                softDropAction();
                repaint();
            }
        }, interval, interval);
    }
    /**
     * 清除墙上的方块
     */
    private void clearWall() {
        for (Cell[] line : wall) {
            Arrays.fill(line, null);
        }
    }
    /**
     * 暂停
     */
    public void pauseAction() {
        timer.cancel();
        pause = true;
    }
    /**
     * 继续
     */
    public void continueAction() {
        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                softDropAction();
                repaint();
            }
        }, interval, interval);
        pause = false;
    }
    /**
     * 游戏结束
     */
    public void checkGameOverAction() {
        if (wall[0][4] != null) {
            timer.cancel();
            gameOver = true;
        }
    }
}