Java俄罗斯方块代码（转载）

最新推荐文章于 2021-09-03 16:58:01 发布
最新推荐文章于 2021-09-03 16:58:01 发布
阅读量1.5k 收藏 11
点赞数
分类专栏： Java-Code 文章标签： java 俄罗斯方块 
package com.learn.tetris;


import java.awt.Button;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.WindowListener;


//俄罗斯方块类
public class ERS_Block extends Frame {
    public static boolean isPlay = false;
    public static int level = 1, score = 0;
    public static TextField scoreField, levelField;
    public static MyTimer timer;
    GameCanvas gameScr;


    public static void main(String[] argus) {
        ERS_Block ers = new ERS_Block("The Tetris V1.0                   Author:proteena_LJK");
        WindowListener win_listener = new WinListener();
        ers.addWindowListener(win_listener);
    }


    // 俄罗斯方块类的构造方法
    ERS_Block(String title) {
        super(title);
        setSize(600, 480);
        setLayout(new GridLayout(1, 2));
        gameScr = new GameCanvas();
        gameScr.addKeyListener(gameScr);
        timer = new MyTimer(gameScr);
        timer.setDaemon(true);
        timer.start();
        timer.suspend();
        add(gameScr);
        Panel rightScr = new Panel();
        rightScr.setLayout(new GridLayout(2, 1, 0, 30));
        rightScr.setSize(120, 500);
        add(rightScr);
        // 右边信息窗体的布局
        MyPanel infoScr = new MyPanel();
        infoScr.setLayout(new GridLayout(4, 1, 0, 5));
        infoScr.setSize(120, 300);
        rightScr.add(infoScr);
        // 定义标签和初始值
        Label scorep = new Label("Score:", Label.LEFT);
        Label levelp = new Label("Level:", Label.LEFT);
        scoreField = new TextField(8);
        levelField = new TextField(8);
        scoreField.setEditable(false);
        levelField.setEditable(false);
        infoScr.add(scorep);
        infoScr.add(scoreField);
        infoScr.add(levelp);
        infoScr.add(levelField);
        scorep.setSize(new Dimension(20, 60));
        scoreField.setSize(new Dimension(20, 60));
        levelp.setSize(new Dimension(20, 60));
        levelField.setSize(new Dimension(20, 60));
        scoreField.setText("0");
        levelField.setText("1");
        // 右边控制按钮窗体的布局
        MyPanel controlScr = new MyPanel();
        controlScr.setLayout(new GridLayout(5, 1, 0, 5));
        rightScr.add(controlScr);
        // 定义按钮play
        Button play_b = new Button("Play");
        play_b.setSize(new Dimension(50, 200));
        play_b.addActionListener(new Command(Command.button_play, gameScr));
        // 定义按钮Level UP
        Button level_up_b = new Button("Level UP");
        level_up_b.setSize(new Dimension(50, 200));
        level_up_b.addActionListener(new Command(Command.button_levelup, gameScr));
        // 定义按钮Level Down
        Button level_down_b = new Button("Level Down");
        level_down_b.setSize(new Dimension(50, 200));
        level_down_b.addActionListener(new Command(Command.button_leveldown, gameScr));
        // 定义按钮Level Pause
        Button pause_b = new Button("Pause");
        pause_b.setSize(new Dimension(50, 200));
        pause_b.addActionListener(new Command(Command.button_pause, gameScr));
        // 定义按钮Quit
        Button quit_b = new Button("Quit");
        quit_b.setSize(new Dimension(50, 200));
        quit_b.addActionListener(new Command(Command.button_quit, gameScr));
        controlScr.add(play_b);
        controlScr.add(level_up_b);
        controlScr.add(level_down_b);
        controlScr.add(pause_b);
        controlScr.add(quit_b);
        setVisible(true);
        gameScr.requestFocus();
    }
}










package com.learn.tetris;


import java.awt.Insets;
import java.awt.Panel;


//重写MyPanel类，使Panel的四周留空间
public class MyPanel extends Panel {
    public Insets getInsets() {
        return new Insets(30, 50, 30, 50);
    }
}










package com.learn.tetris;


import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;


//游戏画布类
public class GameCanvas extends Canvas implements KeyListener {


    final int unitSize = 30; // 小方块边长
    int rowNum; // 正方格的行数
    int columnNum; // 正方格的列数
    int maxAllowRowNum; // 允许有多少行未削
    int blockInitRow; // 新出现块的起始行坐标
    int blockInitCol; // 新出现块的起始列坐标
    int[][] scrArr; // 屏幕数组
    Block b; // 对方快的引用


