A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 刘蕴学 于 2012-5-23 14:18 编辑


第一个,数据存储
1.用最少的占用空间存储俄罗斯方块的所有图形
2.每个图形4帧相连
3.文件大小限制在56B以内(包括56B)
第一题答案在5楼,算是后边题的一个小提示吧

第二个,实现游戏区域的碰撞检测
1.根据第一小题中的存储方式存储游戏区域
2.碰撞检测完全位运算
3.包括左边界,右边界,下边界
4.包括左碰撞,右碰撞,下碰撞(并在下碰撞时落下图形到数据区)
5.变形时的边界以及碰撞检测

第三个,完整实现整个俄罗斯方块的基本功能
有效核心代码不超过500行
不强制实现图形化界面,功能代码实现就行。

难看是难看点,将就吧,不过顶多是把代码画格子换成图片
如果你做过第六题,也看过5楼第一小题的答案,之后在看这个图片,你还是不理解,我就没什么要说的了,我也无能为力。

bug我侧过应该没有了,至于代码,400多行,当然把那些封装之类的无聊代码全干掉,200行用不了,有些地方为了方便查看所以代码并没有合并
注释我实在是不知道怎么写。。。这东西其实很容易理解。。。有问题回帖问吧,我尽量讲的通俗易懂。。。
tetris.zip (5.98 KB, 下载次数: 27)



评分

参与人数 4黑马币 +120 收起 理由
攻城狮 + 30 很给力!
王永旺 + 30 最近忙着看视频,先赞助你一下。顶你。.
李震 李震 李震 + 30
kevindavid + 30

查看全部评分

10 个回复

正序浏览
500的规定呀,代码太多了。
回复 使用道具 举报
刘蕴学 发表于 2012-5-21 15:40

这是什么格式的文档,刚开始我以为是截图呢,请指教

点评

这个20字节的截图数据只有我自己的程序可以解析,或者兼容我这种格式的程序也可以,这就是为什么同样的视频,缓冲有快慢之分,在于数据存储上  发表于 2012-5-22 12:46
如果你单只这个截图,那么实际上他的字节数大小是15*4+2字节 Jpg截图是68KB,数据如果进行压缩,还可以更小,仅不到20字节  发表于 2012-5-22 12:22
回复 使用道具 举报
荣天 中级黑马 2012-5-21 22:01:48
9#
     {:soso_e179:}
回复 使用道具 举报
惭愧呀,回了很久都没达到500的规定呀,我的代码太多了。
回复 使用道具 举报
楼主是骨灰级人物啊,俺们这些小菜鸟惭愧{:soso_e105:}

点评

额,我也还是菜鸟。。。  发表于 2012-5-21 17:42
回复 使用道具 举报
坐等 ............高人贴上答案..

点评

