经典游戏再现——俄罗斯方块第一代（ 第二版已发布）

hello怪

之前看过大神用nxc写的俄罗斯方块，但相对而言比较简单

因此我想到，能不能用nxt的诸多传感器增强人机交互性呢？

嗯，现在开始试着用Java se来实现，预计很快就能实现用lejos nxj做俄罗斯方块了
站内视频似乎挂了，直接上优酷连接：
http://v.youku.com/v_show/id_XMTY4NjU2MzQyMA==.html?x=1

（妈妈说把视频放一楼就有更多人看了。。。（第二版视频：）
先放出java se的实验版：

hello怪

（自己先占一楼）图片放出：

hello怪

咦没人用lejos吗。。。。为啥这么冷清勒。。。。算了我直接把代码贴出来
首先是主类Russian.java
控制总的游戏进程

1. package ro;
   
2. 
   
3. import lejos.nxt.Button;
   
4. import lejos.nxt.Button.*;
   
5. 
   
6. public class Russian {
   
7.        
   
8.         static GameStatue gs = new GameStatue();
   
9.        
   
10.         MyPanel mp = new MyPanel(gs);
    
11.        
    
12.         public Russian(){
    
13.                
    
14.                 //Events
    
15.                 Button.ENTER.addButtonListener(mp);
    
16.                 Button.ESCAPE.addButtonListener(mp);
    
17.                 Button.LEFT.addButtonListener(mp);
    
18.                 Button.RIGHT.addButtonListener(mp);
    
19.                
    
20.         }
    
21. 
    
22.         private void gameStart(){
    
23.                
    
24.         }
    
25.        
    
26.         private void gameRun(){
    
27.                 while(true){
    
28.                         try{                                        //avoid overHeat
    
29.                                 Thread.sleep(1000);
    
30.                         }catch(Exception e){
    
31.                                 e.printStackTrace();
    
32.                         }
    
33.                         while(gs.isGameRunning){
    
34.                                 try{                                        //wait the actions
    
35.                                         Thread.sleep(1000);
    
36.                                 }catch(Exception e){
    
37.                                         e.printStackTrace();
    
38.                                 }
    
39.                                
    
40.                                 if(!gs.tryBlockDown()){
    
41.                                         gs.locateBlock();
    
42.                                         gs.tryRemoveRow();
    
43.                                         if(gs.isGameOver()){
    
44.                                                 System.out.println("GAME OVER!!");
    
45.                                                 gs.isGameRunning = false;
    
46.                                                 return;
    
47.                                         }
    
48.                                         gs.refresh();
    
49.                                 }mp.paint();
    
50.                                
    
51.                         }
    
52.                 }
    
53.         }
    
54.        
    
55.         private void gameEnd(){
    
56.                 Button.waitForAnyPress(5000);
    
57.         }
    
58.        
    
59.         public static void main(String[] args) {
    
60.                 Russian r = new Russian();
    
61.                 r.gameStart();
    
62.                 r.gameRun();
    
63.                 r.gameEnd();
    
64.         }
    
65. 
    
66. }
    

复制代码

然后是画图类MyPanel.java，实现在LCD上的动画效果

1. package ro;
   
2. 
   
3. import lejos.nxt.Button;
   
4. import lejos.nxt.ButtonListener;
   
5. import lejos.nxt.LCD;
   
6. 
   
7. import javax.microedition.lcdui.*;
   
8. 
   
