21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › MM32SPIN27PS实现俄罗斯方块游戏
12下一页
返回列表 发新帖我要提问

[MM32硬件] MM32SPIN27PS实现俄罗斯方块游戏

[复制链接]
1116|33
 楼主| 米多0036 发表于 2023-2-23 16:06 | 显示全部楼层 |阅读模式
函数, se, ps, 俄罗斯方块游戏, spi, MM32
大概思路
因为智能车实验室选拔需要（虽然很遗憾，今年学校实验室又不收大二的学生了），用MM32做一个俄罗斯方块的小游戏。整体方案的硬件部分由一个MM32SPIN27PS黑色芯片、五向按键开关以及1.8寸TFTLCD屏幕组成。分析下来主要实现要点有三个，游戏逻辑的实现，显示函数的实现，定时器的配置实现。

因为实验室提供了基础的调用教学和工程模板，没有配置环境等一系列问题，只需要调用工程模板里面的库函数实现上述三大功能。

画圆函数和画线函数
复制
  1. void Gui_DrawLine(u16 x0, u16 y0,u16 x1, u16 y1,u16 Color)  
    


  2. 

  3. {
    


  4. 

  5. int dx,       // difference in x's
    


  6. 

  7.   dy,       // difference in y's
    


  8. 

  9.   dx2,      // dx,dy * 2
    


  10. 

  11.   dy2, 
    


  12. 

  13.   x_inc,     // amount in pixel space to move during drawing
    


  14. 

  15.   y_inc,     // amount in pixel space to move during drawing
    


  16. 

  17.   error,     // the discriminant i.e. error i.e. decision variable
    


  18. 

  19.   index;     // used for looping    
    


  20. 

  21.  
    


  22. 

  23.  
    


  24. 

  25.  Lcd_SetXY(x0,y0);
    


  26. 

  27.  dx = x1-x0;//计算x距离
    


  28. 

  29.  dy = y1-y0;//计算y距离
    


  30. 

  31.  
    


  32. 

  33.  if (dx>=0)
    


  34. 

  35.  {
    


  36. 

  37. ​      x_inc = 1;
    


  38. 

  39.  }
    


  40. 

  41.  else
    


  42. 

  43.  {
    


  44. 

  45. ​      x_inc = -1;
    


  46. 

  47. ​      dx  = -dx; 
    


  48. 

  49.  } 
    


  50. 

  51.  
    


  52. 

  53.  if (dy>=0)
    


  54. 

  55.  {
    


  56. 

  57. ​      y_inc = 1;
    


  58. 

  59.  } 
    


  60. 

  61.  else
    


  62. 

  63.  {
    


  64. 

  65. ​      y_inc = -1;
    


  66. 

  67. ​      dy  = -dy; 
    


  68. 

  69.  } 
    


  70. 

  71.  
    


  72. 

  73.  dx2 = dx << 1;
    


  74. 

  75.  dy2 = dy << 1;
    


  76. 

  77.  
    


  78. 

  79.  if (dx > dy)//x距离大于y距离，那么每个x轴上只有一个点，每个y轴上有若干个点
    


  80. 

  81.  {//且线的点数等于x距离，以x轴递增画点
    


  82. 

  83. ​      // initialize error term
    


  84. 

  85. ​      error = dy2 - dx; 
    


  86. 

  87.  
    


  88. 

  89. ​      // draw the line
    


  90. 

  91. ​      for (index=0; index <= dx; index++)//要画的点数不会超过x距离
    


  92. 

  93. ​      {
    


  94. 

  95. ​           //画点
    


  96. 

  97. ​           Gui_DrawPoint(x0,y0,Color);
    


  98. 

  99. ​           
    


  100. 

  101. ​           // test if error has overflowed
    


  102. 

  103. ​           if (error >= 0) //是否需要增加y坐标值
    


  104. 

  105. ​           {
    


  106. 

  107. ​                error-=dx2;
    


  108. 

  109.  
    


  110. 

  111. ​                // move to next line
    


  112. 

  113. ​                y0+=y_inc;//增加y坐标值
    


  114. 

  115. ​           } // end if error overflowed
    


  116. 

  117.  
    


  118. 

  119. ​           // adjust the error term
    


  120. 

  121. ​           error+=dy2;
    


  122. 

  123.  
    


  124. 

  125. ​           // move to the next pixel
    


  126. 

  127. ​           x0+=x_inc;//x坐标值每次画点后都递增1
    


  128. 

  129. ​      } // end for
    


  130. 

  131.  } // end if |slope| <= 1
    


  132. 

  133.  else//y轴大于x轴，则每个y轴上只有一个点，x轴若干个点
    


  134. 

  135.  {//以y轴为递增画点
    


  136. 

  137. ​      // initialize error term
    


  138. 

  139. ​      error = dx2 - dy; 
    


  140. 

  141.  
    


  142. 

  143. ​      // draw the line
    


  144. 

  145. ​      for (index=0; index <= dy; index++)
    


  146. 

  147. ​      {
    


  148. 

  149. ​           // set the pixel
    


  150. 

  151. ​           Gui_DrawPoint(x0,y0,Color);
    


  152. 

  153.  
    


  154. 

  155. ​           // test if error overflowed
    


  156. 

  157. ​           if (error >= 0)
    


  158. 

  159. ​           {
    


  160. 

  161. ​                error-=dy2;
    


  162. 

  163.  
    


  164. 

  165. ​                // move to next line
    


  166. 

  167. ​                x0+=x_inc;
    


  168. 

  169. ​           } 
    

  170. ​           error+=dx2;
    

  171. ​           y0+=y_inc;
    


  172. 

  173. ​      } 
    

  174.  }
    

  175. }