坐着等不如自己试试,说不定你会做的比我好  发表于 2012-5-21 17:43
回复 使用道具 举报
  1. package tetris;

  2. import java.io.DataInputStream;
  3. import java.io.DataOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;


  8. public class ShapesUtil
  9. {

  10.        
  11.         public static void main(String[] args) throws IOException
  12.         {
  13.                 //先看代码最后的那个三位数组,俄罗斯方块对于我们来说
  14.                 //没一个单元格cell,只有2个状态吧?一个就是有,一个
  15.                 //就是没有,或者理解成可通行的和障碍物
  16.                
  17.                 /*
  18.                  * 0 0 0 0
  19.                  * 1 0 0 0
  20.                  * 1 0 0 0
  21.                  * 1 1 0 0
  22.                  */
  23.                
  24.                 //上方这个图形,咱们就可以用一个short表示了吧,16位
  25.                 //这也是为什么会有第六题的原因,循序渐进。
  26.                
  27.                 //其实很多人做这个东西,并不是按位存储的,而就是一个
  28.                 //3维int数组,每次3层循环迭代,效率是问题不说,内存
  29.                 //和硬盘占用也大,早先的手机ROM很小,流量也贵,下载
  30.                 //东西节约流量是很重要的,现在的3G流量虽然便宜,但
  31.                 //也需要重视,另外一个就是RAM也就是我们说的内存,
  32.                 //在我最早做手机游戏的时候,200K的内存,去掉其他占用
  33.                 //留给你的内存使用是很少的,所以节约内存也是一个好习惯
  34.                
  35.                 //当然说那么多都是废话,咱们这里只是练习一下位运算符和
  36.                 //一些存储方面的常见用法。
  37.                
  38.                 //运行一次之后刷新下你的eclipse项目,就可以看见这个cfg
  39.                 //文件,至于这个后缀你随便起什么,因为除了咱们的程序能
  40.                 //正常解析之外,你拿记事本是看不出来什么东西的。
  41.                
  42.                 //而后缀名只是一种便捷的标识,他并不能证明这个后缀名是靠
  43.                 //什么程序解析,就像咱们这个不能被记事本解析一样,你会看
  44.                 //到乱码
  45.                 //如果咱们取个Tetris.txt 你还真的去拿记事本看?那样的话
  46.                 //你就会看见下边这个天书,或许你苦思冥想数十载也可能看懂
  47.                 //? ."€ ?& ?? Nb@ ? ? ? ? l? l? ?? ?菵D UU 
  48.                
  49.                 writeShapes();       
  50.                 readShapes();
  51.         }
  52.        
  53.         /**
  54.          * 保存俄罗斯方块图形数据的文件路径
  55.          */
  56.         public static final String FILE_NAME = "Tetris.cfg";
  57.        
  58.         public static void readShapes() throws IOException
  59.         {
  60.                 FileInputStream fis = new FileInputStream(new File(FILE_NAME));
  61.                 DataInputStream dis = new DataInputStream(fis);
  62.                 long shape = 0;
  63.                 //这里的这个dis.available() > 0算是一种便捷用法
  64.                 //也是避免一些IO异常的方式。
  65.                
  66.                 //为什么我不需要知道文件内有多少个图形?
  67.                 //实际上如果你的写入和读取是对等,用dis.available() > 0
  68.                 //这种方式并不会导致EOF异常
  69.                 //EOF的一种情况是你的读取字节大于写入字节。
  70.                 while(dis.available() > 0)
  71.                 {
  72.                         shape = dis.readLong();
  73.                         System.out.println(getLongToBinary(shape));
  74.                 }
  75.         }
  76.        
  77.         /**
  78.          * 将图形数据写入文件,根据图形的实际数据进行位合并
  79.          * 并每个short表示一帧,每个long表示一个图形
  80.          * @throws IOException
  81.          */
  82.         public static void writeShapes() throws IOException
  83.         {
  84.                 FileOutputStream fos = new FileOutputStream(new File(FILE_NAME));
  85.                 DataOutputStream dos = new DataOutputStream(fos);
  86.                
  87.                 //这个shape就是换算过的图形,用来写入文件
  88.                 long shape = 0;
  89.                 //将图形循环写入文件
  90.                 //shape_index 在这里表示图形索引
  91.                 //frame_index 表示这个图形的帧索引
  92.                 //bit         表示当前帧数据上的2进制位
  93.                 for (int shape_index = 0; shape_index < shapes.length; shape_index++)
  94.         {
  95.                         //清0,将缓冲的上一个图形删除
  96.                         shape &= 0;

  97.                         //计算当前图形的每一2进制位数据,最后保存为一个long
  98.                         //并将该数据写入文件
  99.                 for (int frame_index = 0; frame_index < shapes[shape_index].length; frame_index++)
  100.             {
  101.                     for (int bit = 0; bit < shapes[shape_index][frame_index].length; bit++)
  102.                 {
  103.                             /*
  104.                                      * 0 0 0 0
  105.                                      * 1 0 0 0
  106.                                      * 1 0 0 0
  107.                                      * 1 1 0 0
  108.                                      */
  109.                            
  110.                             //从数据源中,可以看出来这就是一个short,也就是16位的2进制数据
  111.                             //由于我们规定每个图形都是4帧,所以没一个图形的完整数据就是64位
  112.                             //也就是一个long
  113.                            
  114.                             //(long)shapes[shape_index][frame_index][bit] 表示的当前位
  115.                             //但是咱们的循环是0开始,所以读入的顺序不会错,但是写进去的话就是
  116.                             //倒叙了,因为我们是从最低位为起始位的。
  117.                            
  118.                             //(((frame_index) << 4) 表示的是我们当前帧需要前进多少位
  119.                             //我们划分数据区是16位一帧,最多是左移48位表示高16位
  120.                             //而由于前边说的我们读入和写入的顺序是相反的,所以这里的这个
  121.                             //(((frame_index) << 4),我们还得做下处理,在倒叙一下就变
  122.                             //正序了吧?所以这里需要一个((3 - frame_index) << 4)
  123.                            
  124.                             //15-bit 的原理跟上边的帧序列一样
  125.                             //而这里的 shape |= 就跟我们前边讲的往上添数据一样的用法
  126.                         shape |= (long)shapes[shape_index][frame_index][bit] << (((3 - frame_index) << 4) + (15-bit));
  127.                 }
  128.             }
  129.                 dos.writeLong(shape);
  130.         }
  131.                 dos.close();
  132.         }
  133.        
  134.         public static final String DEFAULT_LONG_ZERO = "0000000000000000000000000000000000000000000000000000000000000000";
  135.         public static final String getLongToBinary(long value)
  136.         {
  137.                 String binary = Long.toBinaryString(value);
  138.                 int length = Long.SIZE - binary.length();
  139.                 return DEFAULT_LONG_ZERO.substring(0, length) + binary;
  140.         }
  141.        
  142.         /**
  143.          * 俄罗斯方块中的图形,第一维表示的是图形的索引
  144.          * 第二维表示的是这个图形的帧索引
  145.          * 第三维表示这个图形当前帧的数据,每4位为一行
  146.          */
  147.         public static final int[][][] shapes =
  148.                 {
  149.                         /*
  150.                          * 0 0 0 0
  151.                          * 1 0 0 0
  152.                          * 1 0 0 0
  153.                          * 1 1 0 0
  154.                          */
  155.                         {
  156.                                 {
  157.                                         0, 0, 0, 0,
  158.                                         1, 0, 0, 0,
  159.                                         1, 0, 0, 0,
  160.                                         1, 1, 0, 0,
  161.                                 },
  162.                                
  163.                                 {       
  164.                                         0, 0, 0, 0,
  165.                                         0, 0, 0, 0,
  166.                                         0, 0, 1, 0,
  167.                                         1, 1, 1, 0,
  168.                                 },
  169.                                
  170.                                 {       
  171.                                         0, 0, 0, 0,
  172.                                         0, 1, 1, 0,
  173.                                         0, 0, 1, 0,
  174.                                         0, 0, 1, 0,
  175.                                 },
  176.                                
  177.                                 {       
  178.                                         0, 0, 0, 0,
  179.                                         1, 1, 1, 0,
  180.                                         1, 0, 0, 0,
  181.                                         0, 0, 0, 0,
  182.                                 }
  183.                         },
  184.                        
  185.                         /*
  186.                          * 0 0 0 0
  187.                          * 0 0 0 0
  188.                          * 1 0 0 0
  189.                          * 1 1 1 0
  190.                          */
  191.                         {
  192.                                 {
  193.                                         0, 0, 0, 0,
  194.                                         0, 0, 0, 0,
  195.                                         1, 0, 0, 0,
  196.                                         1, 1, 1, 0,
  197.                                 },
  198.                                
  199.                                 {       
  200.                                         0, 0, 0, 0,
  201.                                         0, 0, 1, 0,
  202.                                         0, 0, 1, 0,
  203.                                         0, 1, 1, 0,
  204.                                 },
  205.                                
  206.                                 {       
  207.                                         0, 0, 0, 0,
  208.                                         1, 1, 1, 0,
  209.                                         0, 0, 1, 0,
  210.                                         0, 0, 0, 0,
  211.                                 },
  212.                                
  213.                                 {       
  214.                                         0, 0, 0, 0,
  215.                                         1, 1, 0, 0,
  216.                                         1, 0, 0, 0,
  217.                                         1, 0, 0, 0,
  218.                                 }
  219.                         },
  220.                        
  221.                         /*
  222.                          * 0 0 0 0
  223.                          * 1 0 0 0
  224.                          * 1 1 0 0
  225.                          * 1 0 0 0
  226.                          */
  227.                         {
  228.                                 {
  229.                                         0, 0, 0, 0,
  230.                                         1, 0, 0, 0,
  231.                                         1, 1, 0, 0,
  232.                                         1, 0, 0, 0,
  233.                                 },
  234.                                
  235.                                 {       
  236.                                         0, 0, 0, 0,
  237.                                         0, 0, 0, 0,
  238.                                         0, 1, 0, 0,
  239.                                         1, 1, 1, 0,
  240.                                 },
  241.                                
  242.                                 {       
  243.                                         0, 0, 0, 0,
  244.                                         0, 0, 1, 0,
  245.                                         0, 1, 1, 0,
  246.                                         0, 0, 1, 0,
  247.                                 },
  248.                                
  249.                                 {       
  250.                                         0, 0, 0, 0,
  251.                                         1, 1, 1, 0,
  252.                                         0, 1, 0, 0,
  253.                                         0, 0, 0, 0,
  254.                                 }
  255.                         },
  256.                        
  257.                         /*
  258.                          * 0 0 0 0
  259.                          * 0 0 0 0
  260.                          * 1 1 0 0
  261.                          * 1 1 0 0
  262.                          */
  263.                         {
  264.                                 {
  265.                                         0, 0, 0, 0,
  266.                                         0, 0, 0, 0,
  267.                                         1, 1, 0, 0,
  268.                                         1, 1, 0, 0,
  269.                                 },
  270.                                
  271.                                 {       
  272.                                         0, 0, 0, 0,
  273.                                         0, 0, 0, 0,
  274.                                         1, 1, 0, 0,
  275.                                         1, 1, 0, 0,
  276.                                 },
  277.                                
  278.                                 {       
  279.                                         0, 0, 0, 0,
  280.                                         0, 0, 0, 0,
  281.                                         1, 1, 0, 0,
  282.                                         1, 1, 0, 0,
  283.                                 },
  284.                                
  285.                                 {       
  286.                                         0, 0, 0, 0,
  287.                                         0, 0, 0, 0,
  288.                                         1, 1, 0, 0,
  289.                                         1, 1, 0, 0,
  290.                                 }
  291.                         },
  292.                        
  293.                         /*
  294.                          * 0 0 0 0
  295.                          * 0 0 0 0
  296.                          * 0 1 1 0
  297.                          * 1 1 0 0
  298.                          */
  299.                         {
  300.                                 {
  301.                                         0, 0, 0, 0,
  302.                                         0, 0, 0, 0,
  303.                                         0, 1, 1, 0,
  304.                                         1, 1, 0, 0,
  305.                                 },
  306.                                
  307.                                 {       
  308.                                         0, 0, 0, 0,
  309.                                         1, 0, 0, 0,
  310.                                         1, 1, 0, 0,
  311.                                         0, 1, 0, 0,
  312.                                 },
  313.                                
  314.                                 {       
  315.                                         0, 0, 0, 0,
  316.                                         0, 0, 0, 0,
  317.                                         0, 1, 1, 0,
  318.                                         1, 1, 0, 0,
  319.                                 },
  320.                                
  321.                                 {       
  322.                                         0, 0, 0, 0,
  323.                                         1, 0, 0, 0,
  324.                                         1, 1, 0, 0,
  325.                                         0, 1, 0, 0,
  326.                                 }
  327.                         },
  328.                        
  329.                         /*
  330.                          * 0 0 0 0
  331.                          * 0 0 0 0
  332.                          * 1 1 0 0
  333.                          * 0 1 1 0
  334.                          */
  335.                         {
  336.                                 {
  337.                                         0, 0, 0, 0,
  338.                                         0, 0, 0, 0,
  339.                                         1, 1, 0, 0,
  340.                                         0, 1, 1, 0,
  341.                                 },
  342.                                
  343.                                 {       
  344.                                         0, 0, 0, 0,
  345.                                         0, 1, 0, 0,
  346.                                         1, 1, 0, 0,
  347.                                         1, 0, 0, 0,
  348.                                 },
  349.                                
  350.                                 {       
  351.                                         0, 0, 0, 0,
  352.                                         0, 0, 0, 0,
  353.                                         1, 1, 0, 0,
  354.                                         0, 1, 1, 0,
  355.                                 },
  356.                                
  357.                                 {       
  358.                                         0, 0, 0, 0,
  359.                                         0, 1, 0, 0,
  360.                                         1, 1, 0, 0,
  361.                                         1, 0, 0, 0,
  362.                                 }
  363.                         },
  364.                        
  365.                        
  366.                         /*
  367.                          * 1 0 0 0
  368.                          * 1 0 0 0
  369.                          * 1 0 0 0
  370.                          * 1 0 0 0
  371.                          */
  372.                         {
  373.                                 {
  374.                                         0, 1, 0, 0,
  375.                                         0, 1, 0, 0,
  376.                                         0, 1, 0, 0,
  377.                                         0, 1, 0, 0,
  378.                                 },
  379.                                
  380.                                 {       
  381.                                         0, 0, 0, 0,
  382.                                         0, 0, 0, 0,
  383.                                         0, 0, 0, 0,
  384.                                         1, 1, 1, 1,
  385.                                 },
  386.                                
  387.                                 {       
  388.                                         0, 1, 0, 1,
  389.                                         0, 1, 0, 1,
  390.                                         0, 1, 0, 1,
  391.                                         0, 1, 0, 1,
  392.                                 },
  393.                                
  394.                                 {       
  395.                                         0, 0, 0, 0,
  396.                                         0, 0, 0, 0,
  397.                                         0, 0, 0, 0,
  398.                                         1, 1, 1, 1,
  399.                                 }
  400.                         },
  401.                 };
  402. }
复制代码
回复 使用道具 举报
{:soso_e127:}我网上看了看最少的也有700行

点评

500行已经是很少的了,其实用不到300行,行数并不是主要的,主要的还是你代码实现  发表于 2012-5-21 12:27
回复 使用道具 举报
亚历山大阿,
你学了多久了,
回复 使用道具 举报
这个已经不再送分的范围了~~~~~题目小点嘛....对于我们这些刚看完基础的人很有压力

点评

只要你肯动手,nothing is impossible  发表于 2012-5-21 07:23
可以不写Gui,只实现功能,真没多难,我昨天一会就写完了  发表于 2012-5-21 06:53
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马