码迷，mamicode.com
首页 > 编程语言 > 详细

Java | Tetris

时间：2018-07-23 11:09:29      阅读：160      评论：0      收藏：0      [点我收藏+]

标签：矩阵   als   amp   help   java.awt   居中   nes   mes   .com   

基于 Java-Swing 实现俄罗斯方块

Preview

普通模式：

技术分享图片

加速模式：

技术分享图片

设计思路

方块的属性

  • 方块表示：
    • 由四维数组 SHAPE[][][][] 表示7种方块及每种方块的4种翻转状态。
    • 由SHAPE[type][state]可以唯一标识一个方块。
  • 方块属性：
    • type：方块类型
    • state：方块翻转状态
    • (x, y)：方块坐标
    • nextType：下一方块类型
    • nextState：下一方块翻转状态
  • 背景块：由map[ROW][COl]表示已固定的背景块。

方块的行为

方块翻转：通过改变方块的state属性实现翻转

public void turn() {
    int temp = state;
    state = (state + 1) % 4;
    // 如果旋转后不合法，还原上一状态
    if (!check(type, state, x, y)) {
        state = temp;
    }
}

方块下落：通过改变方块纵坐标实现下落

public void down() {
    // 如果下一个下落状态合法，则下落；不合法，则固定，清行，新建块。
    if (check(type, state, x, y + 1)) {
        y++;
    } else {
        fix(type, state, x, y);
        clearLines();
        createShape();
    }
    this.repaint();
}

方块左移：通过改变方块横坐标实现左移

public void left() {
    if (check(type, state, x - 1, y)) {
        x--;
    }
}

方块右移：通过改变方块横坐标实现右移

public void right() {
    if (check(type, state, x + 1, y)) {
        x++;
    }
}

核心方法实现

方块碰撞检测：

private boolean check(int type, int state, int x, int y) {
    for (int i = 0; i < SHAPE[type][state].length; i++) {
        for (int j = 0; j < SHAPE[type][state][0].length; j++) {
            if (SHAPE[type][state][i][j] == 1) {
                // 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
                if ((x + j >= COL) || (x + j < 0) || (y + i >= ROW) || (map[y + i][x + j] == 1)) {
                    return false;
                }
            }
        }
    }
    return true;
}

固定当前方块到背景中：

private void fix(int type, int state, int x, int y) {
    for (int i = 0; i < SHAPE[type][state].length; i++) {
        for (int j = 0; j < SHAPE[type][state][0].length; j++) {
            // 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
            if ((y + i < ROW) && (x + j >= 0) && (x + j < COL) && (map[y + i][x + j] == 0)) {
                map[y + i][x + j] = SHAPE[type][state][i][j];
                mapColor[y + i][x + j] = color[type];
            }
        }
    }
}

清行加分：

private void clearLines() {
    int lines = 0;
    boolean isFull = true;
    for (int i = 0; i < map.length; i++) {
        isFull = true;
        for (int j = 0; j < map[0].length; j++) {
            if (map[i][j] == 0) {
                isFull = false;
                break;
            }
        }
        if (isFull) {
            lines++;
            for (int m = i; m > 0; m--) {
                for (int n = 0; n < map[0].length; n++) {
                    map[m][n] = map[m - 1][n];
                }
            }
        }
    }
    score += lines * lines * 10;
    if (isAccelMode) {
        up();
    }
}

GUI

绘制图形：重写paint()方法，使用Graphics类随意绘制。

Graphics类绘制方法如下：

setColor(Color color);  // 设置画笔颜色
drawRect(int x,int y,int width,int height);  // 绘制矩形边框
fillRect(int x,int y,int width,int height);  // 填充矩形
fill3DRect(int x,int y,int width,int height, boolean raised); // 填充3D矩形。
drawLine(x1,y1,x2,y2);  // 绘制线条
setFont(Font font); // 设置字体
drawString(String text, int x, int y);  // 绘制字符串

文件目录

com.lizich.tetris下：

.
|——TetrisMain  # 游戏窗口，由此运行
|——TetrisCtrl  # 绘制游戏面板&游戏逻辑

com.lizi.tetris.singleclass下：

.
|——Tetris # 合并了TetrisMain与TetrisCtrl

源码

TetrisMain

package com.liziczh.tetris;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;

public class TetrisMain extends JFrame {

    /**
     * 版本号
     */
    private static final long serialVersionUID = 1L;
    // 游戏面板
    private TetrisCtrl tCtrl = new TetrisCtrl();