    // 画布类的构造方法
    GameCanvas() {
        rowNum = 15;
        columnNum = 10;
        maxAllowRowNum = rowNum - 2;
        b = new Block(this);
        blockInitRow = rowNum - 1;
        blockInitCol = columnNum / 2 - 2;
        scrArr = new int[32][32];
    }


    // 初始化屏幕，并将屏幕数组清零的方法
    void initScr() {
        for (int i = 0; i < rowNum; i++)
            for (int j = 0; j < columnNum; j++)
                scrArr[i][j] = 0;
        b.reset();
        repaint();
    }


    // 重新刷新画布方法
    public void paint(Graphics g) {
        for (int i = 0; i < rowNum; i++)
            for (int j = 0; j < columnNum; j++)
                drawUnit(i, j, scrArr[i][j]);
    }


    // 画方块的方法
    public void drawUnit(int row, int col, int type) {
        scrArr[row][col] = type;
        Graphics g = getGraphics();
        switch (type) { // 表示画方快的方法
        case 0:
            g.setColor(Color.black);
            break; // 以背景为颜色画
        case 1:
            g.setColor(Color.blue);
            break; // 画正在下落的方块
        case 2:
            g.setColor(Color.magenta);
            break; // 画已经落下的方法
        }
        g.fill3DRect(col * unitSize, getSize().height - (row + 1) * unitSize, unitSize, unitSize, true);
        g.dispose();
    }


    public Block getBlock() {
        return b; // 返回block实例的引用
    }


    // 返回屏幕数组中(row,col)位置的属性值
    public int getScrArrXY(int row, int col) {
        if (row < 0 || row >= rowNum || col < 0 || col >= columnNum)
            return (-1);
        else
            return (scrArr[row][col]);
    }


    // 返回新块的初始行坐标方法
    public int getInitRow() {
        return (blockInitRow); // 返回新块的初始行坐标
    }


    // 返回新块的初始列坐标方法
    public int getInitCol() {
        return (blockInitCol); // 返回新块的初始列坐标
    }


    // 满行删除方法
    void deleteFullLine() {
        int full_line_num = 0;
        int k = 0;
        for (int i = 0; i < rowNum; i++) {
            boolean isfull = true;
            L1: for (int j = 0; j < columnNum; j++)
                if (scrArr[i][j] == 0) {
                    k++;
                    isfull = false;
                    break L1;
                }
            if (isfull)
                full_line_num++;
            if (k != 0 && k - 1 != i && !isfull)
                for (int j = 0; j < columnNum; j++) {
                    if (scrArr[i][j] == 0)
                        drawUnit(k - 1, j, 0);
                    else
                        drawUnit(k - 1, j, 2);
                    scrArr[k - 1][j] = scrArr[i][j];
                }
        }
        for (int i = k - 1; i < rowNum; i++) {
            for (int j = 0; j < columnNum; j++) {
                drawUnit(i, j, 0);
                scrArr[i][j] = 0;
            }
        }
        ERS_Block.score += full_line_num;
        ERS_Block.scoreField.setText("" + ERS_Block.score);
    }


    // 判断游戏是否结束方法
    boolean isGameEnd() {
        for (int col = 0; col < columnNum; col++) {
            if (scrArr[maxAllowRowNum][col] != 0)
                return true;
        }
        return false;
    }


    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
        if (!ERS_Block.isPlay)
            return;
        switch (e.getKeyCode()) {
        case KeyEvent.VK_DOWN:
            b.fallDown();
            break;
        case KeyEvent.VK_LEFT:
            b.leftMove();
            break;
        case KeyEvent.VK_RIGHT:
            b.rightMove();
            break;
        case KeyEvent.VK_UP:
            b.leftTurn();
            break;
        }
    }


    @Override
    public void keyReleased(KeyEvent arg0) {
        // TODO Auto-generated method stub


    }


    @Override
    public void keyTyped(KeyEvent arg0) {
        // TODO Auto-generated method stub


    }


}










package com.learn.tetris;


import java.awt.event.ActionEvent;
import java.beans.PropertyChangeListener;


import javax.swing.Action;


//处理控制类
public class Command implements Action {


    static final int button_play = 1; // 给按钮分配编号
    static final int button_levelup = 2;
    static final int button_leveldown = 3;
    static final int button_quit = 4;
    static final int button_pause = 5;
    static boolean pause_resume = true;
    int curButton; // 当前按钮
    GameCanvas scr;


    // 控制按钮类的构造方法
    Command(int button, GameCanvas scr) {
        curButton = button;
        this.scr = scr;
    }


