俄罗斯方块(Java语言实现)

目录

一、心得

二、游戏实例

三、代码

一、心得

在学习Java的过程中，难免会遇到很多的问题，这些问题可能会困扰你许久，为此我有个Java学习交流群（925050116），里面都是CSDN的小伙伴，大家互相学习互相交流共同进步，每日分享不同的学习资料。

点击获取更多素材游戏源码！！

百度盘链接

链接：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 )};
    }
}

本文地址：https://blog.csdn.net/Sixstar_yanxin/article/details/107720468