黑马程序员技术交流社区

标题: 【送分】第七题 位运算 代码公布 有问题回帖，我都会帮忙 [打印本页]
作者: 刘蕴学    时间: 2012-5-20 21:28
标题: 【送分】第七题 位运算 代码公布 有问题回帖，我都会帮忙
本帖最后由 刘蕴学 于 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)



作者: 林豪    时间: 2012-5-21 00:42
这个已经不再送分的范围了~~~~~题目小点嘛....对于我们这些刚看完基础的人很有压力
作者: 王德升    时间: 2012-5-21 08:28
亚历山大阿，
你学了多久了，
作者: 林豪    时间: 2012-5-21 11:57
{:soso_e127:}我网上看了看最少的也有700行
作者: 刘蕴学    时间: 2012-5-21 15:40
  1. package tetris;

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


  11. public class ShapesUtil
  12. {

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

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

这是什么格式的文档，刚开始我以为是截图呢，请指教
作者: 李红飞    时间: 2012-5-24 00:46
500的规定呀，代码太多了。




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2