设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 基于stm32的12864俄罗斯方块程序
返回列表 发新帖
查看: 3489|回复: 2
打印 上一主题 下一主题
收起左侧

基于stm32的12864俄罗斯方块程序

[复制链接]
跳转到指定楼层
楼主
ID:281024 发表于 2018-11-29 21:08 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
基础功能已经实现

单片机源程序如下:
  1. #include "Game.h"
  2. #include "LCD12864.h"
  3. #include "delay.h"

  5. u8 Key_value=0;   //按键值
  6. u32 random_value=1;   //随机数产生填充值

  8. u8 Score=0; //分数寄存变量  每消除一格 便分数加1
  9. u8 Level=1; //等级寄存器

  11. u8 SysFlag=0; //系统标志；
  12. u8 DelayCnt=5; //时间变量
  13. #define NEWSIGNFLAG 0  //产生新得积木标志
  14. #define DEADFLAG 1 //全局标志
  15. #define PAUSEFLAG 2 //暂停标志
  16. #define PASSSCORE 20 //完成当前局 就是20行  得分为20  等级加1

  18. //按键定义
  19. #define RESEVER 1  //复位
  20. #define CHANGE 2   //换方向
  21. #define DOWN 3    //向下
  22. #define LEFT 4    //向左
  23. #define RIGHT 5   //向右
  24. #define PAUSE 6    //暂停 开始


  27. //定义共21行，其中num[0]为下墙壁行，num[20]为上墙壁行,每行12格，最左一格为左墙壁列，最右一格为右墙壁列
  28. u16  num[19+2]={
  29. 0xfff,//第1行，最下面
  30. 0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,
  31. 0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,//第2行到第20行共19行
  32. 0xfff//第21行，最上面
  33. };



  37. //二维数组 用来存放积木块；
  38. u8 Block[28][2]={
  39. /*
  40. *   口     口口口   口口
  41. *   口     口         口      口
  42. *   口口              口  口口口      
  43. */
  44. {0x88,0xc0},{0xe8,0x00},{0x62,0x20},{0x02,0xe0},
  45. /*
  46. *   口        口口 口口口
  47. *   口 口     口       口
  48. * 口口 口口口 口   
  49. */
  50. {0x22,0x60},{0x08,0xe0},{0xc8,0x80},{0xe2,0x00},  
  51. /*
  52. *   口
  53. *   口口         口口
  54. *     口       口口
  55. */
  56. {0x8c,0x40},{0x6c,0x00},{0x8c,0x40},{0x6c,0x00},
  57. /*
  58. *   口        口口
  59. * 口口          口口
  60. * 口
  61. */
  62. {0x4c,0x80},{0xc6,0x00},{0x4c,0x80},{0xc6,0x00},  
  63. /*
  64. *          口                口
  65. *   口     口口   口口口   口口
  66. * 口口口   口       口       口
  67. */
  68. {0x04,0xe0},{0x8c,0x80},{0xe4,0x00},{0x26,0x20},
  69. /*口
  70. * 口
  71. * 口       口口口口
  72. * 口
  73. */
  74. {0x44,0x44},{0x0f,0x00},{0x44,0x44},{0x0f,0x00},  
  75. /*
  76. * 口口
  77. * 口口
  78. */  
  79. {0x06,0x60},{0x06,0x60},{0x06,0x60},{0x06,0x60}
  80. };

  82. //积木结构体
  83. struct Jimu
  84. {
  85.         u16 dat;
  86.         char x;
  87.         u8 y;
  88.         u8 type;
  89.         u8 change;
  90. }Sign[3];




  95. //随机数生成  这里用来随机生成积木块；
  96. static u32 Seed = 1;
  97. #define A 48271L
  98. #define M 2147483647L
  99. #define Q (M / A)
  100. #define R (M % A)
  101. /************************************
  102. 伪随机数发生器
  103. *************************************/
  104. double Random(void)
  105. {
  106.         long TmpSeed;
  107.         TmpSeed=A*(Seed%Q)-R*(Seed/Q);
  108.         if(TmpSeed>=0)
  109.                 Seed=TmpSeed;
  110.         else
  111.                 Seed=TmpSeed+M;
  112.         return (double)Seed/M;
  113. }

  115. /**************************************
  116. 为伪随机数发生器播种
  117. ***************************************/
  118. void InitRandom(u32 InitVal)
  119. {
  120.         Seed=InitVal;
  121. }





  127. void DrawBoard(void)                   //画墙壁，就是指在屏幕上画一个框框和初始化界面显示文字
  128. {
  129.         unsigned char n;
  130.         for(n=0;n<12;n++)
  131.         {
  132.                 LCD12864_Rectangle(3*n,0,3*n+2,2,1);
  133.                 LCD12864_Rectangle(3*n,60,3*n+2,62,1);
  134.         }
  135.         for(n=0;n<20;n++)
  136.         {
  137.                 LCD12864_Rectangle(0,3*n,2,3*n+2,1);
  138.                 LCD12864_Rectangle(33,3*n,35,3*n+2,1);               
  139.         }
  140.         LCD12864_String(3,0,"   ");
  141.         LCD12864_String(3,1,"设计：吕钰");
  142.         LCD12864_String(3,2,"得分:0");
  143.         LCD12864_String(3,3,"等级:0");       
  144. }



  148. //根据积木图标左下坐标X，Y来画出积木图标
  149. u16 MaskTab[16]={
  150. 0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
  151. 0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000
  152. };
  153. void DrawSign(struct Jimu Temp,unsigned char DrawMode)
  154. {
  155.         unsigned char m,n;
  156.         for(m=0;m<4;m++)
  157.                 for(n=0;n<4;n++)
  158.                 {
  159.                         if((Temp.dat&MaskTab[4*m+n])!=0)
  160.                         LCD12864_Rectangle(Temp.x+n*3,Temp.y-2-3*m,Temp.x+n*3+2,Temp.y-3*m,DrawMode);
  161.                 }
  162. }

  164. //随机产生一个积木图标放到预产生区域并显示出来
  165. void CreatSign(void)                 
  166. {
  167.         u8 n;
  168.         u16 Temp;

  170.         DrawSign(Sign[2],0);//先清除

  172.         n=Random()*28;
  173.         Temp=(u16)Block[n][0]<<8;
  174.         Temp=Temp|Block[n][1];
  175.         Sign[2].dat=Temp;
  176.         Sign[2].x=45;
  177.         Sign[2].y=4*3+2;
  178.         Sign[2].type=n/4;
  179.         Sign[2].change=n%4;
  180.         DrawSign(Sign[2],1);//后画出
  181. }

  183. void FixSign(void)         //将积木图标值融入num数据中        也即把积木图标固定，无法再下降
  184. {
  185.         unsigned char m,n;
  186.         for(m=0;m<4;m++)//行循环
  187.                 for(n=0;n<4;n++)//列循环
  188.                 {
  189.                         if((Sign[0].dat&MaskTab[4*m+n])!=0)
  190.                         {
  191.                                 num[20-(Sign[0].y-2)/3+m]|=MaskTab[11-Sign[0].x/3-n];
  192.                         }
  193.                 }
  194. }

  196. u8 CheckIf(void)                  //判断积木图标中方块是否与障碍方块重合
  197. {
  198.         unsigned char m,n;
  199.         for(m=0;m<4;m++)//行循环
  200.                 for(n=0;n<4;n++)//列循环
  201.                 {
  202.                         if((Sign[1].dat&MaskTab[4*m+n])!=0)
  203.                         {
  204.                                 if((num[20-(Sign[1].y-2)/3+m]&MaskTab[11-Sign[1].x/3-n])!=0)
  205.                                         return 0;
  206.                         }
  207.                 }
  208.         return 1;
  209. }

  211. u8 CheckIfDown(void)                        //判断积木图标是否可以继续下降一格
  212. {
  213.         Sign[1]=Sign[0];//
  214.         Sign[1].y+=3;//假设下降一格       
  215.         return CheckIf();
  216.        
  217. }

  219. u8 CheckIfLeft(void)                        //判断积木图标是否可以向左移动
  220. {
  221.         Sign[1]=Sign[0];
  222.         Sign[1].x-=3;//假设左移一格       
  223.         return CheckIf(); //返回检测重合函数
  224. }

  226. u8 CheckIfRight(void)         //判断积木图标是否可以向右移动
  227. {
  228.         Sign[1]=Sign[0];
  229.         Sign[1].x+=3;//假设右移一格       
  230.         return CheckIf();
  231. }
  232. u8 CheckIfRoll(void)                //判断是否可以旋转
  233. {
  234.         unsigned char i;
  235.         unsigned int Temp;
  236.         Sign[1]=Sign[0];
  237.         if(++Sign[1].change>3)
  238.                 Sign[1].change=0;
  239.            i=Sign[1].type*4+Sign[1].change;
  240.         Temp=(unsigned int)Block[i][0]<<8;
  241.         Temp=Temp|Block[i][1];
  242.         Sign[1].dat=Temp;
  243.        
  244.         return CheckIf();
  245. }

  247. void DelFull(void)                                //寻找满格的行并做消除处理，最多寻找4个满行并做消除
  248. {
  249.         u8 m,n;
  250.         u8 Temp;
  251.         u8 Flag=0;
  252.         Temp=(Sign[0].y-2)/3;
  253.         if(Temp>=20)//防止越过了下边界
  254.                 Temp=1;
  255.         else
  256.                 Temp=20-Temp;
  257.         for(n=Temp+3;n>=Temp;n--)//积木图标的最顶行开始寻找满行比较有利于运算
  258.         {
  259.                 if(num[n]==0xfff)
  260.                 {
  261.                         Flag=1;
  262.                         for(m=n+1;m<=19;m++)
  263.                         {
  264.                                 num[m-1]=num[m];
  265.                         }
  266.                         num[m]=0x801;
  267.                         Score++;//每找到一个满行，则分数加1
  268.                 }
  269.         }
  270.         if(Flag)//为加速而设置并判断的标志，有已固定的积木有满格消行变化则重画积木界面
  271.         {
  272.                 for(m=Temp;m<=19;m++)//为加速，不必要重第一行重画起，只需要从积木图标最下行开始往上的重画
  273.                         for(n=1;n<=10;n++)
  274.                         {
  275.                                 if((num[m]&MaskTab[n])==0)
  276.                                 {       
  277.                                         if(LCD12864_Readpoint(30-(n-1)*3,57-(m-1)*3)!=0)//为加速而做的读象素操作
  278.                                         {
  279.                                                 LCD12864_Rectangle(30-(n-1)*3,57-(m-1)*3,30-(n-1)*3+2,57-(m-1)*3+2,0);
  280.                                         }
  281.                                 }
  282.                                    else
  283.                                 {
  284.                                         if(LCD12864_Readpoint(30-(n-1)*3,57-(m-1)*3)==0)//为加速而做的读象素操作
  285.                                         {
  286.                                                 LCD12864_Rectangle(30-(n-1)*3,57-(m-1)*3,30-(n-1)*3+2,57-(m-1)*3+2,1);
  287.                                         }
  288.                                 }
  289.                         }
  290.         }
  291. }

  293. void PrintScore(void)                        //分数显示输出
  294. {
  295.         unsigned char Str[3]; //定义了一个局部数组
  296.         Str[0]=(Score/10)|0x30; //分数得十位
  297.         Str[1]=(Score%10)|0x30; //分数得个位
  298.         Str[2]=0;
  299.         LCD12864_String(6,2,Str); //在指定位置输出分数
  300. }

  302. void PrintLevel(void)                        //等级显示输出
  303. {
  304.         unsigned char Str[3]; //定义了一个局部数组
  305.         Str[0]=(Level/10)|0x30;
  306.         Str[1]=(Level%10)|0x30;
  307.         Str[2]=0;
  308.         LCD12864_String(6,3,Str);
  309. }

  311. void GamePlay(void)                                //玩游戏流程
  312. {
  313.         unsigned char m,n;
  314.         unsigned int Temp;
  315.         SysFlag|=1<<NEWSIGNFLAG;//刚开始初始化为需要产生新的积木图标
  316.         InitRandom(random_value);                //伪随机数发生器播种
  317.         LCD12864_String(3,1,"           ");
  318.         LCD12864_String(3,1,"开始");
  319.         PrintScore();
  320.         PrintLevel();
  321.         CreatSign();                        //随机显示一个方块到预览区
  322.         while(1)
  323.         {       
  324.                 if((SysFlag&(1<<NEWSIGNFLAG))==1)//判是否需要产生新的积木图标
  325.                 {
  326.                         SysFlag&=~(1<<NEWSIGNFLAG);
  327.                         Sign[0]=Sign[2];
  328.                         CreatSign();
  329.                         Sign[0].x=12;
  330.                         Sign[0].y=14;

  332.                         for(m=0;m<4;m++)//行循环
  333.                         {
  334.                                 for(n=0;n<4;n++)//列循环
  335.                                 {
  336.                                         if((Sign[0].dat&MaskTab[15-m*4-n])==0)
  337.                                                 break;
  338.                                 }
  339.                                 if(n==4)
  340.                                         Sign[0].y-=3;
  341.                         }//将积木图标出现置顶
  342.                        
  343.                         for(m=0;m<4;m++)//行循环
  344.                                 for(n=0;n<4;n++)//列循环
  345.                                 {
  346.                                         if((Sign[0].dat&MaskTab[4*m+n])!=0)
  347.                                         {
  348.                                                 if((num[20-(Sign[0].y-2)/3+m]&MaskTab[11-Sign[0].x/3-n])!=0)
  349.                                                         SysFlag|=1<<DEADFLAG;
  350.                                         }
  351.                                 }
  352.                         if((SysFlag&(1<<DEADFLAG))!=0)
  353.                                 break;//如果产生新的积木图标中的方块与已固定好的方块重合，则死亡。游戏结束
  354.                         DrawSign(Sign[0],1);       
  355.                 }
  356.                 switch(Key_value)
  357.                 {
  358.                         case LEFT:
  359.                                         Key_value=0;
  360.                                         if((SysFlag&(1<<PAUSEFLAG))==0)
  361.                                         {
  362.                                                 if(CheckIfLeft())
  363.                                                 {
  364.                                                         DrawSign(Sign[0],0);
  365.                                                         Sign[0].x-=3;
  366.                                                         DrawSign(Sign[0],1);
  367.                                                 }
  368.                                         }
  369.                                         else
  370.                                         {
  371.                                                 if(++Level>=4)
  372.                                                         Level=1;
  373.                                                 PrintLevel();
  374.                                         }
  375.                                         break;
  376.                         case RIGHT:
  377.                                         Key_value=0;
  378.                                         if((SysFlag&(1<<PAUSEFLAG))==0)
  379.                                         {
  380.                                                 if(CheckIfRight())
  381.                                                 {
  382.                                                         DrawSign(Sign[0],0);
  383.                                                         Sign[0].x+=3;
  384.                                                         DrawSign(Sign[0],1);       
  385.                                                 }
  386.                                         }
  387.                                         else
  388.                                         {
  389.                                                 if(++Level>=4)
  390.                                                         Level=1;
  391.                                                 PrintLevel();
  392.                                         }
  393.                                         break;
  394.                         case DOWN:
  395.                                         Key_value=0;
  396.                                         if((SysFlag&(1<<PAUSEFLAG))==0)
  397.                                         {
  398.                                                 if(CheckIfDown())//判断是否能继续下降一格
  399.                                                 {
  400.                                                         DrawSign(Sign[0],0);
  401.                                                         Sign[0].y+=3;
  402.                                                         DrawSign(Sign[0],1);       
  403.                                                 }
  404.                                         }
  405.                                         break;
  406.                         case CHANGE:
  407.                                         Key_value=0;
  408.                                         if((SysFlag&(1<<PAUSEFLAG))==0)
  409.                                         {
  410.                                                 if(CheckIfRoll())
  411.                                                 {
  412.                                                         DrawSign(Sign[0],0);
  413.                                                         if(++Sign[0].change>3)
  414.                                                                 Sign[0].change=0;
  415.                                                            m=Sign[0].type*4+Sign[0].change;
  416.                                                         Temp=(unsigned int)Block[m][0]<<8;
  417.                                                         Temp=Temp|Block[m][1];
  418.                                                         Sign[0].dat=Temp;
  419.                                                         DrawSign(Sign[0],1);
  420.                                                 }
  421.                                         }
  422.                                         break;
  423.                            case PAUSE:
  424.                                         Key_value=0;
  425.                                         SysFlag^=1<<PAUSEFLAG;
  426.                                         if((SysFlag&(1<<PAUSEFLAG))==0)
  427.                                         {
  428.                                                 LCD12864_String(3,1,"          "); //在显示“开始”之前将改区域得显示清除
  429.                                                 LCD12864_String(3,1,"开始");
  430.                                         }
  431.                                         else
  432.                                         {
  433.                                                 LCD12864_String(3,1,"          ");//在显示“暂停”之前将改区域得显示清除
  434.                                                 LCD12864_String(3,1,"暂停");       
  435.                                         }
  436.                                         break;
  437.                     default:
  438.                                         break;
  439.                 }
  440.                 if((SysFlag&(1<<PAUSEFLAG))!=0)
  441.                         continue;
  442.                 delay_ms(50);
  443.                 if(++DelayCnt>=2*(11-Level))
  444.                 {
  445.                         DelayCnt=0;
  446.                         if(CheckIfDown())//判断是否能继续下降一格
  447.                         {
  448.                                 DrawSign(Sign[0],0);
  449.                                 Sign[0].y+=3;
  450.                                 DrawSign(Sign[0],1);
  451.                         }
  452.                         else
  453.                         {
  454.                                 FixSign();
  455.                                 DelFull();
  456.                                 PrintScore();
  457.                                 if(Score>=PASSSCORE)
  458.                                 {
  459.                                         SysFlag&=~(1<<DEADFLAG);
  460.                                         break;//跳出玩游戏过程
  461.                                 }
  462.                                 SysFlag|=1<<NEWSIGNFLAG;//新的积木图标产生标志置1
  463.                         }
  464.                 }
  465.         }
  466. }

  468. void GameOver(void)                                        //游戏结束处理
  469. {
  470.         if((SysFlag&(1<<DEADFLAG))!=0)
  471.           {       
  472.                         LCD12864_Init(); //初始化LCD屏
  473.                   LCD12864_String(1,2,"失败");
  474.        
  475.           }
  476.         else
  477.                 {       
  478.                         LCD12864_Init(); //初始化LCD屏
  479.                         LCD12864_String(1,2,"恭喜");
  480.        
  481.                  }
  482. }
复制代码

所有资料51hei提供下载:
俄罗斯方块.rar (310.57 KB, 下载次数: 68)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:1 发表于 2018-12-1 02:04 | 只看该作者
补全原理图或者详细说明一下电路连接即可获得100+黑币
回复

使用道具 举报

板凳
ID:339366 发表于 2018-12-7 13:33 | 只看该作者
这个用kill怎么看 没学过stm32 不怎么会用
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表