9. public class MyPanel implements ButtonListener{
   
10.        
    
11.         GameStatue gs;
    
12.         Graphics g = new Graphics();
    
13.        
    
14.         public MyPanel(GameStatue g){                        //set Game Statue
    
15.                 gs = g;
    
16.         }
    
17.        
    
18.         public void paint(){                        //Draw
    
19.                
    
20.                 LCD.clear();//refresh
    
21.                
    
22.                 g.setFont(Font.getFont(0,0,Font.SIZE_SMALL));
    
23.                
    
24.                 //Standard Line
    
25.                 g.drawLine(64, 0, 64, 64);
    
26.                
    
27.                 //moving Blocks
    
28.                 for(int iy=0; iy<4; iy++){
    
29.                         for(int ix=0; ix<4; ix++){
    
30.                                 if(gs.currentMap[ix][iy]){
    
31.                                         g.fillRect((gs.blockX+ix)*8, (gs.blockY+iy-4)*8, 8,8);
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.                 //next Blocks
    
36.                 g.drawString("NEXT:", 64+2, 16, Graphics.LEFT|Graphics.TOP);
    
37.                 for(int iy=0; iy<4; iy++){
    
38.                         for(int ix=0; ix<4; ix++){
    
39.                                 if(gs.nextMap[ix][iy]){
    
40.                                         g.fillRect((ix)*6+gs.WIDTH*8+2, (iy)*6+24+2, 6,6);
    
41.                                 }
    
42.                         }
    
43.                 }
    
44.                
    
45.                
    
46.                 //stationary Blocks
    
47.                 for(int iy=4; iy<gs.HEIGHT+4; iy++){
    
48.                         for(int ix=0; ix<gs.WIDTH; ix++){
    
49.                                 if(gs.isBlockExist[ix][iy]){
    
50.                                         g.fillRect(ix*8,(iy-4)*8, 8,8);
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.                
    
55.                 //Display score & etc
    
56.                 g.drawString("SCORE:", 64+2, 0, Graphics.LEFT|Graphics.TOP);
    
57.                 g.drawString(String.valueOf(gs.score),64+2,8,Graphics.LEFT|Graphics.TOP);
    
58.         }
    
59.        
    
60.         @Override
    
61.         public void buttonPressed(Button b) {
    
62.                
    
63.                 if(Button.readButtons() == Button.ID_LEFT+Button.ID_RIGHT){
    
64.                         gs.gameStartOrPause();
    
65.                 }else{
    
66.                         switch(b.getId()){
    
67.                         case Button.ID_LEFT:
    
68.                                 gs.tryBlockLeft();
    
69.                                 break;
    
70.                         case Button.ID_RIGHT:
    
71.                                 gs.tryBlockRight();
    
72.                                 break;
    
73.                         case Button.ID_ENTER:
    
74.                                 gs.tryBlockRotate();
    
75.                                 break;
    
76.                         case Button.ID_ESCAPE:
    
77.                                 gs.tryBlockDown();
    
78.                                 break;
    
79.                         default:
    
80.                         }
    
81.                 }
    
82.                 paint();
    
83.                
    
84.         }
    
85.         @Override
    
86.         public void buttonReleased(Button b) {
    
87.                 // TODO Auto-generated method stub
    
88.         }
    
89. }
    

复制代码

再然后是控制类GameStatue, 存储游戏的大部分数据以及控制方块移动，旋转的方法

1. package ro;
   
2. 
   
3. public class GameStatue {
   
4.        
   
5.         static final int WIDTH = 8,HEIGHT = 8;
   
6.        
   
7.         boolean isGameRunning;
   
8.         int score;
   
9.        
   
10.         int blockX=2, blockY = 0;
    
11.        
    
12.         int currentBlockType, currentBlockRotation;
    
13.         int nextBlockType, nextBlockRotation;
    
14.        
    
15.         boolean currentMap[][] = new boolean[4][4];
    
16.         boolean nextMap[][] = new boolean[4][4];
    
17.        
    
18.         boolean isBlockExist[][] = new boolean[WIDTH][HEIGHT+4];
    
19.        
    
20.         public GameStatue(){
    
21.                
    
22.                
    
23.                 score = 0;
    
24.                 isGameRunning = true;
    
25.                
    
26.                 currentBlockType = 5;
    
27.                 currentBlockRotation = 0;                        //flash now and then
    
28.                
    
29.                 loadCurrentMap();
    
30.                
    
31.                 loadRandomNextMap();
    
32.         }
    
33.         private void loadCurrentMap(){
    
34.                
    
35.                 int array = 0x8000;
    
36.                 for(int iy=0; iy<4; iy++){
    
37.                         for(int ix=0; ix<4; ix++){
    
38.                                 currentMap[ix][iy] =(Blocks.map[currentBlockType][currentBlockRotation] & array) !=0;
    
39.                                 array = array >> 1;
    
40.                         }
    
41.                 }
    
42.         }
    
43.        
    
44.         private void loadRandomNextMap(){
    
45.                 nextBlockType = (int)(Math.random()*7);
    
46.                 nextBlockRotation = (int)(Math.random()*4);
    
47.                 int array = 0x8000;
    
48.                 for(int iy=0; iy<4; iy++){
    
49.                         for(int ix=0; ix<4; ix++){
    
50.                                 nextMap[ix][iy] = (Blocks.map[nextBlockType][nextBlockRotation] & array) !=0;
    
51.                                 array = array >> 1;
    
52.                         }
    
53.                 }
    
54.         }
    
55.        
    
56.         public void refresh(){
    
57.                
    
58.                
    
59.                 blockX = 2;
    
60.                 blockY = 0;
    
61.                 currentBlockType = nextBlockType;
    
62.                 currentBlockRotation = nextBlockRotation;
    
63.                 loadCurrentMap();
    
64.                 loadRandomNextMap();
    
65.         }
    
66.        
    
67.         public boolean tryBlockDown(){
    
68.                 //&&&&&&&&&&&&&
    
69.                
    
70.                
    
71.                 for(int ia=0; ia<4; ia++){//x
    
72.                         for(int ib=3; ib>=0; ib--){//y
    
73.                                 if(currentMap[ia][ib]){
    
74.                                         if(blockY+ib-4+1>=HEIGHT){
    
75.                                                 return false;
    
76.                                         }
    
77.                                         if(isBlockExist[blockX+ia][blockY+ib+1])return false;
    
78.                                 }
    
79.                         }
    
80.                 }
    
81.                
    
82.                 blockY++;
    
83.                
    
84.                 return true;                        //return whether the block can be moved down
    
85.         }
    
86.        
    
87.         public void tryBlockLeft(){
    
88.                
    
89.                 for(int ia=0; ia<4; ia++){//y
    
90.                         for(int ib=0; ib<4; ib++){
    
91.                                 if(currentMap[ib][ia]){
    
92.                                         if(blockX+ib-1<0) return;
    
93.                                         if(isBlockExist[blockX+ib-1][ia])return;
    
94.                                 }
    
95.                         }
    
96.                 }
    
97.                 blockX--;
    
98.         }
    
99.        
    
100.         public void tryBlockRight(){
     
101.                
     
102.                 for(int ia=0; ia<4; ia++){//y
     
103.                         for(int ib=3; ib>=0; ib--){
     
104.                                 if(currentMap[ib][ia]){
     
105.                                         if(blockX+ib+1>WIDTH-1) return;
     
106.                                         if(isBlockExist[blockX+ib+1][ia])return;
     
107.                                 }
     
108.                         }
     
109.                 }
     
110.                 blockX++;
     
111.         }
     
112.        
     
113.         public void tryBlockRotate(){
     
114.                 int rotated;
     
115.                 if(currentBlockRotation == 3)rotated = 0;
     
116.                 else rotated = currentBlockRotation + 1;
     
117.                
     
118.                 boolean rotateMap[][] = new boolean[4][4];
     
119.                 int array = 0x8000;
     
120.                 for(int iy=0; iy<4; iy++){
     
121.                         for(int ix=0; ix<4; ix++){
     
122.                                 rotateMap[ix][iy] = (Blocks.map[currentBlockType][rotated] & array) !=0;
     
123.                                 if(rotateMap[ix][iy]){
     
124.                                         if(ix+blockX<0)return;
     
125.                                         if(isBlockExist[ix+blockX][iy+blockY])return;
     
126.                                 }
     
127.                                 array = array >> 1;
     
128.                         }
     
129.                 }
     
130.                 for(int ia=0; ia<4; ia++){
     
131.                         for(int ib=0; ib<4; ib++){
     
132.                                 currentMap[ia][ib] = (boolean)rotateMap[ia][ib];
     
133.                         }
     
134.                 }
     
135.                 currentBlockRotation = rotated;
     
136.                
     
137.         }
     
138.        
     
139.         public void gameStartOrPause(){
     
140.                 isGameRunning = !isGameRunning;
     
141.                
     
142.         }
     
143.        
     
144.         public void locateBlock(){
     
145.                
     
146.                 for(int iy=0; iy<4; iy++){
     
147.                         for(int ix=0; ix<4; ix++){
     
148.                                 if(currentMap[ix][iy]){
     
149.                                         isBlockExist[blockX+ix][blockY+iy] = true;
     
150.                                 }
     
151.                         }
     
152.                 }
     
153.         }
     
154.        
     
155.         public int tryRemoveRow(){
     
156.                 int removedRows = 0;
     
157.                
     
158.                 for(int iy=HEIGHT-1+4; iy>4; iy--){
     
159.                         for(int ix=0; ix<WIDTH; ix++){
     
160.                                 if(!isBlockExist[ix][iy]){
     
161.                                         break;
     
162.                                 }
     
163.                                 if(ix==WIDTH-1){
     
164.                                         removedRows++;
     
165.                                         for(int ia=iy; ia>4;ia--){//y from down to up
     
166.                                                 for(int ib=0; ib<WIDTH; ib++){
     
167.                                                         isBlockExist[ib][ia] = isBlockExist[ib][ia-1];
     
168.                                                 }
     
169.                                         }
     
170.                                         iy++;
     
171.                                 }
     
172.                         }
     
173.                 }
     
174.                
     
175.                
     
176.                 score+=10*removedRows;
     
177.                
     
178.                 //&&&&&&&&&&&&&&&&&&&&
     
179.                 return removedRows;                        //return the number of removed Lines
     
180.         }
     
181.        
     
182.         public boolean isGameOver(){
     
183.                 for(int ix=0; ix<WIDTH; ix++){
     
184.                         if(isBlockExist[ix][4])return true;
     
185.                 }
     
186.                 //&&&&&&&&&&&&&
     
187.                 return false;                //check whether the game is over
     
188.         }
     
189. 
     
190. }
     

复制代码

最后是存储方块形状的类Blocks，用十六位的int来代表4*4棋盘上的方块数据

1. package ro;
   
2. 
   
3. public class Blocks {
   
4.         //block version,rotation
   
5.         public static final int map[][] = {
   
6.                         {0x06c0,0x0462,0x06c0,0x0462},//反之字
   
7.                         {0x0c60,0x04c8,0x0c60,0x04c8},//之字
   
8.                         {0x0660,0x0660,0x0660,0x0660},//正方形
   
9.                         {0x08e0,0x0644,0x00e2,0x044c},//左手拐
   
10.                         {0x02e0,0x0446,0x00e8,0x0c44},//右手拐
    
11.                         {0x4444,0x00f0,0x4444,0x00f0},//长条
    
12.                         {0x04e0,0x0464,0x00e4,0x04c4}//三角
    
13.         };
    
14. }
    

复制代码

显而易见我在Java se上的代码没怎么改就直接搬过来了。嗯，所以说Java的可移植性比G语言强无限大倍（G语言的可移植性大概是零吧。。。）

想转行lejos Java 的快上车啊啊啊！！

hello怪

附加jar文件以及java源代码：RussianBlocks
重要#########第一代第二版已发布，详情见9楼

hello怪

当当当当！历经一天时间，nxt版本写完了！

其实我大部分代码全是从Java SE版俄罗斯方块上直接搬过来的（笑）
上源码：

上图上视频
（视频是没有声音的，不用调大声音了：-）：

我叫_Madara

附带代码

我叫_Madara

牛B

lwl5633

请问现在 ev3 支持第三方的编程有哪些？ 除了lejos.

hello怪

lwl5633 发表于 2016-8-10 16:33
请问现在 ev3 支持第三方的编程有哪些？ 除了lejos.

嗯，这个我还真不太清楚，不过似乎labview, matlab也支持ev3编程（如果把labview算在内的话）

可能在可移植性，功能和可扩展度方面只有matlab能和lejos比拼吧。。。（笑）

hello怪

第一代第二版登场啦！

我进行了大规模的更新和bug修复：


横向的屏幕不够经典？我们也深有此感！于是，nxt从此横过来用！竖着屏幕玩才是王道！

#8*8的方格数怎么够？要玩就玩大个的！版面数已由8*8升级到8*10！更多可能与机会！

##全新的BGM功能火热登场啦！！”原汁原味“的背景音乐让你全身燃起来！

###最新的触控传感器控制了左右移动！向左为一号触摸传感器，向右为二号传感器，手感爆棚！！

####不想等待方块缓慢下落？用nxt左键即可让他们极速落下！原有的加速下落功能已移至灰色退出键！

#####总有激情一刻，总有短暂离开——nxt右键最懂你！全新的暂停/继续功能，让你短暂抽身也无妨！

######俄罗斯方块是智者的战场，同时消去多行更应赢得奖赏！分数机能全新改版，消去一行得十分，两行得40分，三行90分，四行160分！让分数像火箭一样飞升！

#######便捷的消息功能，让您实时获取分数奖励情况！


嘛，写了这么多，总而言之就一句话：更新太多啦！自己试去吧！


（打包的文件价值一乐币，以希望大家多多发言发干货，谢谢大家的支持啦！

hello怪

视频放出：

搭建狂魔

请允许我发一个 吊 字~

天殇

强顶

糊糊

今天才看到，赞一个

noir

学习。。。。