    /**
     * 游戏窗口初始化
     */
    public TetrisMain() {
        // 设置标题
        this.setTitle("Lizi Tetris");
        // 设置大小
        this.setSize(tCtrl.getSize());
        // 调用方法居中
        this.setLocationRelativeTo(null);
        // 设置关闭操作：关闭窗口，程序结束运行；
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置窗体大小不改变
        this.setResizable(false);
        // 添加键盘监听事件
        this.addKeyListener(keyListener);

        // 菜单栏
        JMenuBar menu = new JMenuBar();
        this.setJMenuBar(menu);
        JMenu gameMenu = new JMenu("游戏");
        JMenuItem newGameItem = gameMenu.add("新游戏");
        newGameItem.addActionListener(newGameAction);
        JMenuItem pauseItem = gameMenu.add("暂停");
        pauseItem.addActionListener(pauseAction);
        JMenuItem continueItem = gameMenu.add("继续");
        continueItem.addActionListener(continueAction);
        JMenuItem exitItem = gameMenu.add("退出");
        exitItem.addActionListener(exitAction);
        JMenu modeMenu = new JMenu("模式");
        JMenuItem normalModeItem = modeMenu.add("普通模式");
        normalModeItem.addActionListener(normalModeAction);
        JMenuItem accelModeItem = modeMenu.add("加速模式");
        accelModeItem.addActionListener(accelModeAction);
        JMenu helpMenu = new JMenu("帮助");
        JMenuItem aboutItem = helpMenu.add("关于");
        aboutItem.addActionListener(aboutAction);
        menu.add(gameMenu);
        menu.add(modeMenu);
        menu.add(helpMenu);
        // 设置窗口可见
        this.setVisible(true);
        // 添加TetrisPanel
        this.add(tCtrl);

    }

    // 键盘事件监听
    KeyListener keyListener = new KeyAdapter() {

        @Override
        public void keyPressed(KeyEvent e) {
            switch (e.getKeyCode()) {
            case KeyEvent.VK_UP:
                // ↑：旋转
                tCtrl.turn();
                tCtrl.repaint();
                break;
            case KeyEvent.VK_LEFT:
                // ←：左移
                tCtrl.left();
                tCtrl.repaint();
                break;
            case KeyEvent.VK_RIGHT:
                // →：右移
                tCtrl.right();
                tCtrl.repaint();
                break;
            case KeyEvent.VK_DOWN:
                // ↓：下移
                tCtrl.down();
                tCtrl.repaint();
                break;
            }
        }
    };

    // 新游戏
    ActionListener newGameAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent arg0) {
            tCtrl.init();
        }
    };
    // 暂停
    ActionListener pauseAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent arg0) {
            tCtrl.setPause();
        }
    };
    // 继续
    ActionListener continueAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            tCtrl.setContinue();
        }
    };

    // 退出
    ActionListener exitAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            System.exit(0);
        }
    };

    // 普通模式
    ActionListener normalModeAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            tCtrl.setNormal();
        }
    };

    // 加速模式
    ActionListener accelModeAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            tCtrl.setAccel();
        }
    };

    // 关于
    ActionListener aboutAction = new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            JOptionPane.showMessageDialog(tCtrl, "Tetris v1.0 from liziczh", "关于", getDefaultCloseOperation());
        }
    };

    public static void main(String[] args) {
        new TetrisMain();
    }

}

TetrisCtrl：

package com.liziczh.tetris;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

public class TetrisCtrl extends JPanel {

    /**
     * 版本号
     */
    private static final long serialVersionUID = 1L;

    // 方块边长，单位像素(px)
    public final int LEN = 24;

    // Panel区域：20行10列
    public final int ROW = 20;
    public final int COL = 10;