————————————————


回复

收藏 举报

评论

米多0036
———————————————— 版权声明：本文为CSDN博主「唔~~」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_65439361/article/details/127149980  发表于 2023-2-23 16:06

相关帖子
 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
复制
  1. void Gui_Circle(u16 X,u16 Y,u16 R,u16 fc) 
    


  2. 

  3. { 
    


  4. 

  5.   unsigned short a,b; 
    


  6. 

  7.   int c; 
    


  8. 

  9.   a=0; 
    


  10. 

  11.   b=R; 
    


  12. 

  13.   c=3-2*R; 
    


  14. 

  15.   while (a<b) 
    


  16. 

  17.   { 
    


  18. 

  19. ​    Gui_DrawPoint(X+a,Y+b,fc);   //    7 
    


  20. 

  21. ​    Gui_DrawPoint(X-a,Y+b,fc);   //    6 
    


  22. 

  23. ​    Gui_DrawPoint(X+a,Y-b,fc);   //    2 
    


  24. 

  25. ​    Gui_DrawPoint(X-a,Y-b,fc);   //    3 
    


  26. 

  27. ​    Gui_DrawPoint(X+b,Y+a,fc);   //    8 
    


  28. 

  29. ​    Gui_DrawPoint(X-b,Y+a,fc);   //    5 
    


  30. 

  31. ​    Gui_DrawPoint(X+b,Y-a,fc);   //    1 
    


  32. 

  33. ​    Gui_DrawPoint(X-b,Y-a,fc);   //    4 
    


  34. 

  35.  
    


  36. 

  37. ​    if(c<0) c=c+4*a+6; 
    


  38. 

  39. ​    else 
    


  40. 

  41. ​    { 
    


  42. 

  43. ​      c=c+4*(a-b)+10; 
    


  44. 

  45. ​      b-=1; 
    


  46. 

  47. ​    } 
    


  48. 

  49. ​    a+=1; 
    


  50. 

  51.   } 
    


  52. 

  53.   if (a==b) 
    


  54. 

  55.   { 
    


  56. 

  57. ​    Gui_DrawPoint(X+a,Y+b,fc); 
    


  58. 

  59. ​    Gui_DrawPoint(X+a,Y+b,fc); 
    


  60. 

  61. ​    Gui_DrawPoint(X+a,Y-b,fc); 
    


  62. 

  63. ​    Gui_DrawPoint(X-a,Y-b,fc); 
    


  64. 

  65. ​    Gui_DrawPoint(X+b,Y+a,fc); 
    


  66. 

  67. ​    Gui_DrawPoint(X-b,Y+a,fc); 
    


  68. 

  69. ​    Gui_DrawPoint(X+b,Y-a,fc); 
    


  70. 

  71. ​    Gui_DrawPoint(X-b,Y-a,fc); 
    


  72. 

  73.   } 
    


  74. 

  75. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
方块绘制函数
TFT显示屏为128*160，选取10*10作为一个方块，游戏界面可以设置为长15格，宽12格，右侧留出一格提前显示下一个俄罗斯方块。
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
复制
  1. void Draw_realbox(uint16 x,uint16 y)
    

  2. {
    

  3.         uint8 i,n;
    

  4.         for(i=1;i<=8;i++)//绘制小方块内填充色8*8
    

  5.         {
    

  6.                 for(n=1;n<=8;n++)
    

  7.                 {
    

  8.                         lcd_drawpoint((x+i),(y+n),RED);        
    

  9.                 }        
    

  10.         }
    

  11.         for(i=0;i<=9;i++)//绘制小方块轮廓10*10
    

  12.         {
    

  13.                 lcd_drawpoint((x+i),y,BLACK        );
    

  14.                 lcd_drawpoint((x+i),(y+9),BLACK        );                
    

  15.                 lcd_drawpoint(x,(y+i),BLACK        );                
    

  16.                 lcd_drawpoint((x+9),(y+i),BLACK        );                                
    

  17.         }        
    

  18. }
    


  19. 

  20. void Draw_realbox1(uint16 x,uint16 y)
    

  21. {
    

  22.         uint8 i,n;
    

  23.         for(i=1;i<=3;i++)
    

  24.         {
    

  25.                 for(n=1;n<=3;n++)
    

  26.                 {
    

  27.                         lcd_drawpoint((x+i),(y+n),RED);        
    

  28.                 }        
    

  29.         }
    

  30.         for(i=0;i<=4;i++)
    

  31.         {
    

  32.                 lcd_drawpoint((x+i),y,BLACK        );
    

  33.                 lcd_drawpoint((x+i),(y+4),BLACK        );                
    

  34.                 lcd_drawpoint(x,(y+i),BLACK        );                
    

  35.                 lcd_drawpoint((x+4),(y+i),BLACK        );                                
    

  36.         }        
    

  37. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
复制
  1. void Draw_realbox(uint16 x,uint16 y)
    

  2. {
    

  3.         uint8 i,n;
    

  4.         for(i=1;i<=8;i++)//绘制小方块内填充色8*8
    

  5.         {
    

  6.                 for(n=1;n<=8;n++)
    

  7.                 {
    

  8.                         lcd_drawpoint((x+i),(y+n),RED);        
    

  9.                 }        
    

  10.         }
    

  11.         for(i=0;i<=9;i++)//绘制小方块轮廓10*10
    

  12.         {
    

  13.                 lcd_drawpoint((x+i),y,BLACK        );
    

  14.                 lcd_drawpoint((x+i),(y+9),BLACK        );                
    

  15.                 lcd_drawpoint(x,(y+i),BLACK        );                
    

  16.                 lcd_drawpoint((x+9),(y+i),BLACK        );                                
    

  17.         }        
    

  18. }
    


  19. 

  20. void Draw_realbox1(uint16 x,uint16 y)
    

  21. {
    

  22.         uint8 i,n;
    

  23.         for(i=1;i<=3;i++)
    

  24.         {
    

  25.                 for(n=1;n<=3;n++)
    

  26.                 {
    

  27.                         lcd_drawpoint((x+i),(y+n),RED);        
    

  28.                 }        
    

  29.         }
    

  30.         for(i=0;i<=4;i++)
    

  31.         {
    

  32.                 lcd_drawpoint((x+i),y,BLACK        );
    

  33.                 lcd_drawpoint((x+i),(y+4),BLACK        );                
    

  34.                 lcd_drawpoint(x,(y+i),BLACK        );                
    

  35.                 lcd_drawpoint((x+4),(y+i),BLACK        );                                
    

  36.         }        
    

  37. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
删除方块实现方法是绘制成白色
复制
  1. void Del_realbox(uint16 x,uint16 y)
    

  2. {
    

  3.         uint8 i,n;
    

  4.         for(i=0;i<=9;i++)
    

  5.         {
    

  6.                 for(n=0;n<=9;n++)
    

  7.                 {
    

  8.                         lcd_drawpoint((x+i),(y+n),WHITE);        
    

  9.                 }        
    

  10.         }
    

  11. }
    


  12. 


  13. 

  14. void Del_realbox1(uint16 x,uint16 y)
    

  15. {
    

  16.         uint8 i,n;
    

  17.         for(i=0;i<=4;i++)
    

  18.         {
    

  19.                 for(n=0;n<=4;n++)
    

  20.                 {
    

  21.                         lcd_drawpoint((x+i),(y+n),WHITE);        
    

  22.                 }        
    

  23.         }
    

  24. }
    


  25.
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:07 | 显示全部楼层
删除方块实现方法是绘制成白色
复制
  1. void Del_realbox(uint16 x,uint16 y)
    

  2. {
    

  3.         uint8 i,n;
    

  4.         for(i=0;i<=9;i++)
    

  5.         {
    

  6.                 for(n=0;n<=9;n++)
    

  7.                 {
    

  8.                         lcd_drawpoint((x+i),(y+n),WHITE);        
    

  9.                 }        
    

  10.         }
    

  11. }
    


  12. 


  13. 

  14. void Del_realbox1(uint16 x,uint16 y)
    

  15. {
    

  16.         uint8 i,n;
    

  17.         for(i=0;i<=4;i++)
    

  18.         {
    

  19.                 for(n=0;n<=4;n++)
    

  20.                 {
    

  21.                         lcd_drawpoint((x+i),(y+n),WHITE);        
    

  22.                 }        
    

  23.         }
    

  24. }
    


  25.
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:08 | 显示全部楼层
有了以上两个函数，我们只需要在规定的坐标处调用四次小方块绘制或删除函数。即可得到或消除一块完整的俄罗斯方块，利用random产生随机数，加上switch语句进行选择需要何种方块，总方块在switch中设计了19种。
图形绘制函数如下（部分）：
复制
  1. void Del_tuxing(uint16 x,uint16 y,uint8 what)
    

  2. {
    

  3.         switch (what)
    

  4.         {
    

  5.                 case 1:
    

  6.                 {
    

  7.                 Del_realbox(x,y);
    

  8.                 Del_realbox(x+10,y);
    

  9.                 Del_realbox(x,y+10);
    

  10.                 Del_realbox(x+10,y+10);
    

  11.                 }
    

  12.                 break;
    

  13.                 
    

  14.                 case 2:
    

  15.                 {
    

  16.                 Del_realbox(x,y);
    

  17.                 Del_realbox(x+10,y);
    

  18.                 Del_realbox(x+20,y);
    

  19.                 Del_realbox(x+30,y);
    

  20.                 }
    

  21.                 break;
    

  22.                 
    

  23.                 case 3:
    

  24.                 {
    

  25.                 Del_realbox(x,y);
    

  26.                 Del_realbox(x,y+10);
    

  27.                 Del_realbox(x,y+20);
    

  28.                 Del_realbox(x,y+30);
    

  29.                 }
    

  30.                 break;
    

  31.                 
    

  32.                 case 4:
    

  33.                 {
    

  34.                 Del_realbox(x+10,y);
    

  35.                 Del_realbox(x,y+10);
    

  36.                 Del_realbox(x+10,y+10);
    

  37.                 Del_realbox(x+20,y+10);
    

  38.                 }
    

  39.                 break;
    

  40.                 
    

  41.                 case 5:
    

  42.                 {
    

  43.                 Del_realbox(x+10,y+10);
    

  44.                 Del_realbox(x,y);
    

  45.                 Del_realbox(x,y+10);
    

  46.                 Del_realbox(x,y+20);
    

  47.                 }
    

  48.                 break;
    


  49. 

  50.                 case 6:
    

  51.                 {
    

  52.                 Del_realbox(x,y+10);
    

  53.                 Del_realbox(x+10,y);
    

  54.                 Del_realbox(x+10,y+10);
    

  55.                 Del_realbox(x+10,y+20);
    

  56.                 }
    

  57.                 break;
    

  58.                 
    

  59.                 case 7:
    

  60.                 {
    

  61.                 Del_realbox(x+10,y+10);
    

  62.                 Del_realbox(x,y);
    

  63.                 Del_realbox(x+10,y);
    

  64.                 Del_realbox(x+20,y);
    

  65.                 }
    

  66.                 break;
    

  67.         
    

  68.                 case 8:
    

  69.                 {
    

  70.                 Del_realbox(x,y);
    

  71.                 Del_realbox(x,y+10);
    

  72.                 Del_realbox(x,y+20);
    

  73.                 Del_realbox(x+10,y+20);
    

  74.                 }
    

  75.                 break;
    

  76.                 
    

  77.                 case 9:
    

  78.                 {
    

  79.                 Del_realbox(x,y);
    

  80.                 Del_realbox(x,y+10);
    

  81.                 Del_realbox(x+10,y);
    

  82.                 Del_realbox(x+20,y);
    

  83.                 }
    

  84.                 break;
    

  85.                 
    

  86.                 case 10:
    

  87.                 {
    

  88.                 Del_realbox(x,y);
    

  89.                 Del_realbox(x+10,y);
    

  90.                 Del_realbox(x+10,y+10);
    

  91.                 Del_realbox(x+10,y+20);
    

  92.                 }
    

  93.                 break;
    

  94.                 
    

  95.                 case 11:
    

  96.                 {
    

  97.                 Del_realbox(x,y+10);
    

  98.                 Del_realbox(x+10,y+10);
    

  99.                 Del_realbox(x+20,y+10);
    

  100.                 Del_realbox(x+20,y);
    

  101.                 }
    

  102.                 break;
    

  103.                 
    

  104.                 case 12:
    

  105.                 {
    

  106.                 Del_realbox(x+10,y);
    

  107.                 Del_realbox(x+10,y+10);
    

  108.                 Del_realbox(x+10,y+20);
    

  109.                 Del_realbox(x,y+20);
    

  110.                 }
    

  111.                 break;
    

  112.                 
    

  113.                 case 13:
    

  114.                 {
    

  115.                 Del_realbox(x,y);
    

  116.                 Del_realbox(x+10,y);
    

  117.                 Del_realbox(x+20,y);
    

  118.                 Del_realbox(x+20,y+10);
    

  119.                 }
    

  120.                 break;
    

  121.                 
    

  122.                 case 14:
    

  123.                 {
    

  124.                 Del_realbox(x,y);
    

  125.                 Del_realbox(x+10,y);
    

  126.                 Del_realbox(x,y+10);
    

  127.                 Del_realbox(x,y+20);
    

  128.                 }
    

  129.                 break;
    

  130.                 
    

  131.                 case 15:
    

  132.                 {
    

  133.                 Del_realbox(x,y);
    

  134.                 Del_realbox(x,y+10);
    

  135.                 Del_realbox(x+10,y+10);
    

  136.                 Del_realbox(x+20,y+10);
    

  137.                 }
    

  138.                 break;
    

  139.                 
    

  140.                 
    

  141.                 case 16:
    

  142.                 {
    

  143.                 Del_realbox(x+10,y);
    

  144.                 Del_realbox(x,y+10);
    

  145.                 Del_realbox(x+10,y+10);
    

  146.                 Del_realbox(x,y+20);
    

  147.                 }
    

  148.                 break;
    

  149.                 
    

  150.                 case 17:
    

  151.                 {
    

  152.                 Del_realbox(x,y);
    

  153.                 Del_realbox(x+10,y);
    

  154.                 Del_realbox(x+10,y+10);
    

  155.                 Del_realbox(x+20,y+10);
    

  156.                 }
    

  157.                 break;
    

  158.                 
    

  159.                 case 18:
    

  160.                 {
    

  161.                 Del_realbox(x,y);
    

  162.                 Del_realbox(x,y+10);
    

  163.                 Del_realbox(x+10,y+10);
    

  164.                 Del_realbox(x+10,y+20);
    

  165.                 }
    

  166.                 break;
    

  167.                 
    

  168.                 case 19:
    

  169.                 {
    

  170.                 Del_realbox(x,y+10);
    

  171.                 Del_realbox(x+10,y+10);
    

  172.                 Del_realbox(x+10,y);
    

  173.                 Del_realbox(x+20,y);
    

  174.                 }
    

  175.                 break;
    

  176.         
    

  177.         
    

  178.         
    

  179.         
    

  180.         }
    


  181. 

  182. }
    


  183. 


  184. 

  185. void Del_tuxing1(uint16 x,uint16 y,uint8 what)
    

  186. {
    

  187.         switch (what)
    

  188.         {
    

  189.                 case 1:
    

  190.                 {
    

  191.                 Del_realbox1(x,y);
    

  192.                 Del_realbox1(x+5,y);
    

  193.                 Del_realbox1(x,y+5);
    

  194.                 Del_realbox1(x+5,y+5);
    

  195.                 }
    

  196.                 break;
    

  197.                 
    

  198.                 case 2:
    

  199.                 {
    

  200.                 Del_realbox1(x,y);
    

  201.                 Del_realbox1(x+5,y);
    

  202.                 Del_realbox1(x+10,y);
    

  203.                 Del_realbox1(x+15,y);
    

  204.                 }
    

  205.                 break;
    

  206.                 
    

  207.                 case 3:
    

  208.                 {
    

  209.                 Del_realbox1(x,y);
    

  210.                 Del_realbox1(x,y+5);
    

  211.                 Del_realbox1(x,y+10);
    

  212.                 Del_realbox1(x,y+15);
    

  213.                 }
    

  214.                 break;
    

  215.                 
    

  216.                 case 4:
    

  217.                 {
    

  218.                 Del_realbox1(x+5,y);
    

  219.                 Del_realbox1(x,y+5);
    

  220.                 Del_realbox1(x+5,y+5);
    

  221.                 Del_realbox1(x+10,y+5);
    

  222.                 }
    

  223.                 break;
    

  224.                 
    

  225.                 case 5:
    

  226.                 {
    

  227.                 Del_realbox1(x+5,y+5);
    

  228.                 Del_realbox1(x,y);
    

  229.                 Del_realbox1(x,y+5);
    

  230.                 Del_realbox1(x,y+10);
    

  231.                 }
    

  232.                 break;
    


  233. 

  234.                 case 6:
    

  235.                 {
    

  236.                 Del_realbox1(x,y+5);
    

  237.                 Del_realbox1(x+5,y);
    

  238.                 Del_realbox1(x+5,y+5);
    

  239.                 Del_realbox1(x+5,y+10);
    

  240.                 }
    

  241.                 break;
    

  242.                 
    

  243.                 case 7:
    

  244.                 {
    

  245.                 Del_realbox1(x+5,y+5);
    

  246.                 Del_realbox1(x,y);
    

  247.                 Del_realbox1(x+5,y);
    

  248.                 Del_realbox1(x+10,y);
    

  249.                 }
    

  250.                 break;
    

  251.         
    

  252.                 case 8:
    

  253.                 {
    

  254.                 Del_realbox1(x,y);
    

  255.                 Del_realbox1(x,y+5);
    

  256.                 Del_realbox1(x,y+10);
    

  257.                 Del_realbox1(x+5,y+10);
    

  258.                 }
    

  259.                 break;
    

  260.                 
    

  261.                 case 9:
    

  262.                 {
    

  263.                 Del_realbox1(x,y);
    

  264.                 Del_realbox1(x,y+5);
    

  265.                 Del_realbox1(x+5,y);
    

  266.                 Del_realbox1(x+10,y);
    

  267.                 }
    

  268.                 break;
    

  269.                 
    

  270.                 case 10:
    

  271.                 {
    

  272.                 Del_realbox1(x,y);
    

  273.                 Del_realbox1(x+5,y);
    

  274.                 Del_realbox1(x+5,y+5);
    

  275.                 Del_realbox1(x+5,y+10);
    

  276.                 }
    

  277.                 break;
    

  278.                 
    

  279.                 case 11:
    

  280.                 {
    

  281.                 Del_realbox1(x,y+5);
    

  282.                 Del_realbox1(x+5,y+5);
    

  283.                 Del_realbox1(x+10,y+5);
    

  284.                 Del_realbox1(x+10,y);
    

  285.                 }
    

  286.                 break;
    

  287.                 
    

  288.                 case 12:
    

  289.                 {
    

  290.                 Del_realbox1(x+5,y);
    

  291.                 Del_realbox1(x+5,y+5);
    

  292.                 Del_realbox1(x+5,y+10);
    

  293.                 Del_realbox1(x,y+10);
    

  294.                 }
    

  295.                 break;
    

  296.                 
    

  297.                 case 13:
    

  298.                 {
    

  299.                 Del_realbox1(x,y);
    

  300.                 Del_realbox1(x+5,y);
    

  301.                 Del_realbox1(x+10,y);
    

  302.                 Del_realbox1(x+10,y+5);
    

  303.                 }
    

  304.                 break;
    

  305.                 
    

  306.                 case 14:
    

  307.                 {
    

  308.                 Del_realbox1(x,y);
    

  309.                 Del_realbox1(x+5,y);
    

  310.                 Del_realbox1(x,y+5);
    

  311.                 Del_realbox1(x,y+10);
    

  312.                 }
    

  313.                 break;
    

  314.                 
    

  315.                 case 15:
    

  316.                 {
    

  317.                 Del_realbox1(x,y);
    

  318.                 Del_realbox1(x,y+5);
    

  319.                 Del_realbox1(x+5,y+5);
    

  320.                 Del_realbox1(x+10,y+5);
    

  321.                 }
    

  322.                 break;
    

  323.                 
    

  324.                 
    

  325.                 case 16:
    

  326.                 {
    

  327.                 Del_realbox1(x+5,y);
    

  328.                 Del_realbox1(x,y+5);
    

  329.                 Del_realbox1(x+5,y+5);
    

  330.                 Del_realbox1(x,y+10);
    

  331.                 }
    

  332.                 break;
    

  333.                 
    

  334.                 case 17:
    

  335.                 {
    

  336.                 Del_realbox1(x,y);
    

  337.                 Del_realbox1(x+5,y);
    

  338.                 Del_realbox1(x+5,y+5);
    

  339.                 Del_realbox1(x+10,y+5);
    

  340.                 }
    

  341.                 break;
    

  342.                 
    

  343.                 case 18:
    

  344.                 {
    

  345.                 Del_realbox1(x,y);
    

  346.                 Del_realbox1(x,y+5);
    

  347.                 Del_realbox1(x+5,y+5);
    

  348.                 Del_realbox1(x+5,y+10);
    

  349.                 }
    

  350.                 break;
    

  351.                 
    

  352.                 case 19:
    

  353.                 {
    

  354.                 Del_realbox1(x,y+5);
    

  355.                 Del_realbox1(x+5,y+5);
    

  356.                 Del_realbox1(x+5,y);
    

  357.                 Del_realbox1(x+10,y);
    

  358.                 }
    

  359.                 break;
    

  360.         }
    


  361. 

  362. }
    


  363.
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:08 | 显示全部楼层
数组实现逻辑
使用了15*12的数组来记录方块的位置，用0，1对当前方块进行标记，逻辑上可以进行后续的碰撞，方块消除的判断。需要区分改变数组状态并不等于直接显示，改变数组状态之后还需要调用相关的显示函数才可以实现实现相关的显示功能。
绘制一个状态
复制
  1. void Draw_a_zhuangtai(uint16 x,uint16 y)
    

  2. {
    

  3.           zhuangtai[y/10][x/10+1]=1;
    

  4. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:08 | 显示全部楼层
删除一个状态
复制
  1. void Del_a_zhuangtai(uint16 x,uint16 y)
    

  2. {
    

  3.           zhuangtai[y/10][x/10+1]=0;
    

  4. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:08 | 显示全部楼层
碰撞判断
使用求和的方式找出碰撞的方块。在方块没发生碰撞之前，对该数组求和的值为把目前数组扫一遍的值。当方块发生碰撞，两个方块之间的交集会使得方块占的值变化（变小），与原值比较后可得出方块是否碰撞，碰撞则返回一个值。
复制

  1. 

  2. int panduan(uint16 x,uint16 y,uint8 what,uint8 fangxiang)//碰撞检测
    

  3. {
    

  4.         uint16 sum1=0,sum2=0;
    

  5.         uint8 i,n;
    

  6.         uint8 sbuff[A][B];
    

  7.         x=x/10+1;//得到换算后的真实坐标
    

  8.         y=y/10;
    

  9.         for(i=0;i<A;i++)
    

  10.         {
    

  11.                 for(n=0;n<B;n++)
    

  12.                 {
    

  13.                         sbuff[i][n]=zhuangtai[i][n];
    

  14.                         sum1=sum1+zhuangtai[i][n];        
    

  15.                 }  
    

  16.         }
    

  17.         switch(fangxiang)
    

  18.         {
    

  19.                 case 1:Left_zhuangtai_move((x-1)*10,10*y,what);break;
    

  20.                 case 2:Down_zhuangtai_move((x-1)*10,10*y,what);break;
    

  21.                 case 3:Right_zhuangtai_move((x-1)*10,10*y,what);break;
    

  22.                 case 4:change_zhuangtai();break;
    

  23.                 
    

  24.         }
    

  25.                 for(i=0;i<A;i++)
    

  26.         {
    

  27.                 
    

  28.                 for(n=0;n<B;n++)
    

  29.                 {
    

  30.                         sum2=sum2+zhuangtai[i][n];        
    

  31.                         zhuangtai[i][n]=sbuff[i][n];                        
    

  32.     }
    

  33.         }        
    

  34.                 return !(sum1==sum2);
    

  35. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:09 | 显示全部楼层
物理消除
由函数xiaochu()实现，每发生一次碰撞就检测一次是否满足消除条件
复制
  1. void xiaochu()
    

  2. {
    

  3.         uint8 n;
    

  4.         for(n=12;n>0;n--)
    

  5.         {
    

  6.                 if(n>=12)
    

  7.                 {
    

  8.                         n=12;
    

  9.                 }
    

  10.                 if(        (
    

  11.                                         zhuangtai[n+1][1]&&zhuangtai[n+1][2]&&zhuangtai[n+1][3]&&zhuangtai[n+1][4]&&zhuangtai[n+1][5]&&zhuangtai[n+1][6]&&zhuangtai[n+1][7]&&zhuangtai[n+1][8]&&zhuangtai[n+1][9]&&zhuangtai[n+1][10]&&zhuangtai[n+1][11]
    

  12.                                 ) 
    

  13.                                  &&
    

  14.                                 !(
    

  15.                                         zhuangtai[n][1]&&zhuangtai[n][2]&&zhuangtai[n][3]&&zhuangtai[n][4]&&zhuangtai[n][5]&&zhuangtai[n][6]&&zhuangtai[n][7]&&zhuangtai[n][8]&&zhuangtai[n][9]&&zhuangtai[n][10]&&zhuangtai[n][11]
    

  16.                                         )
    

  17.                    )//描述：
    

  18.                   
    

  19.                 {
    

  20.                         lie_move(10*n);//将被消除行于其上一行交换 
    

  21.                         n=n+2;
    

  22.                 }
    

  23.                 
    

  24.                 if((
    

  25.                                 !zhuangtai[n][1]&&!zhuangtai[n][2]&&!zhuangtai[n][3]&&!zhuangtai[n][4]&&!zhuangtai[n][5]&&!zhuangtai[n][6]&&!zhuangtai[n][7]&&!zhuangtai[n][8]&&!zhuangtai[n][9]&&!zhuangtai[n][10]&&!zhuangtai[n][11]
    

  26.                                 )//该条件用于判断换行是否完成（因为换行瞬间两行是清空的，即均为0）
    

  27.                   )
    

  28.                 {
    

  29.                         for(n=0;n<12 ;n++){
    

  30.                                 if(
    

  31.                                                 (
    

  32.                                                 zhuangtai[n][1]&&zhuangtai[n][2]&&zhuangtai[n][3]&&zhuangtai[n][4]&&zhuangtai[n][5]&&zhuangtai[n][6]&&zhuangtai[n][7]&&zhuangtai[n][8]&&zhuangtai[n][9]&&zhuangtai[n][10]&&zhuangtai[n][11]
    

  33.                                                 )
    

  34.                                         ){
    

  35.                                                 Del_lie(n*10);
    

  36.                                                 fengshu++;
    

  37.                                                 display_fengshu();
    

  38.                                         if(fengshu%10==0)
    

  39.                                         {
    

  40.                                                 speed=speed-10;
    

  41.                                                 leave++;
    

  42.                                                 display_leave();                                
    

  43.                                         }
    

  44.                                 }        
    

  45.                         }
    

  46.         break;                
    

  47.                 }
    

  48.         }
    

  49. }
    


  50.
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:09 | 显示全部楼层
其中，消除函数的“消除”功能是由调用换行函数lie_move（）和删行函数Del_lie（）实现的
复制
  1. void lie_move(uint16 y)//交换上下两行的缓存值
    

  2. {
    

  3.         uint8 i;
    

  4.         y=y/10;
    

  5.         for(i=1;i<15;i++)
    

  6.         {
    

  7.                 if(zhuangtai[y][i]==1)
    

  8.                 {
    

  9.                         zhuangtai[y][i]=zhuangtai[y+1][i];
    

  10.                         zhuangtai[y+1][i]=1;
    

  11.                         
    

  12.                                 Del_realbox((i-1)*10,y*10);
    

  13.                         Draw_realbox((i-1)*10,(y+1)*10);
    

  14.                 }
    

  15.                 else if(zhuangtai[y][i]==0)
    

  16.                 {
    

  17.                         zhuangtai[y][i]=zhuangtai[y+1][i];
    

  18.                         zhuangtai[y+1][i]=0;
    

  19.                         
    

  20.                                 Del_realbox((i-1)*10,y*10);
    

  21.                         Del_realbox((i-1)*10,(y+1)*10);
    

  22.                 }
    

  23.         }
    

  24. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:09 | 显示全部楼层
复制
  1. void Del_lie(uint16 y)//删除一行
    

  2. {
    

  3.         uint8 i;
    

  4.         y=y/10;
    

  5.         for(i=1;i<15;i++)
    

  6.         {
    

  7.                 zhuangtai[y][i]=0;
    

  8.                 Del_realbox((i-1)*10,y*10);
    

  9.         }
    

  10. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:09 | 显示全部楼层
形状控制函数
绘制出规定形状的俄罗斯方块的函数，一共有两个，change()函数用于绘制LCD上的，change_Zhuangtai()函数用于改变状态数组中的。
复制
  1. void change()
    

  2. {
    

  3.         switch(what)
    

  4.         {
    

  5.                 case 1:break;
    

  6.                 
    

  7.                 case 2:Del(x,y,2);Draw(x,y,3);what=3;break;
    

  8.                 case 3:Del(x,y,3);Draw(x,y,2);what=2;break;
    

  9.                 
    

  10.                 case 4:Del(x,y,4);Draw(x,y,5);what=5;break;
    

  11.                 case 5:Del(x,y,5);Draw(x,y,7);what=7;break;
    

  12.                 case 6:Del(x,y,6);Draw(x,y,4);what=4;break;
    

  13.                 case 7:Del(x,y,7);Draw(x,y,6);what=6;break;
    

  14.                 
    

  15.                 case 8:Del(x,y,8);Draw(x,y,9);what=9;break;
    

  16.                 case 9:Del(x,y,9);Draw(x,y,10);what=10;break;
    

  17.                 case 10:Del(x,y,10);Draw(x,y,11);what=11;break;
    

  18.                 case 11:Del(x,y,11);Draw(x,y,8);what=8;break;
    

  19.                 
    

  20.                 case 12:Del(x,y,12);Draw(x,y,15);what=15;break;
    

  21.                 case 13:Del(x,y,13);Draw(x,y,12);what=12;break;
    

  22.                 case 14:Del(x,y,14);Draw(x,y,13);what=13;break;
    

  23.                 case 15:Del(x,y,15);Draw(x,y,14);what=14;break;
    

  24.                 
    

  25.                 case 16:Del(x,y,16);Draw(x,y,17);what=17;break;
    

  26.                 case 17:Del(x,y,17);Draw(x,y,16);what=16;break;
    

  27.                 
    

  28.                 case 18:Del(x,y,18);Draw(x,y,19);what=19;break;
    

  29.                 case 19:Del(x,y,19);Draw(x,y,18);what=18;break;
    

  30.         
    

  31.         }
    

  32. }

复制
  1. void change_zhuangtai()
    

  2. {
    

  3.         switch(what)
    

  4.         {
    

  5.                 case 1:break;
    

  6.                 case 2:Del_zhuangtai_tuxing(x,y,2);Draw_zhuangtai_tuxing(x,y,3);break;
    

  7.                 case 3:Del_zhuangtai_tuxing(x,y,3);Draw_zhuangtai_tuxing(x,y,2);break;
    

  8.                 case 4:Del_zhuangtai_tuxing(x,y,4);Draw_zhuangtai_tuxing(x,y,5);break;
    

  9.                 case 5:Del_zhuangtai_tuxing(x,y,5);Draw_zhuangtai_tuxing(x,y,7);break;
    

  10.                 case 6:Del_zhuangtai_tuxing(x,y,6);Draw_zhuangtai_tuxing(x,y,4);break;
    

  11.                 case 7:Del_zhuangtai_tuxing(x,y,7);Draw_zhuangtai_tuxing(x,y,6);break;
    

  12.                 case 8:Del_zhuangtai_tuxing(x,y,8);Draw_zhuangtai_tuxing(x,y,9);break;
    

  13.                 case 9:Del_zhuangtai_tuxing(x,y,9);Draw_zhuangtai_tuxing(x,y,10);break;
    

  14.                 case 10:Del_zhuangtai_tuxing(x,y,10);Draw_zhuangtai_tuxing(x,y,11);break;
    

  15.                 case 11:Del_zhuangtai_tuxing(x,y,11);Draw_zhuangtai_tuxing(x,y,8);break;
    

  16.                 case 12:Del_zhuangtai_tuxing(x,y,12);Draw_zhuangtai_tuxing(x,y,15);break;
    

  17.                 case 13:Del_zhuangtai_tuxing(x,y,13);Draw_zhuangtai_tuxing(x,y,12);break;
    

  18.                 case 14:Del_zhuangtai_tuxing(x,y,14);Draw_zhuangtai_tuxing(x,y,13);break;
    

  19.                 case 15:Del_zhuangtai_tuxing(x,y,15);Draw_zhuangtai_tuxing(x,y,14);break;
    

  20.                 case 16:Del_zhuangtai_tuxing(x,y,16);Draw_zhuangtai_tuxing(x,y,17);break;
    

  21.                 case 17:Del_zhuangtai_tuxing(x,y,17);Draw_zhuangtai_tuxing(x,y,16);break;
    

  22.                 case 18:Del_zhuangtai_tuxing(x,y,18);Draw_zhuangtai_tuxing(x,y,19);break;
    

  23.                 case 19:Del_zhuangtai_tuxing(x,y,19);Draw_zhuangtai_tuxing(x,y,18);break;
    

  24.         
    

  25.         }
    

  26. }
    

  27.        
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:10 | 显示全部楼层
随机数的生成
复制
  1. what=rand()%19+1;//what代表着不同俄罗斯方块
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:10 | 显示全部楼层
方向控制
方块可进行左、右、下的移动，因此我们需要在接到指令后再对应坐标画出完整的俄罗斯方块并将原坐标处的图形消除，只需调用之前定义的图形调用/删除函数即可。值得注意的是，在移动图像的同时，我们也需要对状态数组中的数据进行相应的移动，为此我们需要一些整合后的函数如Down(),Left(),Right(),Del().

复制
  1. void Down(uint16 x,uint16 y,uint8 what)//调用方向移动函数
    

  2. {
    

  3.         Down_zhuangtai_move(x,y,what);
    

  4.         Down_tuxing_move(x,y,what);                        
    

  5. }```
    


  6. 

  7. ```c
    

  8. void Left(uint16 x,uint16 y,uint8 what)
    

  9. {
    

  10.         Left_zhuangtai_move(x,y,what);
    

  11.         Left_tuxing_move(x,y,what);                        
    

  12. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:10 | 显示全部楼层
2
复制
  1. void Right(uint16 x,uint16 y,uint8 what)
    

  2. {
    

  3.         Right_zhuangtai_move(x,y,what);
    

  4.         Right_tuxing_move(x,y,what);                        
    

  5. }
    


  6.
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:11 | 显示全部楼层
3

复制
  1. void Del(uint16 x,uint16 y,uint8 what)
    

  2. {
    

  3.         Del_tuxing(x,y,what);
    

  4.         Del_zhuangtai_tuxing(x,y,what);                        
    

  5. }
回复

收藏 举报

 楼主| 米多0036 发表于 2023-2-23 16:11 | 显示全部楼层
配合KEY_Scan()就可以实现方向判断。
复制
  1. #define KEY_UP 1
    

  2. #define KEY_DOWN 2
    

  3. #define KEY_LEFT 3
    

  4. #define KEY_RIGHT 4  
    

  5. #define KEY_MID 5  
    

  6. u8 Key_Scan(void)
    

  7. {
    


  8. 

  9.         
    

  10.         if(key_up&&(KB1||KB2||KB3||KB4||KB5))
    

  11.         {
    


  12. 

  13.                 systick_delay_ms(10);//去抖动// 
    

  14.                 key_up=0;
    

  15.                 if     (KB1)        
    

  16.                         return KEY_UP;
    

  17.                 else if(KB2)
    

  18.                         return KEY_DOWN;
    

  19.                 else if(KB3)
    

  20.                         return KEY_LEFT;
    

  21.                 else if(KB4)
    

  22.                         return KEY_RIGHT;
    

  23.                 else if(KB5)
    

  24.                         return KEY_MID;
    

  25.         }
    

  26.         else if(!KB1&&!KB2&&!KB3&&!KB4&&!KB5)
    

  27.         {
    

  28.                 key_up=1;
    

  29.         }
    

  30.          return 0;// 无按键按下        
    

  31. }
    


  32. 

  33.                
回复

收藏 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

米多0036

138

主题

1431

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部