    // 按钮执行方法
    @Override
    public void actionPerformed(ActionEvent e) {
        switch (curButton) {
        case button_play:
            if (!ERS_Block.isPlay) {
                scr.initScr();
                ERS_Block.isPlay = true;
                ERS_Block.score = 0;
                ERS_Block.scoreField.setText("0");
                ERS_Block.timer.resume();
            }
            scr.requestFocus();
            break;
        case button_levelup:
            if (ERS_Block.level < 10) {
                ERS_Block.level++;
                ERS_Block.levelField.setText("" + ERS_Block.level);
                ERS_Block.score = 0;
                ERS_Block.scoreField.setText("" + ERS_Block.score);
            }
            scr.requestFocus();
            break;
        case button_leveldown:
            if (ERS_Block.level > 1) {
                ERS_Block.level--;
                ERS_Block.levelField.setText("" + ERS_Block.level);
                ERS_Block.score = 0;
                ERS_Block.scoreField.setText("" + ERS_Block.score);
            }
            scr.requestFocus();
            break;
        case button_pause:
            if (pause_resume) {
                ERS_Block.timer.suspend();
                pause_resume = false;
            } else {
                ERS_Block.timer.resume();
                pause_resume = true;
            }
            scr.requestFocus();
            break;
        case button_quit:
            System.exit(0);
        }
    }


    @Override
    public void addPropertyChangeListener(PropertyChangeListener arg0) {
        // TODO Auto-generated method stub


    }


    @Override
    public Object getValue(String arg0) {
        // TODO Auto-generated method stub
        return null;
    }


    @Override
    public boolean isEnabled() {
        // TODO Auto-generated method stub
        return false;
    }


    @Override
    public void putValue(String arg0, Object arg1) {
        // TODO Auto-generated method stub


    }


    @Override
    public void removePropertyChangeListener(PropertyChangeListener arg0) {
        // TODO Auto-generated method stub


    }


    @Override
    public void setEnabled(boolean arg0) {
        // TODO Auto-generated method stub


    }


}










package com.learn.tetris;


//方块类
public class Block {
    static int[][] pattern = { { 0x0f00, 0x4444, 0x0f00, 0x4444 }, // 用十六进至表示，本行表示长条四种状态
            { 0x04e0, 0x0464, 0x00e4, 0x04c4 }, { 0x4620, 0x6c00, 0x4620, 0x6c00 }, { 0x2640, 0xc600, 0x2640, 0xc600 },
            { 0x6220, 0x1700, 0x2230, 0x0740 }, { 0x6440, 0x0e20, 0x44c0, 0x8e00 },
            { 0x0660, 0x0660, 0x0660, 0x0660 } };
    int blockType; // 块的模式号（0-6）
    int turnState; // 块的翻转状态（0-3）
    int blockState; // 快的下落状态
    int row, col; // 块在画布上的坐标
    GameCanvas scr;


    // 块类的构造方法
    Block(GameCanvas scr) {
        this.scr = scr;
        blockType = (int) (Math.random() * 1000) % 7;
        turnState = (int) (Math.random() * 1000) % 4;
        blockState = 1;
        row = scr.getInitRow();
        col = scr.getInitCol();
    }


    // 重新初始化块，并显示新块
    public void reset() {
        blockType = (int) (Math.random() * 1000) % 7;
        turnState = (int) (Math.random() * 1000) % 4;
        blockState = 1;
        row = scr.getInitRow();
        col = scr.getInitCol();
        dispBlock(1);
    }


    // 实现“块”翻转的方法
    public void leftTurn() {
        if (assertValid(blockType, (turnState + 1) % 4, row, col)) {
            dispBlock(0);
            turnState = (turnState + 1) % 4;
            dispBlock(1);
        }
    }


    // 实现“块”的左移的方法
    public void leftMove() {
        if (assertValid(blockType, turnState, row, col - 1)) {
            dispBlock(0);
            col--;
            dispBlock(1);
        }
    }


    // 实现块的右移
    public void rightMove() {
        if (assertValid(blockType, turnState, row, col + 1)) {
            dispBlock(0);
            col++;
            dispBlock(1);
        }
    }


    // 实现块落下的操作的方法
    public boolean fallDown() {
        if (blockState == 2)
            return (false);
        if (assertValid(blockType, turnState, row - 1, col)) {
            dispBlock(0);
            row--;
            dispBlock(1);
            return (true);
        } else {
            blockState = 2;
            dispBlock(2);
            return (false);
        }
    }