    /**
     * SHAPE[type][state]：方块形状； type方块类型， state方块旋转状态；
     */
    private final int[][][][] SHAPE = new int[][][][] {
            // S:
            { { { 0, 1, 1, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 1, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } } },
            // Z:
            { { { 1, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 1, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 1, 0, 0, 0 }, { 0, 0, 0, 0 } } },
            // L:
            { { { 1, 0, 0, 0 }, { 1, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 1, 1, 0 }, { 1, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 0, 1, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
            // J:
            { { { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 1, 0, 0 }, { 1, 0, 0, 0 }, { 1, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 1, 1, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
            // I:
            { { { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
            // O:
            { { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } } },
            // T:
            { { { 0, 1, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } },
                    { { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } } },

    };

    // 当前方块的四个参数：type方块类型，state方块旋转状态，坐标(x,y)。
    private int type, state, x, y;
    // 下一个块的参数：nextType方块类型，nextState方块旋转状态
    private int nextType, nextState;

    // 背景：已固定块
    private int[][] map = new int[ROW][COL];
    // 已固定块的颜色
    private Color[][] mapColor = new Color[ROW][COL];

    // 得分
    private int score = 0;
    // 等级
    private int level = 0;
    // 下落延时
    private int delay = 1000;

    // 是否在暂停状态
    private boolean isPause = false;

    // 是否为加速模式
    private boolean isAccelMode = false;

    // 方块颜色：color[type]
    private Color[] color = new Color[] { Color.green, Color.red, Color.orange, Color.blue, Color.cyan, Color.yellow,
            Color.magenta, Color.gray };

    public TetrisCtrl() {
        // 初始化Panel大小
        this.setSize(LEN * 20, LEN * 25);
        this.init();
    }

    /**
     * 游戏初始化
     */
    public void init() {
        // 初始化背景map
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                map[i][j] = 0;
            }
        }
        // 初始化分数
        score = 0;
        isPause = false;
        // 随机生成下一方块
        nextType = (int) (Math.random() * 7);
        nextState = (int) (Math.random() * 4);
        // 生成当前方块
        createShape();

        // 启动timer
        timer.start();
        // 绘图
        this.repaint();
    }

    /**
     * 创建一个新方块
     */
    public void createShape() {
        // 当前块
        type = nextType;
        state = nextState;
        x = 3;
        y = 0;
        // 下一块
        nextType = (int) (Math.random() * 7);
        nextState = (int) (Math.random() * 4);
        // 如果新块不合法，则表示游戏已结束，则重新开始
        if (!check(type, state, x, y)) {
            JOptionPane.showMessageDialog(this, "GAME OVER!");
            init();
        }
    }

    /**
     * 判断方块是否合法：true合法，false不合法
     */
    private boolean check(int type, int state, int x, int y) {
        for (int i = 0; i < SHAPE[type][state].length; i++) {
            for (int j = 0; j < SHAPE[type][state][0].length; j++) {
                if (SHAPE[type][state][i][j] == 1) {
                    // 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
                    if ((x + j >= COL) || (x + j < 0) || (y + i >= ROW) || (map[y + i][x + j] == 1)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     * 固定shape到map
     */
    private void fix(int type, int state, int x, int y) {
        for (int i = 0; i < SHAPE[type][state].length; i++) {
            for (int j = 0; j < SHAPE[type][state][0].length; j++) {
                // 在坐标系中小方块坐标(x+j,y+i);在背景矩阵中小方块位置map[y+i][x+j];
                if ((y + i < ROW) && (x + j >= 0) && (x + j < COL) && (map[y + i][x + j] == 0)) {
                    map[y + i][x + j] = SHAPE[type][state][i][j];
                    mapColor[y + i][x + j] = color[type];
                }
            }
        }
    }

    /**
     * 消行加分
     */
    private void clearLines() {
        int lines = 0;
        boolean isFull = true;
        for (int i = 0; i < map.length; i++) {
            isFull = true;
            for (int j = 0; j < map[0].length; j++) {
                if (map[i][j] == 0) {
                    isFull = false;
                    break;
                }
            }
            if (isFull) {
                lines++;
                for (int m = i; m > 0; m--) {
                    for (int n = 0; n < map[0].length; n++) {
                        map[m][n] = map[m - 1][n];
                    }
                }
            }
        }
        score += lines * lines * 10;
        if (isAccelMode) {
            up();
        }

    }

    /**
     * 升级加速：UP
     */
    public void up() {
        int limit = 50;
        if (score > limit * level) {
            level++;
            delay /= 1.5;
            timer.setDelay(delay);
            limit = limit * level;
        }
    }

    public void turn() {
        int temp = state;
        state = (state + 1) % 4;
        // 如果旋转后不合法，还原上一状态
        if (!check(type, state, x, y)) {
            state = temp;
        }
    }

    public void down() {
        // 如果下一个下落状态合法，则下落；不合法，则固定。
        if (check(type, state, x, y + 1)) {
            y++;
        } else {
            fix(type, state, x, y);
            clearLines();
            createShape();
        }
        this.repaint();
    }

    public void right() {
        if (check(type, state, x + 1, y)) {
            x++;
        }
    }

    public void left() {
        if (check(type, state, x - 1, y)) {
            x--;
        }
    }

    /**
     * 绘图：重写paint()方法
     * 
     * @see javax.swing.JComponent#paint(java.awt.Graphics)
     */
    @Override
    public void paint(Graphics g) {
        // 游戏区域的左、上边距
        int MARGIN_LEFT = LEN;
        int MARGIN_TOP = LEN + 10;

        // 边栏的起始坐标
        int SIDEBAR_X = LEN * 13;// 文本的横坐标
        int SIDEBAR_Y = LEN * 9; // 文本的纵坐标
        /**
         * 填充背景色
         */
        g.setColor(Color.white);
        g.fillRect(0, 0, (int) (this.getSize().getWidth()), (int) (this.getSize().getHeight()));

        /**
         * 画边框
         */
        g.setColor(Color.gray);
        for (int offset = 1; offset < 2; offset++) {
            // 绘制矩形边框：drawRect(int x,int y,int width,int height);
            g.drawRect(MARGIN_LEFT - offset, MARGIN_TOP - offset, COL * LEN + offset * 2, ROW * LEN + offset * 2);
        }
        /**
         * 画网状线
         */
        g.setColor(Color.gray);
        // 11条竖线
        for (int i = 0; i < 11; i++) {
            // 绘制线条：drawLine(x1,y1,x2,y2);
            g.drawLine(MARGIN_LEFT + LEN * i, MARGIN_TOP, MARGIN_LEFT + LEN * i, MARGIN_TOP + ROW * LEN);
        }
        // 21条横线
        for (int i = 0; i < 21; i++) {
            g.drawLine(MARGIN_LEFT, MARGIN_TOP + LEN * i, MARGIN_LEFT + COL * LEN, MARGIN_TOP + LEN * i);
        }
        /**
         * 画侧栏
         */
        // 画文本：下一个
        g.setColor(Color.gray);
        g.setFont(new Font("Times", Font.BOLD, 20));
        g.drawString("下一个：", SIDEBAR_X, LEN * 2 + 10);
        // 画提示方块（下一个方块）
        g.setColor(color[nextType]);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (SHAPE[nextType][nextState][i][j] == 1) {
                    // 填充3D矩形：fill3DRect(int x,int y,int width,int height,boolean raised)
                    g.fill3DRect(SIDEBAR_X + 20 + j * LEN, LEN * 3 + i * LEN, LEN, LEN, true);
                }
            }
        }
        // 画文本：得分
        g.setColor(Color.gray);
        g.setFont(new Font("Times", Font.BOLD, 24));
        g.drawString("等级：" + level, SIDEBAR_X, SIDEBAR_Y);
        g.drawString("得分：" + score, SIDEBAR_X, SIDEBAR_Y + 40);
        // 画文本：游戏说明
        g.setColor(Color.gray);
        g.setFont(new Font("Times", Font.BOLD, 15));
        g.drawString("玩法：", SIDEBAR_X, SIDEBAR_Y + LEN * 4);
        g.drawString("上箭头：旋转", SIDEBAR_X, SIDEBAR_Y + LEN * 5);
        g.drawString("左箭头：左移", SIDEBAR_X, SIDEBAR_Y + LEN * 6);
        g.drawString("右箭头：右移", SIDEBAR_X, SIDEBAR_Y + LEN * 7);
        g.drawString("下箭头：下落", SIDEBAR_X, SIDEBAR_Y + LEN * 8);
        g.drawString("@栗子", SIDEBAR_X, SIDEBAR_Y + LEN * 10);

        // 画当前下落块
        g.setColor(color[type]);
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (SHAPE[type][state][i][j] == 1) {
                    g.fill3DRect(MARGIN_LEFT + (x + j) * LEN, MARGIN_TOP + (y + i) * LEN, LEN, LEN, true);
                }
            }
        }

        // 画背景map
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[0].length; j++) {
                if (map[i][j] == 1) {
                    g.setColor(mapColor[i][j]);
                    g.fill3DRect(MARGIN_LEFT + j * LEN, MARGIN_TOP + i * LEN, LEN, LEN, true);
                }
            }
        }

        // 画暂停
        if (isPause) {
            g.setColor(Color.black);
            g.drawString("PAUSE", MARGIN_LEFT + LEN * 8, LEN);
        }

        // 画普通模式
        if (!isAccelMode) {
            g.setColor(Color.black);
            g.drawString("Normal Mode", LEN, LEN);
        }
        // 画加速模式
        if (isAccelMode) {
            g.setColor(Color.black);
            g.drawString("Accel Mode", LEN, LEN);
        }

    }

    /**
     * 定时器
     */
    Timer timer = new Timer(delay, new ActionListener() {
        // 定时器任务
        @Override
        public void actionPerformed(ActionEvent e) {
            down();
        }
    });

    // 暂停
    public void setPause() {
        timer.stop();
        isPause = true;
        this.repaint();
    }

    // 继续
    public void setContinue() {
        timer.restart();
        isPause = false;
        this.repaint();
    }

    // 简单模式
    public void setNormal() {
        isAccelMode = false;
        level = 0;
        timer.setDelay(1000);
        init();
    }

    // 加速模式
    public void setAccel() {
        isAccelMode = true;
        level = 1;
        timer.setDelay(500);
        init();
    }

}

Java | Tetris

标签：矩阵   als   amp   help   java.awt   居中   nes   mes   .com   

原文地址：https://www.cnblogs.com/liziczh/p/9353027.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！