‘壹’ java的俄罗斯方块代码及详细解答和设计思想
import java.awt.*;
import java.awt.event.*;
//俄罗斯方块类
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("俄罗斯方块游戏 V1.0 Author:Vincent");
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("分数:",Label.LEFT);
Label levelp = new Label("级数:",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_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_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_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));
//定义按钮Level Pause
Button pause_b =new Button("游戏暂停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));
//定义按钮Quit
Button quit_b = new Button("退出游戏");
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();
}
}
//重写MyPanel类，使Panel的四周留空间
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}
//游戏画布类
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;
}
public void keyTyped(KeyEvent e){
}
public void keyReleased(KeyEvent e){
}
//处理键盘输入的方法
public void keyPressed(KeyEvent e){
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_SPACE:b.leftTurn();break;
}
}
}
//处理控制类
class Command implements ActionListener{
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;
}
//按钮执行方法
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);
}
}
}
//方块类
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;
}
}
}
}
//定时线程
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();
}
}
}
}
class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}
‘贰’ java俄罗斯方块
俄罗斯方块——java源代码提供
import java.awt.*;
import java.awt.event.*;
//俄罗斯方块类
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("俄罗斯方块游戏 V1.0 Author:Vincent");
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("分数:",Label.LEFT);
Label levelp = new Label("级数:",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_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_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_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));
//定义按钮Level Pause
Button pause_b =new Button("游戏暂停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));
//定义按钮Quit
Button quit_b = new Button("退出游戏");
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();
}
}
//重写MyPanel类，使Panel的四周留空间
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}
//游戏画布类
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[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[j]);
}
//画方块的方法
public void drawUnit(int row,int col,int type){
scrArr[row][col] = type;
Graphics g = getGraphics();
tch(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[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[j] == 0)
drawUnit(k-1,j,0);
else
drawUnit(k-1,j,2);
scrArr[k-1][j] = scrArr[j];
}
}
for(int i = k-1 ;i < rowNum; i++){
for(int j = 0; j < columnNum; j++){
drawUnit(i,j,0);
scrArr[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;
}
public void keyTyped(KeyEvent e){
}
public void keyReleased(KeyEvent e){
}
//处理键盘输入的方法
public void keyPressed(KeyEvent e){
if(!ERS_Block.isPlay)
return;
tch(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_SPACE:b.leftTurn();break;
}
}
}
//处理控制类
class Command implements ActionListener{
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;
}
//按钮执行方法
public void actionPerformed (ActionEvent e){
tch(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);
}
}
}
//方块类
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;
}
}
}
}
//定时线程
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();
}
}
}
}
class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}
希望能解决您的问题。
‘叁’ java俄罗斯方块制作方法 全面哦
代码多了，传不过去 分开给你传吧
还是发你邮箱吧
下面是一部分代码
代码如下：
package com.tarena.tetris;//包名倒写
//导包
import java.awt.image.BufferedImage;
/**
* 格子类
*/
public class Cell {
//1定义属性
private int row;//行
private int col;//列
private BufferedImage image;//图片
//2构造器
public Cell(int row, int col, BufferedImage image) {
super();
this.row = row;
this.col = col;
this.image = image;
}
//3属性访问方法
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;
}
//5移动方法
public void drop() {
row++;
}
public void moveLeft() {
col--;
}
public void moveRight() {
col++;
}
//4重写toString
public String toString() {
return row + "," + col;
}
}
-----------------------------------------------------------------------
package com.tarena.tetris;//包名倒写
//导包
import java.util.Arrays;
import java.util.Random;
/**
* 四格方块类：包含七个子类T I J L S Z O
*/
public abstract class Tetromino {
//1创建四个格子
protected Cell[] cells = new Cell[4];
//9
protected State[] states;//旋转状态
protected int index = 10000;//旋转状态的序号 state[index%state.length]
//8旋转 内部类
protected class State {
int row0,col0,row1,col1,row2,col2,row3,col3;//转一圈 8个数
//构造器
public State(int row0, int col0, int row1, int col1, int row2,
int col2, int row3, int col3) {
super();
this.row0 = row0;
this.col0 = col0;
this.row1 = row1;
this.col1 = col1;
this.row2 = row2;
this.col2 = col2;
this.row3 = row3;
this.col3 = col3;
}
}
//10
/** 向右转 */
public void rotateRight() {
//1取得变换的下个数据状态state[n]
index++;
State s = states[index%states.length];
//2取得当前轴的row,col
Cell o = cells[0];
int row = o.getRow();
int col = o.getCol();
//3旋转以后的数据=(row,col) + state[n]
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);
}
//11
/** 向左转 */
public void rotateLeft() {
//1取得变换的下个数据状态state[n]
index--;
State s = states[index%states.length];
//2取得当前轴的row,col
Cell o = cells[0];
int row = o.getRow();
int col = o.getCol();
//3旋转以后的数据=(row,col) + state[n]
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);
}
//2工厂方法，随机产生四个格子
public static Tetromino randomOne() {
//4随机产生七种四格方块
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 J();
case 3 : return new L();
case 4 : return new S();
case 5 : return new Z();
case 6 : return new O();
}
return null;
}
//5移动方法
public void softDrop() {
for(int i=0; i<cells.length; i++) {//迭代每一个方块
cells[i].drop();//使每一个方块下落
}
}
public void moveLeft() {
for(int i=0; i<cells.length; i++) {//迭代每一个方块
cells[i].moveLeft();//使每一个方块左移
}
}
public void moveRight() {
for(int i=0; i<cells.length; i++) {//迭代每一个方块
cells[i].moveRight();//使每一个方块右移
}
}
//6重写toString
public String toStrig() {
return Arrays.toString(cells);
}
}
//3创建子类T继承父类Tetromino
class T extends Tetromino {
//7
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);
//12
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);
}
}
//3创建子类I继承父类Tetromino
class I extends Tetromino {
//7
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);
//12
states = new State[] {new State(0,0, 0,1, 0,-1, 0,-2),
new State(0,0, -1,0, 1,0, 2,0)};
}
}
//3创建子类J继承父类Tetromino
class J extends Tetromino {
//7
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);
//12
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)};
}
}
//3创建子类L继承父类Tetromino
class L extends Tetromino {
//7
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);
//12
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)};
}
}
//3创建子类S继承父类Tetromino
class S extends Tetromino {
//7
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);
//12
states = new State[]{
new State(0,0, 0,1, 1,-1, 1,0),
new State(0,0, -1,0, 1,1, 0,1)};
}
}
//3创建子类Z继承父类Tetromino
class Z extends Tetromino {
//7
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);
//12
states = new State[]{
new State(0,0, -1,-1, -1,0, 0,1),
new State(0,0, -1,1, 0,1, 1,0)};
}
}
//3创建子类O继承父类Tetromino
class O extends Tetromino {
//7
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);
//12
states = new State[]{
new State(0,0, 0,1, 1,0, 1,1),
new State(0,0, 0,1, 1,0, 1,1)};
}
}
‘肆’ 俄罗斯方块编程 JAVA C# C++用哪个简单，这三种编程语言都没学过，但是课程设计需要做俄罗斯方块编程
说简单，其实都不难。
从语言的上手程度来看，C#绝对是列出的3个中最快的。适合快速建立工程。
‘伍’ 求JAVA课程设计俄罗斯方块代码，流程图，能有详细说明介绍的更好！感激不尽！
import java.awt.*;
import java.awt.event.*;
//俄罗斯方块类
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("俄罗斯方块游戏 V1.0 Author:Vincent");
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("分数:",Label.LEFT);
Label levelp = new Label("级数:",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_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_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_b.setSize(new Dimension(50,200));
level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));
//定义按钮Level Pause
Button pause_b =new Button("游戏暂停");
pause_b.setSize(new Dimension(50,200));
pause_b.addActionListener(new Command(Command.button_pause,gameScr));
//定义按钮Quit
Button quit_b = new Button("退出游戏");
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();
}
}
//重写MyPanel类，使Panel的四周留空间
class MyPanel extends Panel{
public Insets getInsets(){
return new Insets(30,50,30,50);
}
}
//游戏画布类
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;
}
public void keyTyped(KeyEvent e){
}
public void keyReleased(KeyEvent e){
}
//处理键盘输入的方法
public void keyPressed(KeyEvent e){
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_SPACE:b.leftTurn();break;
}
}
}
//处理控制类
class Command implements ActionListener{
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;
}
//按钮执行方法
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);
}
}
}
//方块类
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;
}
}
}
}
//定时线程
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();
}
}
}
}
class WinListener extends WindowAdapter{
public void windowClosing (WindowEvent l){
System.exit(0);
}
}
‘陆’ 用Java设计网络版俄罗斯方块会遇到哪些难点
(Java ) . 1.1 开发一个俄罗斯方块游戏。游戏者移动和旋转窗口内落下的方块，方块在一行堆满后就可以消掉，并得到相应的分数；如果方块堆积至窗口顶端，即告负。 1.2 在游戏程序中，我们可以将它看成3 个对象，分别是程序窗体主类对象、方块数据管理对象、控制游戏自动下落的定时器线程对象、三个背景音乐对象。 窗体主类对象: 方块数据管理对象: 控制游戏自动下落的定时器线程对象: 三个背景音乐对象： 1.3 开发工具：Sun NetBeans IDE 6.1 NetBeans IDE 是一个为软件开发者提供的自由、开源的集成开发环境。您可以从中获得您所需要的所有工具，用 Java、C/C++ 甚至是 Ruby 来创建专业的桌面应用程序、企业应用程序、web 和移动应用程序。此 IDE 可以在多种平台上运行，包括 Windows、Linux、Mac OS X 以及 Solaris；它易于安装且非常方便使用。6.0 发行版包含了重要的增强功能和新特性，包括完全重写的编辑器基础结构、对扩展语言的支持、新的生产率特性，以及一个能让您根据实际需求安装并配置 IDE 的简化安装过程。 . 2.1 游戏数据与界面显示相分离，用游戏结构数据描述游戏的状态，玩家操作或游戏自行走一步，程序中都通过修改游戏数据来体现，即每走一步，程序会修改当前的游戏数据，判断游戏是否结束了，也是通过对游戏数据的分析来作出结论。游戏界面是根据当时游戏数据来绘制的，当数据改变时，要清除原图形并重绘。总之，游戏的逻辑设计是针对游戏数据，而不是游戏界面。界面只是间接地向玩家显示结果。因此，在设计函数时，大致分二类：与玩家操作事件有关的数据处理函数，与界面效果有关的图形绘制函数。游戏运行过程由窗体监听到的键盘事件控制 主要流程图如下： 制造新的方块 方 向键 的控 制与方法 IsCanChangeTo() Anthem类 游戏背景音乐当游戏开始时启动 Class RussionGame clearblock() makeblock() moveright() movedown() moveleft() turnleft() turnright() Anthem2 类 按键的声音当触发方向键的方法时响应 formKeyPressed（） 当游戏结束后启动另一首音乐 定义一个线程类，在后台自动地按游戏速度，移动方块。 CheckAndCutLine() IsOver() Anthem3 类 检查某一行是否为全填充，如是，消掉并返回1 IsHitBottom() 判断当前方块是否已触底，并处理 TimerRuner 游戏数据管理对象：主要管理着两方面数据：方块的坐标数据和游戏空间数据。用成员数组变量描述游戏空间状态，根据游戏空间状态判断游戏是否结束。用它的成员变量保存方块的形状数据及坐标数据，定义当方块走动方块数据变化的处理方法。此外，还把各种游戏属性数据作为其成员变量。 控制游戏自动下落的定时器线程对象：是一个线程类派生对象，独立运行，每隔一段时间控制方块下落下格。 窗体界面主类对象：负责绘制游戏图象、包含游戏设置的各种控件（如：设置速度的文本框、显示得分的标签、开始及暂停按钮），负责游戏的各种属性数据的读入及显示输出，最重要的是：它还是一个键盘事件处理类，监听玩家的键盘操作，处理键盘事件，在键盘事件处理函数中调用游戏数据管理对象的方法，控制游戏的运行。我们还把游戏数据管理对象、控制游戏自动下落的定时器线程对象作为它的成员变量。 往面板中加入需要的控件（2 个 Jlable，2 个 JcomboBox，4 个 Jbottun），并布置好它们的位置，并重命名控件对象变量的名称，如上图： 2.3 1. 首先对于方块的构造分析，可以用一个三维数组来表示，方块总共有四种基本形，其它形状可由这四种基本形通过旋转得到，如下图： class RussionBlockGame { final int sp_WIDTH = 20; // final int sp_HIGHT = 20; // final int boxtypes[4][4][2]={ {{-1,0},{0,0},{1,0},{2,0}}, {{-1,0},{0,0},{1,0},{1,-1}}, {{-1,0},{0,0},{1,0},{0,-1}}, {{-1,0},{0,0},{1,0},{-1,-1}} };/* */ int box[4][2]; /* */ int cx, cy; /* */ int type; /* ( 0,1,2,3)*/ int block_box[][]=new int[4][2]; /* */ int block_cx, block_cy; /* */ int block_type; /* ( 0,1,2,3)*/ int gamespace[][] = new int[sp_HIGHT][sp_WIDTH] ; void makeblock()// { block_type = (int)(Math.random()*100)%4;//产生一个1－4 的随机数 for(int i=0; i<4;i++) block_box[i] = types[block_type][i]; block_cx=sp_WIDTH/2; block_cy=0; } HIGHT WIDTH (cx,cy)= (11,4) (WIDTH-1,HIGHT-1) 游戏空间可以看成由sp_WIDTH × sp_HIGHT 个正方形小格子构成，每格子都有一个相对于左上角的坐标。可以用一个sp_WIDTH × sp_HIGHT 的二维数组表示游戏空间。如下： int gamespace[sp_WIDTH][sp_HIGHT]; 某格子对应的数组元素的值为1，表示此格子已被方块填充，为0 表示未被填充。 在游戏空间中，被方块填充了的格子为深灰色，未被填充的格子为白色（底色），灰色格子触及空间顶部时，游戏结束。即gamespace[0](二维数组第一排)中有元素的值为1 时，游戏结束。下面是判断游戏是否结束的程序： boolean IsGameOver() { boolean flag=false; for(int i=0; i=sp_WIDTH || y>=sp_HIGHT|| (y>0 && gamespace[y][x]==1)) { IsCan = false; break;} } return IsCan; } 4. , 判断方块是否已落到底，就是判断方块中每个小正方形格的正下方位置是否已被填充或出下界。 如已到底，把方块所在的位置（格子）填充（对应 gamespace 1）,还要查看是否有某行已被全填充，把被全填充的行消掉，并给用户加分,程序片段如下： boolean IsHitBottom( ) / { boolean flag =false ; int i, x, y; for (i=0; i<4; i++) { x= block_cx + block_box[i][0]; y= block_cy + block_box[i][1] + 1 ; if ( y>=sp_HIGHT|| gamespace[y][x]==1) { flag = true; break; } } if( flag ) { for (i=0; i<4; i++) { x= block_cx + block_box[i][0] ; y= block_cy + block_box[i][1] ; if(y>=0) { gamespace[y][x]=1;} } for (i=0; i<4; i++) { y= block_cy + block_box[i][1] ; while(y>=0 && CheckAndCutLine(y)) m_score += 100; } isplaying = ! IsGameOver(); } return flag; } 开始音乐时已被循环播放 w1.audioClips.loop(); Anthem2 w2 = new Anthem(); 当触发到按键事件时执行formKeyPressed 方法，每当系统取得某一个按键的键码时程序都会自动执行w2.audioClips2.play();直到游戏结束。 Anthem2 w3 = new Anthem() ; 当触发到game.IsOver 方法时证明游戏已结束这时程序会调用 w1.audioClips.stop(); w3.audioClips3.play(); 背景音乐消失，结束音乐开始。 6. 游戏窗体的设计视图中，选择“开始游戏”按钮，再右键点击“开始游戏”按钮，从菜单中选“事件”－＞“Action”事件类型－＞“actionPerformed”接口方法，将转到源视图中事件处理代码处，加入我们的处理代码，使得游戏开始，如下： private void jButton_startActionPerformed(java.awt.event.ActionEvent evt) { game.isplaying=true; this.requestFocusInWindow(); new TimerRuner(this); } 用同样的方法编写“暂停游戏”、“结束游戏”、“退出游戏”的点击事件处理代码，代码如下： private void jButton_stopActionPerformed(java.awt.event.ActionEvent evt) { game.isplaying=false; } private void jButton_overActionPerformed(java.awt.event.ActionEvent evt) { game.isplaying=false; game.cleargamespace(); } private void jButton_exitActionPerformed(java.awt.event.ActionEvent evt) { game.isplaying=false; System.exit(0); } 2.4 功能： 具有等级功能，不同的等级游戏的难度不一样； 具有分数功能，消行可以得到分数； 具有声音，有背景音和执行不同的操作出现不同的声音； 具有设置功能，可以用来设置初始等级、开始行数、按键设置等。 3. /number2 方块向下 /number4：方块向下 /number3：方块向右 PageDown 方块向右翻传 End 方块向左传 Start 游戏开始 背景音乐的开关 Stop 暂停游戏 over 停止游戏 Speed：调整速度 ：选择方块的背景色（默认为浅蓝） 程序运行结果大部分按照预期设计一样，但背景色的改变有时响应过慢，而且每次打开音乐后必须重新按下start 键，这是该游戏的缺陷之一。鉴于此，已作出部分修正，虽然还没有达到游戏更加人性化，但基本上能满足游戏的多方面的需要了。
‘柒’ java课程设计（符合要求，别太深奥）
俄罗斯方块没有 有自己做的贪食蛇
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
public class GameMain extends JFrame implements Runnable {
int runY = 140;
int runX = 120;
int width = 600;
int height = 500;
int W = 10;
int M = 10;
int fangxiang = 0;
int sheshen[] = new int[200];
int foodx = 150;
int foody = 150;
int score = 0;
boolean zhuangtai = true;
class UsurKey extends KeyAdapter {
public void keyPressed(KeyEvent e) {
fangxiang = e.getKeyCode();
}
}
class UsurMouse extends MouseAdapter {
public void mouseClicked(MouseEvent e) {
System.out.println(e.getX() + "," + e.getY());
}
}
public GameMain() {
this.setSize(width, height);
this.setVisible(true);
this.addKeyListener(new UsurKey());
this.addMouseListener(new UsurMouse());
new Thread(this).start();
for (int i = 0; i < W; i++) {
sheshen[i * 2] = runX + i * W;
sheshen[i * 2 + 1] = runY;
}
}
public static void main(String[] args) {
GameMain g = new GameMain();
}
int count = 0;
public void paint(Graphics g) {
g.fillRect(0, 0, width, height);
g.setColor(new Color(155, 155, 155));
try {
File file1 = new File("img/�0�8�0�8.jpg");
Image image = ImageIO.read(file1);
g.drawImage(image, 150, 100, null);
} catch (IOException e) {
e.printStackTrace();
}
g.drawRect(20, 50, width - 40, height - 100);
g.setColor(new Color(133, 195, 95));
for (int i = 0; i < W; i++) {
g.fillRect(sheshen[i * 2], sheshen[i * 2 + 1], 10, 10);
}
g.setColor(new Color(255,255,0));
count++;
if(count%2==0){
g.fillRect(foodx, foody, M, M);
}
}
public void updata() {
if (fangxiang == KeyEvent.VK_UP) {
runY = runY - 10;
}
if (fangxiang == KeyEvent.VK_DOWN) {
runY = runY + 10;
}
if (fangxiang == KeyEvent.VK_RIGHT) {
runX = runX + 10;
}
if (fangxiang == KeyEvent.VK_LEFT) {
runX = runX - 10;
}
for (int i = W - 1; i > 0; i--) {
sheshen[i * 2] = sheshen[(i - 1) * 2];
sheshen[i * 2 + 1] = sheshen[(i - 1) * 2 + 1];
}
sheshen[0] = runX;
sheshen[1] = runY;
if (sheshen[0] <= 20 || sheshen[0] + W >= 580) {
zhuangtai = false;
}
if (sheshen[1] <= 50 || sheshen[1] + W >= 450) {
zhuangtai = false;
}
Random rand= new Random();
if(sheshen[0]==foodx&&sheshen[1]==foody){
W++;
while(true){
foodx = Math.abs((rand.nextInt()%(50 + width-100 -10))/10*10);
foody = Math.abs((rand.nextInt()%(50 + height-100 -10))/10*10);
if(foodx>60&&foody>60){
boolean flag=true;
for(int i=0;i<W;i++){
if(sheshen[2*i] == foodx && sheshen[2*i+1] == foody){
flag=false;
}
}
if(flag){
break;
}
}
}
}
}
public void run() {
while (zhuangtai) {
try {
updata();
this.repaint();
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
‘捌’ 求一个java俄罗斯方块的设计思路 不要代码 只要思路 本人是初学者
1：首先自己定义一个类，比如MyLabel，继承jlabel，设置大小比如
（40，40）设置成方块，这就是游戏里面最小的单位，下落的图形，就是四个这个样的单位组合到一起，位置不同。
2：定义自己的图形（就是游戏中下落的部分）比如MyPic
,这个类是控制MyLabel的，一般是4个MyLabel组合成一个MyPic,
3：定义自己的面板，大小是
(n*40,m*40
)就是上面最小单位的整数行和列,然后建一个二位数组
int
[n][m],数组里面默认为0，标示这个位置没有MyLabel
，是空的，如果位置有
MyLabel,设置成1
，这个是数组是，图形下落的时候判断是否继续下落还是要停下了，下面有了就停，否则继续下落，下落停止后，根据数组，看某一行是否全部为1
是的话，把这行清空
图形的下落要用定时器或者自己写线程实现，然后就是判断下面是否有东西，是下落，还是停止，
图形的旋转的话，自己研究吧，位置的变换，也不好做
‘玖’ 关于游戏俄罗斯方块（JAVA语言做的）项目答辩时，老师通常会问什么问题求助高手，并解答，谢谢
我以前同学也是做这个毕业设计的。不过是用C++做的。我记得评委提了几个问题。
1、俄罗斯方块已经是很老的游戏了，你做的俄罗斯方块与我们平时见过的有什么区别？创新点在哪里？这个问题是百分之百会问的。
回答：就要看你到底有没有创新，怎么去和一般的俄罗斯方块比较，要好好总结一下。
2、这个毕业设计的工作量、代码量。
回答：从你开始收集需求分析开始，时间统计，代码量粗略统计。
3、你觉得这个俄罗斯方块还有什么不足，怎么改进？
回答：比如界面要更加人性化，音效还不够完美……还要增加多人对战模式等等
4、你实现项目的主要技术，核心算法有哪些？
回答：介绍主要技术，算法参考。
基本上记得的就这些，希望你顺利通过。
‘拾’ 俄罗斯方块论文怎么写
5月15日 16:34 游戏起源、历史、简介
俄罗斯方块是一款风靡全球的电视游戏机和掌上游戏机游戏，它曾经造成的轰动与造成的经济价值可以说是游戏史上的一件大事。这款游戏最初是由苏联的游戏制作人Alex Pajitnov制作的，它看似简单但却变化无穷，令人上瘾。相信大多数用户都还记得为它痴迷得茶不思饭不想的那个俄罗斯方块时代。
究其历史，俄罗斯方块最早还是出现在PC机上，而我国的用户都是通过红白机了解、喜欢上它的。现在联众又将重新掀起这股让人沉迷的俄罗斯方块风潮。对一般用户来说，它的规则简单，容易上手，且游戏过程变化无穷，而在"联众俄罗斯方块"中，更有一些联众网络游戏所独有的魅力――有单机作战与两人在线对战两种模式，用户可任选一种进行游戏。网络模式还增加了积分制，使用户既能感受到游戏中的乐趣，也给用户提供了一个展现自己高超技艺的场所。
★★ 一些和俄罗斯方块有关的故事
俄罗斯方块操作简单，难度却不低。作为家喻户晓老少皆宜的大众游戏，时至今日玩游戏的人（以及许多不怎么玩游戏的人）中谁要是不知道的话可真所谓是火星上的熊猫了。但是，谁知道这么优秀的娱乐工具，出自哪位神人之手呢？
顾名思义，俄罗斯方块自然是俄罗斯人发明的。这位伟人叫做阿列克谢·帕基特诺夫（Alexey Patnov） 。
然而，很少有人知道，这个着名的游戏在80年代曾经在法律界掀起轩然大波，那就是着名的俄罗斯方块产权之争。这次产权争夺，几家欢喜，几家哀愁，几家公司倒闭，几家公司赚钱，其中的是是非非，一言难尽。
1985年6月
工作于莫斯科科学计算机中心的阿列克谢·帕基特诺夫在玩过一个拼图游戏之后受到启发，从而制作了一个以Electronica 60（一种计算机）为平台的俄罗斯方块的游戏。后来经瓦丁·格拉西莫夫（Vadim Gerasimov）移植到PC上，并且在莫斯科的电脑界传播。帕基特诺夫因此开始小有名气。
1986年7月
PC版俄罗斯方块在匈牙利的布达佩斯被当地的一群电脑专家移植到了Apple II 和 Commodore 64 上，这些版本的软件引起了当时英国一个叫Andromeda的游戏公司经理罗伯特·斯坦恩（Robert Stein）的注意，他向帕基特诺夫以及匈牙利的电脑专家们收购了俄罗斯方块的版权，并且在买到版权之前把它们倒手卖给了英国的Mirrorsoft （注意不是Microsoft！） 以及美国的Spectrum Holobyte。
1986年11月
斯坦恩和帕基特诺夫经过谈判，就版权收购问题未取得成果。斯坦恩甚至直接飞到莫斯科和帕基特诺夫面谈，但是空手而归。由于俄罗斯人对于已经在西方兴起的电子游戏产业知道不多，斯坦恩决定窃取Tetris的版权，于是他放出谣言说这是匈牙利人开发的游戏。
与此同时，PC版的俄罗斯方块已经由英国的Mirrorsoft出品并且在欧洲销售，受到当时人们的极大关注。不仅仅因为这个游戏好玩，而且这是“第一个来自铁幕国家的游戏。”当时的游戏宣传海报上有浓郁的冷战色彩，比如战争画面，加加林太空飞行等。而斯坦恩仍然没有正式合法的版权。
1987年6月
斯坦恩最终取得了在IBM-PC及其兼容机上的Tetris的版权，版权机种包括“其他任何电脑系统”。但是，他没有和苏联方面签署协议，也就是说，这个版权是不完全的。（注： 这个“其他任何电脑系统”在原文中的描述是any other computer system，这种说法在当时看来也很不严密，从而为后来的产权之争埋下了伏笔）
1988年1月
Tetris在电脑平台的热销，一时造成“洛阳纸贵”（伦敦磁盘贵？？）的局面。而当CBS晚报采访了俄罗斯方块之父帕基特诺夫之后，斯坦恩盗窃版权的计划彻底泡汤了。一个新的公司ELORG（Electronorgtechinca，苏联一家软件公司）开始和斯坦恩就游戏程序问题进行协商。ELORG的负责人亚历山大·阿列欣科（ Alexander Alexinko）知道斯坦恩虽然没有版权，但是会以手中的游戏开发程序为筹码威胁中断谈判。
1988年5月
经过几个月的争吵之后，筋疲力尽的斯坦恩终于和ELORG签定了PC俄罗斯方块版权的合约。当时的合约禁止开发街机版和掌机版的方块游戏，而电脑版的Tetris则成为当时最畅销的游戏。
1988年7月
斯坦恩与阿列欣科商谈开发街机版俄罗斯方块的问题。阿列欣科当时尚未从斯坦恩那里拿到一分钱的版权费，但是同时的Spectrum 和 Mirrorsoft已经开始向电子游戏商出售了俄罗斯方块的版权。Spectrum 将Tetris的游戏机和PC在日本的版权卖给了Bullet-Proof Software （FC和GB版俄罗斯方块的制作商），而Mirrorsoft则把它在日本和北美的版权卖给了美国的Atari。这样一来两家公司的矛盾就开始了。1988年11月，BPS在FC上发行的俄罗斯方块（大家不很熟悉的俄罗斯方块1）在日本发售，销量达200万份。
1988年11月
随着GB的开发，NOA（任天堂美国分公司）的经理荒川实（任天堂山内溥老爷子的女婿）希望将Tetris做成GB上的游戏。于是他联系了BPS的总裁亨克·罗杰斯（Henk Rogers），罗杰斯再与斯坦恩联系的时候却吃了闭门羹。于是他直接去莫斯科购买版权。而斯坦恩觉察出风头，也乘飞机前往莫斯科；与此同时，Spectrum的负责人罗伯特·麦克斯韦（Robert Maxwell）的儿子凯文·麦克斯韦（Kevin Maxwell） 也在向莫斯科进发。就这样，三路人马几乎在同时赶到了冰天雪地的红色都市。
1989年2月21日
罗杰斯首先会见了ELORG的代表叶甫盖尼·别里科夫（Evgeni Belikov，和那个“装在套子里的人”同名）。他给帕基特诺夫等苏联人留下了深刻印象，并且签了手掌机方块游戏的版权。之后他向俄国人展示了FC版Tetris，这使别里科夫极为震惊。因为他并没有授予罗杰斯家用机的版权！罗杰斯则向他们说这是向TENGEN购买的版权，但是别里科夫也从来听说过TENGEN这个公司的名字。罗杰斯为了缓和尴尬的局面，将斯坦恩隐瞒的事实如数告诉了别里科夫，并且答应付给苏联方面更多支票作为已经卖出的FC版俄罗斯方块的版权费用。这时罗杰斯发现自己有机会买到Tetris全部机种的版权（但是当时还没买），虽然Atari会对他虎视耽耽，但是别忘了，他和BPS的背后还有任天堂这个大靠山给自己撑腰。
注意：罗伯特·斯坦恩原先所签的协议只是电脑版Tetris的版权，其他的版权并不是他的。
后来，斯坦恩和ELORG重新签署了协议。别里科夫强迫他重签的合约中修改的内容是：“电脑的定义：包含有中央处理器，监视器，磁盘驱动器，键盘和操作系统的机器”。而斯坦恩当时却没有仔细看这些定义。（这回轮到他犯混了……）后来他才意识到这是罗杰斯从自己手中抢走版权而耍的花招。但是为时已晚。第二天他被告知虽然签署的文件已经不能改过来，但是他还可以得到街机版Tetris的开发权。三天之后，他签下了街机版的协议。
1989年2月22日
凯文·麦克斯韦访问了ELORG。别里科夫拿出罗杰斯给他的FC游戏卡向他询问这件事情。麦克斯韦在卡带上看到了Mirrorsoft的名字后才想起他的公司已经把部分版权倒卖给了Atari。（糊涂人办糊涂事……）当他想继续谈街机和手掌机版权的问题的时候，却发现他自己能够签的，就只有除电脑，街机，家用机和掌机以外的协议了。（其实等于没有协议可签，除非他发明一种新的娱乐系统，比方说俄罗斯方块积木……）在糊涂之余这家伙灵机一动，告诉别里科夫说此卡带为盗版（汗……），然后也要签家用机的协议。
最后的结果是：凯文·麦克斯韦只带走一张白纸，罗伯特·斯坦恩带走了街机协议书。由于麦克斯韦声称所有的FC卡都是盗版，ELORG保留了家用机的版权，没卖给任何人。假如麦克斯韦想获得家用机版权的话，就必须出价比任天堂高才行。亨克·罗杰斯买到了掌机的版权，并且通知了荒川实。BPS就制作GB版Tetris向任天堂达成交易：这笔交易额高大500万-1000万美元。
1989年3月15日
亨克·罗杰斯回到莫斯科，并且代表任天堂出巨资收购家用机版Tetris的版权。版权费的价格虽然没有向外界透露，但是这个数字将是Mirrorsoft永远拿不出来的。连荒川实和NOA的首席执行官霍华德·林肯（Howard Lincoln）都亲自前往苏联助阵。
1989年3月22日
ELORG和任天堂的家用机协议终于达成。任天堂方面坚持加入一款声明，在协议签定之后，如果和其他出现法律纠纷，苏联方面必须派人去美国的法庭上做证。实际上，这种法律上的争端将是不可避免的。据说ELORG仅仅得到的定金有300-500万美元之多。别里科夫向Mirrorsoft通知，说Mirrorsoft， Andromeda和Tengen都没有家用机的版权，现在版权都归任天堂所有。当天晚上任天堂和BPS的头目们在莫斯科酒店里举行了庆祝party。
（各位看明白了，现在家用机和掌机的版权已经被任天堂和BPS分别掌握在手中。无论是Atari还是Tengen都没有权利制作FC版的俄罗斯方块。）
1989年3月31日
霍华德·林肯愉快（幸灾乐祸？）地向Atari发去最后通牒（传真），告诉他们立刻停止FC（NES）版的俄罗斯方块游戏。这使得Atari和麦克斯韦都十分震怒。他们以Tengen的名义回信说在4月7日那天他们就已经享有家用机俄罗斯方块的版权了。
1989年4月13日
Tengen撰写了一份申请书，要求拥有Tetris的“影音作品，源程序和游戏音乐”版权。但是申请书中并没有提及阿列克谢·帕基特诺夫和任天堂的游戏版权问题。（忽视了阿列克谢·帕基特诺夫真是个大错误！）
与此同时，麦克斯韦利用自己掌握的媒体势力，企图夺回Tetris的阵地。甚至搬出了苏联与英国政府，对俄罗斯方块版权问题进行干预。（好大的面子啊！）结果挑起了苏共与ELORG之间的矛盾。甚至连戈尔巴乔夫都向麦克斯韦保证“以后不用担心日本公司的问题”。（汗……这位麦克斯韦果然不是善主……伟大的苏联政府都对俄罗斯方块关注起来了……）
在4月晚些时候，霍华德·林肯回到莫斯科的时候，发现ELORG已经在苏联政府的打压下抬不起头来，而就在那天半夜，NOA方面给他打电话，说Tengen已经起诉了任天堂。（山雨欲来风满楼啊……）
第二天，他面会了别里科夫，帕基特诺夫和其他几位ELORG的成员，以确保他们能够为任天堂的官司佐证。（这回合同里的条款可生效了）随后NOA立刻反诉Tengen，并且开始收集证据。
1989年5月17日
Tengen在USA Today上登载了大幅Tertis广告，虽然法庭大战已经迫在眉睫。
1989年6月
Tengen与任天堂的案子终于开庭审理。
论战主要围绕一个议题展开：NES（FC）究竟是电脑，还是电子游戏机。（大家不许笑，在法庭上这可是很严肃的话题）Atari认为NES是电脑系统，因为它拥有扩展机能，而且日本的Famicom也有网络功能存在。而任天堂的证据则更加切题：ELORG中的苏联人从来没有意向出售Tetris的家用机版权，而所谓的“电脑”的概念则早在和斯坦恩的协议中提到了。
1989年6月15日
法庭召开听证会，讨论关于任天堂和Tengen互相命令对方终止生产和销售各自的Tetris软件的行为。法官福恩·史密斯（Fern Smith）宣布Mirrorsoft 与 Spectrum Holobyte均没有家用机版权，因此他们提供给Tengen的权利也不能生效。任天堂的请求最后得到了许可。
1989年6月21日
Tengen版的俄罗斯方块全部撤下了货架，该游戏卡带的生产也被迫中止。数十万份软件留在包装盒里，封存在仓库中。
1989年7月
任天堂NES版Tetris在美国发售。全美销量大约300万。与此同时，和GB版Tetris捆绑销售的Game Boy席卷美国，美利坚大地上刮起一阵方块旋风。
关于Tetris的混战此时已经告一段落。而任天堂和Tengen之间的法庭纠纷则一直持续到1993年。
尾声
Atari Games仍然开发了街机版的Tetris，共卖出约2万台机器。近来Atari Games 被 Williams/WMS收购，而那些封存在仓库里的NES版Tetris的命运则没人知道。Tengen不能从其他途径把它们处理掉，所以估计这些软件都被销毁了。但是据说仍然有约10万份Tengen版的Tetris流入了市场。
我们今天在64合一等游戏D版卡里玩到的所谓“俄罗斯方块2”其实就是当年的Tengen版，平心而论，这一版的方块比BPS的版本要好玩许多。首先，这版的操作感和按键设定十分到位，AB分别是正转和反转，而BPS版是用十字键的下来转动，只支持一个方向，按A就直接“啪”地落下来，手感十分不爽；其次，它支持的二人对战，与电脑竞争和合作的模式也让人耳目一新。还有，音乐也是没的说。
罗伯特·斯坦恩，这个版权问题的始作俑者，在Tetris上总共只赚了25万美元。本来他可以挣多点钱的，但是Atari和Mirrorsoft在付他版税的时候没有给足。（应得的报应……）
Spectrum Holobyte 则需要和ELORG重新协商，以确保电脑版Tetris的版权。
罗伯特·麦克斯韦的媒体堡垒在混战中逐渐分崩离析，老麦克斯韦在做生意时做幕后黑手的事实也在调查中，而他却突然暴病身亡。（气死的……）Mirrorsoft 英国公司也惨淡地退出了历史舞台。
真正的大赢家是BPS的总裁亨克·罗杰斯，还有幕后的任天堂。俄罗斯方块究竟为任天堂赚了多少银子呢？答案恐怕永远说不清了。想一想吧，在美国GB都是和Tetris捆绑销售，以增加GB的出货量……然后因为Tetris买了GB的人还会买其他的GB卡……要是这么算起来的话，那利润简直就像滚雪球一样了。现在GB版的Tetris（Z版）总共生产了3000万张。（后来GB的俄罗斯方块又在SFC上出了复刻版，和《马里奥医生》一起出现在屏幕上，成为不朽之作。）
至于苏联方面，除了苏联政府，谁也没有从Tetris那里得到多少好处。苏联解体之后，原ELORG的人员都四散到了全国乃至世界各地，许多人继续开发游戏（比方说帕基特诺夫）。
阿列克谢·帕基特诺夫几乎没有从Tetris上赚到一分钱。ELORG本来打算给他Tetris的销售权，但是旋即取消了这笔交易。不过帕基特诺夫仍然为自己能够制作出这么一个世界闻名的优秀游戏而欣慰。他从科学院里得到一台286（当时在苏联可是了不起的电脑）作为奖励。而且分到了比同事们家宽敞明亮的房子。在1996年，亨克·罗杰斯支付给他一笔报酬（还算是个知恩图报的人），帕基特诺夫组建了Tetris Company LLC 公司，终于能够自己创作游戏，并且收取版权费了。
注：当年俄罗斯方块红遍世界的各个角落，一个本来是吃大锅饭的人在消极怠工的时候发明的娱乐工具成了造福全人类的宝贝，它的价值远远超越了开发这个软件时候的预想。Atari虽然在法庭上惨败，但是拜亚洲盗版商人所赐，Tengen版的俄罗斯方块已经在中国玩家心目中生根发芽，长叶开花，任天堂的正统Tetris在中国反而没人玩了。其实说了那么多，归根到底，平平淡淡才是真。有机会的话，下载一个FC的模拟器和一个64合一的经典ROM，回家体会一下俄罗斯方块的魅力吧……
附上Alex Pajitnov照片一张。
该回答在5月15日 19:30由回答者修改过