    // 判断是否正确的方法
    boolean assertValid(int t, int s, int row, int col) {
        int k = 0x8000;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if ((int) (pattern[t][s] & k) != 0) {
                    int temp = scr.getScrArrXY(row - i, col + j);
                    if (temp < 0 || temp == 2)
                        return false;
                }
                k = k >> 1;
            }
        }
        return true;
    }


    // 同步显示的方法
    public synchronized void dispBlock(int s) {
        int k = 0x8000;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (((int) pattern[blockType][turnState] & k) != 0) {
                    scr.drawUnit(row - i, col + j, s);
                }
                k = k >> 1;
            }
        }
    }
}










package com.learn.tetris;


//定时线程
public class MyTimer extends Thread {
    GameCanvas scr;


    public MyTimer(GameCanvas scr) {
        this.scr = scr;
    }


    public void run() {
        while (true) {
            try {
                sleep((10 - ERS_Block.level + 1) * 100);
            } catch (InterruptedException e) {
            }
            if (!scr.getBlock().fallDown()) {
                scr.deleteFullLine();
                if (scr.isGameEnd()) {
                    ERS_Block.isPlay = false;
                    suspend();
                } else
                    scr.getBlock().reset();
            }
        }
    }
}










package com.learn.tetris;


import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;


public class WinListener extends WindowAdapter {
    public void windowClosing(WindowEvent l) {
        System.exit(0);
    }
}
proteena_LJK
关注
专栏目录
新手向！超详细！Java俄罗斯方块程序面向对象编程全记录
Baishu的专栏
10-22 5万+
零、写在开始之前 新人，Java学习中，文章中遗漏错误之处，欢迎斧正 个人博客，完全原创 转载请注明出处。 项目全代码地址：GitHub 一、从面向对象的开始，将对象抽象成类面对一个程序or实际项目，个人会选择从程序的表面入手，从入目可及的实例对象出发，一步步抽象成类。 对于如何使用面向对象的思想去分析一个项目时，我的理解是： 首先去找出对象间的共性，以此来设计出最基本的
android俄罗斯方块完整代码
热门推荐
我的IT追求
12-02 3万+
这段时间一直没有更新自己的博客，很多东西不经常看看会生疏了许多。在这里我就把自己前段时间编写的android俄罗斯方块代码贴出来。                                                                            转载请注明出处~~~~~~~~~~~~~~~~谢谢！
Java俄罗斯方块(源码)
04-23
俄罗斯方块小游戏的Java源代码，俄罗斯方块的Java 实现，里面包括控制面板类、方格类、游戏控制主类等，方格类是组成块的基本元素，用自己的颜色来表示块的外观，俄罗斯方块游戏控制面板类，继承自JPanel.上边安放预显窗口、等级、得分、控制按钮，主要用来控制游戏进程。 　　游戏主类，继承自JFrame类，负责游戏的全局控制，内含： 　　1, 一个GameCanvas画布类的实例引用， 　　2, 一个保存当前活动块(ErsBlock)实例的引用， 　　3, 一个保存当前控制面板（ControlPanel）实例的引用; 　　俄罗斯方块控制面板类的构造函数： 　　@param game ErsBlocksGame, ErsBoxesGame类的一个实例引用，方便直接控制ErsBoxesGame类的行为。让用户修改游戏难度等级。 　　@param level 修改后的游戏难度等级，当用户消灭一行方块后，重新计算TipPanel里的boxes[][]里的小框的大小。。 转自源码爱好者
俄罗斯方块的JAVA版代码
07-02
/* * 俄罗斯方块算法包括四个方面： * 1、自动生成方块：在游戏的进行当中，当上一个方块落定之后，随机地产生不同形状的方块 * 2、控制方块移动、下落和变形等：如果方块需要变形，则方块按顺时针进行旋转， 再根据需要进行平行移动，这时候记录方块的坐标将随之改变，最后是将方块 下落到既定的位置。 * 3、消行并积分：当方块排成整齐的一行后，设定的行标志将标志该行的方块可以消去， * 这时候将根据积分原则给游戏者加分。 * 4、判断游戏胜负：当游戏者的本轮积分达到某个规定值时，则认为游戏者已经获胜， * 并提高相应的游戏等级；如果在未到达积分规定值前，方块就到达了俄罗斯方块 * 游戏界面的顶部，则宣布游戏者失败，并扣除游戏者一定的积分。 * 该游戏代码包含5个类： * 1、ErsBlocksGame ; * 2、GameCanvas; * 3、ControlPanel; * 4、ErsBlock; * 5、ErsBox; * 功能可分为三个部分： * 1、俄罗斯方块构建游戏图形主界面。 * 2、俄罗斯方块构建图形方格。 * 3、完成控制俄罗斯方块的各种动作。 */
俄罗斯方块JAVA源代码
08-22
闲时无聊，用Java写了一个小时候经常玩的俄罗斯方块小游戏（里面有源代码和编译好的可执行jar包）。 运行环境jdk1.8 源码使用方法：打开eclipse，新建一个java project然后把tetris目录复制到project里的src目录下。
java俄罗斯方块源码
07-19
主要介绍了Java 小游戏开发之俄罗斯方块的相关资料,这里实现俄罗斯方块的实例和实现效果给大家看下，学习java基础的朋友的好资料，需要的朋友可以参考下
java俄罗斯方块源代码
03-24
java入门基础，俄罗斯方块游戏开发：游戏等级包括高，中，低三个等级。方块样式自定义，排行榜，方块墙体上升等。丰富的音效，方块投影效果。
java俄罗斯方块源码-GoodSourceCodes:好源代码
06-05
java俄罗斯方块源码 GoodSourceCodes -- 作者：auxten 链接： 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 碰巧读过之前大家提到的一些开源项目 网络编程： redis是单线程...
java俄罗斯方块源码-nlp_olami_exchangerate_java_demo:自然语言汇率过程的javademo
06-05
java俄罗斯方块源码 nlp_olami_exchangerate_java_demo a java demo of nature language process of exchange rate. #自然语言理解 之 汇率换算 ##用olami开放语义实现汇率换算功能 >>>>>>>>>>>>>>>>>>>>>>>> 欢迎...
让你从入门到工作——Java基础＞JavaWeb前端＞数据库＞动态网页＞微服务框架＞SSM＞高级框架＞分布式＞进阶＞面试
编程领域的博客
09-03 358
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的 Java编程 Java基础 Java基础是java初学者的起点，是帮助你从小白入门到精通必学基础课程！ 为初学者而著！ java300集>>>适合准备入行开发的零基础员学习Java，基于最新JDK13、IDEA平台讲解的，视频中穿插多个实战项目。每一个知识点都讲解的通俗易懂，由浅入深。不仅适用于零基础的初学者，有经验的程序员也可做巩固学习。 Java基础板块知识： .
java 俄罗斯方块代码
06-14
java 俄罗斯方块代码下载即可运行、还不错 里面注解很详细 有兴趣的朋友可以是玩一下
Java 俄罗斯方块完整代码
09-30
java编写的俄罗斯方块完整代码. 非常适合用于教学使用;
java俄罗斯方块（源码）
01-11
俄罗斯方块java，新手锻炼自己代码用的吧，欢迎下载！！！！！！！
俄罗斯方块java语言源代码
10-22
俄罗斯方块，java语言写的，啦啦啦啦啦绿啦咯啦咯啦咯啦咯啦
java俄罗斯方块简单代码_Java实现简易俄罗斯方块
weixin_39558521的博客
02-13 2836
本文实例为大家分享了Java实现简易俄罗斯方块的具体代码，供大家参考，具体内容如下一、将对象抽象为类首先考虑俄罗斯方块游戏中含有哪些具体的对象，对象中含有哪些具体属性和方法，然后用代码来实现。建立如下类：Cell类：代表最小的方格单位，构成7种图形的最基本图形。含有row(行号)，col(列号)，image(对应的图片)属性，含有left(左移)，right(右移)，drop(下落)方法。Tetr...
java俄罗斯方块代码_java俄罗斯方块游戏代码
weixin_39867296的博客
02-15 269
1 packagecom;23 importjava.awt.Color;4 importjava.awt.Graphics;5 importjava.awt.event.KeyEvent;6 importjava.awt.event.KeyListener;7 importjava.util.Random;89 importjavax.swing.JFrame;10 importjavax.sw...
俄罗斯方块java代码_java的俄罗斯方块代码
weixin_33364945的博客
02-12 551
展开全部俄罗斯方块——java源代码提供import java.awt.*;import java.awt.event.*;//俄罗斯方块类62616964757a686964616fe59b9ee7ad9431333231393039public class ERS_Block extends Frame{public static boolean isPlay=false;public sta...
java俄罗斯方块程序,java实现俄罗斯方块程序代码
weixin_33821493的博客
03-21 194
import java.util.Random;import javax.microedition.lcdui.Canvas;import javax.microedition.lcdui.Graphics;public class TetrisCanvas extends Canvas implements Runnable {Thread current;// ----------------...
Java实现的俄罗斯方块代码解析
"这是一个Java实现的俄罗斯方块游戏代码示例，旨在帮助学习Java编程的人巩固基础知识。" 在Java编程中，实现俄罗斯方块游戏涉及到多个关键知识点，包括图形用户界面（GUI）设计、事件处理、多线程以及游戏逻辑。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值