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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机+LCD12864俄罗斯方块游戏程序+PCB+Proteus仿真
返回列表 发新帖
查看: 7703|回复: 15
收起左侧

51单片机+LCD12864俄罗斯方块游戏程序+PCB+Proteus仿真

  [复制链接]
ID:577864 发表于 2019-7-4 16:43 | 显示全部楼层 |阅读模式
Altium Designer画的基于51单片机的俄罗斯方块电路原理图和PCB图如下：(51hei附件中可下载工程文件)
0.png 0.png 0.png

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
0.png 0.png 0.png

                                               俄罗斯方块元件清单        
元件编号    参数    数量
R11    10K电阻    1
C2    10uF电解电容    1
Y1    12M晶振    1
C1, C3    30pf瓷片电容    2
VR1    103滑动变阻器    1
P4    4针插针    1
LCD1    LCD12864液晶    1
U1    STC89C51单片机    1
K1, K2, K3, K4, K5, K6    大按键    6
K7    小轻触按键    1
J1    电源接口    1
SW1    自锁开关    1

单片机源程序如下:
  1. #include <REGX52.H>
  2. #include"pic.c"
  3. #include <intrins.h>
  4. #define LCD_DATA P2
  5. #define button_delay 150  //按键延时
  6. #define button_acceleration 65  //按键加速度阈值
  7. #define GAME_LOCATION 30
  8. sbit button_a = P3^4;         //变形
  9. sbit button_b = P3^5;        //开始
  10. sbit up = P3^2;           //暂停开始
  11. sbit down = P3^0;
  12. sbit left = P3^1;
  13. sbit right = P3^3;
  14. sbit speaker=P3^6;

  16. sbit LCD_RS=P1^0;
  17. sbit LCD_RW=P1^1;
  18. sbit LCD_E=P1^2;
  19. sbit LCD_CS2=P1^4;                //右屏选择（左右屏有时候相反）
  20. sbit LCD_CS1=P1^3;                //左屏选择
  21. sbit LCD_RST=P3^7;

  23. unsigned int up_reg=button_delay;       //按键up累加器
  24. unsigned int down_reg=button_delay;     //按键down累加器
  25. unsigned int left_reg=button_delay;     //按键left累加器
  26. unsigned int right_reg=button_delay;    //按键right累加器
  27. unsigned int button_a_reg=button_delay; //按键button_a累加器
  28. unsigned int button_b_reg=button_delay; //按键button_b累加器
  29. unsigned int right_acceleration=0;                //按键right加速度寄存器
  30. unsigned int left_acceleration=0;                //按键left加速度寄存器

  32. unsigned int idata Box_Ram[19];//定义游戏点阵缓存10*16
  33. unsigned char box_down_reg;//定义方块下落累加寄存器
  34. unsigned char time0_reg;//定义定时器0累加寄存器
  35. unsigned char next_mode;//定义下一个方块的类型
  36. unsigned char next_shape;//定义下一个方块的形状
  37. unsigned int destroy_row_num=0;//定义所消的行数
  38. unsigned char speed_num=0;//定义游戏速度等级
  39. unsigned char level_num;//定义游戏难度等级
  40. bit game_over_flag;//游戏结束标志位置0表示游戏未结束
  41. bit pause_game_flag;//游戏暂停标志位置0表示游戏未暂停

  43. struct
  44. {
  45.         unsigned char mode;//类型
  46.         unsigned char shape;//形状
  47.         unsigned char x;//x坐标
  48.         unsigned char y;//y坐标
  49.         unsigned int box;//定义方块缓存
  50. }s_box;        //定义方块结构体
  51. //LCD检测忙状态函数
  52. void LCD_check_busy()
  53. {
  54.         unsigned char temp;
  55.         LCD_RS=0;
  56.         LCD_RW=1;
  57.         do
  58.         {
  59.                 LCD_DATA=0xff;
  60.                 LCD_E=1;
  61.                 temp=LCD_DATA;
  62.                 LCD_E=0;
  63.         }while((temp&0x80)==0x80);               
  64. }
  65. //写指令代码（cs为0选左屏，cs为1选右屏）
  66. void LCD_W_code(unsigned char tpcode,bit cs)
  67. {
  68.         LCD_RS=0;
  69.         LCD_RW=0;
  70.         LCD_CS2=~cs;
  71.         LCD_CS1=cs;
  72.         LCD_DATA=tpcode;
  73.         LCD_E=1;
  74.         _nop_();
  75.         LCD_E=0;
  76. }
  77. //写显示数据（cs为0选左屏，cs为1选右屏）
  78. void LCD_W_data(unsigned char tpdata,bit cs)
  79. {
  80.         LCD_check_busy();
  81.         LCD_RS=1;
  82.         LCD_RW=0;
  83.         LCD_CS2=~cs;
  84.         LCD_CS1=cs;       
  85.         LCD_DATA=tpdata;
  86.         LCD_E=1;       
  87.         _nop_();
  88.         LCD_E=0;
  89. }

  91. //LCD初始化函数
  92. void LCD_initialize()
  93. {
  94.         LCD_RST=0;
  95.         _nop_();
  96.         _nop_();
  97.         LCD_RST=1;
  98.         LCD_W_code(0x3f,0);                //开显示设置       
  99.         LCD_W_code(0xc0,0);                //设置显示起始行为第一行       
  100.         LCD_W_code(0xb8,0);                //页面地址设置       
  101.         LCD_W_code(0x40,0);                //列地址设为0
  102.         LCD_W_code(0x3f,1);
  103.         LCD_W_code(0xc0,1);       
  104.         LCD_W_code(0xb8,1);
  105.         LCD_W_code(0x40,1);
  106. }
  107. //LCD清屏函数
  108. void LCD_clear()
  109. {
  110.         unsigned char i,j;
  111.         for(j=0;j<8;j++)
  112.         {
  113.                 LCD_W_code(0xb8+j,0);
  114.                 LCD_W_code(0x40,0);
  115.                 LCD_W_code(0xb8+j,1);
  116.                 LCD_W_code(0x40,1);
  117.                 for(i=0;i<64;i++)
  118.                         {       
  119.                                 LCD_W_data(0x00,0);       
  120.                                 LCD_W_data(0x00,1);
  121.                         }
  122.         }
  123. }
  124. //LCD显示字符串函数（word表示要显示的字符串,
  125. //length表示要显示的字符串宽度,
  126. //x表示首字符所在行数,
  127. //y表示首字符所在列数）
  128. void LCD_display_word(unsigned char word[],
  129.                       unsigned int length,
  130.                                           unsigned char x,
  131.                                           unsigned char y)
  132. {
  133.         unsigned char i;
  134.         for(i=0;i<length;i++)
  135.         {
  136.                
  137.                 LCD_W_code(0xb8+x,0);
  138.                 LCD_W_code(0xb8+x,1);
  139.                 if(y+i<64)
  140.                 {
  141.                         LCD_W_code(0x40+y+i,0);       
  142.                         LCD_W_data(word[i],0);
  143.                 }
  144.                 else
  145.                 {
  146.                         LCD_W_code(y+i,1);       
  147.                         LCD_W_data(word[i],1);
  148.                 }
  149.         }
  150. }
  151. //LCD画全屏函数
  152. void LCD_full_draw(unsigned char word[])
  153. {
  154.         unsigned char i,j;
  155.         for(i=0;i<8;i++)
  156.         {
  157.                 LCD_W_code(0xb8+i,0);
  158.                 LCD_W_code(0x40,0);       
  159.                 for(j=0;j<64;j++)
  160.                 {
  161.                         LCD_W_data(word[i*128+j],0);
  162.                 }
  163.                 LCD_W_code(0xb8+i,1);
  164.                 LCD_W_code(0x40,1);       
  165.                 for(j=0;j<64;j++)
  166.                 {
  167.                         LCD_W_data(word[i*128+64+j],1);
  168.                 }                       
  169.         }
  170. }
  171. //LCD显示一个字节函数（
  172.   //x表示x坐标,
  173.   //y表示y坐标,
  174.   //tpdata表示要显示的数据）
  175. void LCD_display_byte(unsigned char x,
  176.                                           unsigned char y,
  177.                                           unsigned char tpdata)
  178. {
  179.         if(x<64)
  180.         {
  181.                 LCD_W_code(0xb8+y,0);
  182.                 LCD_W_code(0x40+x,0);
  183.                 LCD_W_data(tpdata,0);       
  184.         }
  185.         else
  186.         {
  187.                 LCD_W_code(0xb8+y,1);
  188.                 LCD_W_code(x,1);
  189.                 LCD_W_data(tpdata,1);       
  190.         }
  191. }

  193. void LCD_draw(unsigned char word[])
  194. {
  195.   unsigned char i,j;
  196.   for(i=0;i<8;i++)
  197.   {
  198.     LCD_W_code(0xb8+i,1);
  199.         LCD_W_code(0x40+20,1);
  200.         for(j=0;j<44;j++)
  201.         {
  202.           LCD_W_data(word[i*44+j],1);
  203.         }
  204.   }
  205. }
  206. //基本界面显示函数
  207. void display_basic()
  208. {
  209.         unsigned char i;
  210.         for(i=0;i<8;i++)
  211.         {
  212.                 LCD_display_byte(GAME_LOCATION,i,0xff);
  213.                 LCD_display_byte(GAME_LOCATION+41,i,0xff);
  214.         }
  215. }
  216. //刷新游戏区域函数
  217. void refurbish_display()
  218. {
  219.         unsigned char i,j,tpdata;
  220.         for(i=0;i<8;i++)
  221.         {
  222.                 for(j=0;j<10;j++)
  223.                 {
  224.                         tpdata=0x00;
  225.                         if(  (Box_Ram[2*i]>>(12-j))&0x0001==1  )
  226.                         {
  227.                                 tpdata=0x0f;
  228.                         }
  229.                         if(  (Box_Ram[2*i+1]>>(12-j))&0x0001==1  )
  230.                         {
  231.                                 tpdata|=0xf0;
  232.                         }
  233.                         LCD_display_byte(GAME_LOCATION+1+j*4,i,tpdata);
  234.                         LCD_display_byte(GAME_LOCATION+2+j*4,i,0xbb&tpdata);
  235.                         LCD_display_byte(GAME_LOCATION+3+j*4,i,0xdd&tpdata);
  236.                         LCD_display_byte(GAME_LOCATION+4+j*4,i,tpdata);
  237.                 }
  238.         }
  239. }
  240. //基本按键程序(返回0表示没按键被按下，返回1表示down被按下，返回2表示up被按下，返回3表示button_a被按下,返回4表示left被按下,返回5表示right被按下)
  241. //游戏中按键识别程序（有优先级，从高到低依次是button_a_reg>down>left>right>up）
  242. unsigned char basic_button()
  243. {
  244.         unsigned char tpflag=0;
  245.         if(button_b==0)
  246.         {
  247.             if(button_b_reg<button_delay*8)
  248.                 {
  249.                   button_b_reg++;
  250.                 }
  251.                 else
  252.                 {
  253.                   button_b_reg=0;
  254.                   tpflag=6;
  255.                 }
  256.         }
  257.         else
  258.         {
  259.                 button_b_reg=button_delay*8;
  260.         }
  261.         if(down==0)
  262.         {
  263.                 if(down_reg<button_delay)//按键一直被按下时设置时间间隔触发
  264.                 {
  265.                         down_reg++;
  266.                 }
  267.                 else
  268.                 {
  269.                         down_reg=0;
  270.                         tpflag=1;//返回1表示down被按下
  271.                 }               
  272.         }
  273.         else
  274.         {
  275.                 down_reg=button_delay;//释放按键时置按键缓存为button_delay，以便在下次按键时及时响应
  276.         }
  277.         if(up==0)
  278.         {
  279.                 if(up_reg<button_delay)//按键一直被按下时设置时间间隔触发
  280.                 {
  281.                         up_reg++;
  282.                 }
  283.                 else
  284.                 {
  285.                         up_reg=0;
  286.                         tpflag=2;//返回2表示up被按下
  287.                 }               
  288.         }
  289.         else
  290.         {
  291.                 up_reg=button_delay;//释放按键时置按键缓存为button_delay，以便在下次按键时及时响应
  292.         }
  293.         if(button_a==0)
  294.         {
  295.                 if(button_a_reg<button_delay*8)//按键一直被按下时设置时间间隔触发
  296.                 {
  297.                         button_a_reg++;
  298.                 }
  299.                 else
  300.                 {
  301.                         button_a_reg=0;
  302.                         tpflag=3;//返回3表示button_a被按下
  303.                 }               
  304.         }
  305.         else
  306.         {
  307.                 button_a_reg=button_delay*8;//释放按键时置按键缓存为button_delay，以便在下次按键时及时响应
  308.         }
  309.         if(left==0)
  310.         {
  311.                 if(left_reg<(button_delay))//按键一直被按下时设置时间间隔触发
  312.                 {
  313.                         left_reg++;
  314.                 }
  315.                 else
  316.                 {
  317.                         left_reg=left_acceleration*button_acceleration;
  318.                         if(left_acceleration<2)left_acceleration++;
  319.                         tpflag=4;//返回4表示left被按下
  320.                 }               
  321.         }
  322.         else
  323.         {
  324.                 left_acceleration=0;
  325.                 left_reg=button_delay;//释放按键时置按键缓存为button_delay，以便在下次按键时及时响应
  326.         }
  327.         if(right==0)
  328.         {
  329.                 if(right_reg<(button_delay))//按键一直被按下时设置时间间隔触发
  330.                 {
  331.                         right_reg++;
  332.                 }
  333.                 else
  334.                 {
  335.                         right_reg=right_acceleration*button_acceleration;
  336.                         if(right_acceleration<2)right_acceleration++;
  337.                         tpflag=5;//返回5表示right被按下
  338.                 }               
  339.         }
  340.         else
  341.         {
  342.                 right_acceleration=0;
  343.                 right_reg=button_delay;//释放按键时置按键缓存为button_delay，以便在下次按键时及时响应
  344.         }
  345.         return(tpflag);
  346. }
  347. //检查覆盖函数（检查此时带入的参数所确定的方块是否会覆盖原有图形，不会覆盖返回1，覆盖返回0）
  348. bit check_cover(unsigned char tpx,unsigned char tpy,unsigned int tpbox)
  349. {
  350.         unsigned char i;
  351.         bit tpflag=1;
  352.         unsigned int temp;
  353.         temp=s_box.box;
  354.         for(i=0;i<4;i++)
  355.         {
  356.                 Box_Ram[3-i+s_box.y]&=(~((temp&0x000f)<<(9-s_box.x)));
  357.                 temp=temp>>4;
  358.         }//先将现有的方块从游戏点阵缓存中删除
  359.         temp=tpbox;
  360.         for(i=0;i<4;i++)
  361.         {
  362.                 if((((temp&0x000f)<<(9-tpx))&Box_Ram[3-i+tpy])!=0x0000)
  363.                 {
  364.                         tpflag=0;
  365.                 }
  366.                 temp=temp>>4;
  367.         }//检查方块是否和原有图形重叠,重叠置标志位tpflag为0,不重叠不置标志位，即tpflag为1
  368.         temp=s_box.box;
  369.         for(i=0;i<4;i++)
  370.         {
  371.                 Box_Ram[3-i+s_box.y]|=((temp&0x000f)<<(9-s_box.x));
  372.                 temp=temp>>4;
  373.         }//在游戏点阵缓存中恢复原有方块
  374.         return(tpflag);
  375. }
  376. //方块缓存数据函数（输入方块类型和形状即可获得方块缓存数据）
  377. unsigned int box_read_data(unsigned char tpmode,unsigned char tpshape)
  378. {
  379.         unsigned int tpbox;
  380.         switch(tpmode)
  381.         {
  382.                 case 0: switch(tpshape)
  383.                                 {
  384.                                         case 0: tpbox=0xf000;break;
  385.                                         case 1: tpbox=0x4444;break;
  386.                                         case 2: tpbox=0xf000;break;
  387.                                         case 3: tpbox=0x4444;break;
  388.                                         default:;
  389.                                 }break;       
  390.                 case 1: switch(tpshape)
  391.                                 {
  392.                                         case 0: tpbox=0xe800;break;
  393.                                         case 1: tpbox=0xc440;break;
  394.                                         case 2: tpbox=0x2e00;break;
  395.                                         case 3: tpbox=0x88c0;break;
  396.                                         default:;
  397.                                 }break;       
  398.                 case 2: switch(tpshape)
  399.                                 {
  400.                                         case 0: tpbox=0xe200;break;
  401.                                         case 1: tpbox=0x44c0;break;
  402.                                         case 2: tpbox=0x8e00;break;
  403.                                         case 3: tpbox=0xc880;break;
  404.                                         default:;
  405.                                 }break;       
  406.                 case 3: switch(tpshape)
  407.                                 {
  408.                                         case 0: tpbox=0xcc00;break;
  409.                                         case 1: tpbox=0xcc00;break;
  410.                                         case 2: tpbox=0xcc00;break;
  411.                                         case 3: tpbox=0xcc00;break;
  412.                                         default:;
  413.                                 }break;       
  414.                 case 4: switch(tpshape)
  415.                                 {
  416.                                         case 0: tpbox=0xc600;break;
  417.                                         case 1: tpbox=0x4c80;break;
  418.                                         case 2: tpbox=0xc600;break;
  419.                                         case 3: tpbox=0x4c80;break;
  420.                                         default:;
  421.                                 }break;       
  422.                 case 5: switch(tpshape)
  423.                                 {
  424.                                         case 0: tpbox=0x6c00;break;
  425.                                         case 1: tpbox=0x8c40;break;
  426.                                         case 2: tpbox=0x6c00;break;
  427.                                         case 3: tpbox=0x8c40;break;
  428.                                         default:;
  429.                                 }break;
  430.                 case 6: switch(tpshape)
  431.                                 {
  432.                                         case 0: tpbox=0x4e00;break;
  433.                                         case 1: tpbox=0x8c80;break;
  434.                                         case 2: tpbox=0xe400;break;
  435.                                         case 3: tpbox=0x4c40;break;
  436.                                         default:;
  437.                                 }break;
  438.                 default:;
  439.         }
  440.         return(tpbox);
  441. }
  442. //方块载入函数
  443. void box_load()
  444. {
  445.         s_box.box=box_read_data(s_box.mode,s_box.shape);
  446. }
  447. //方块映射游戏点阵缓存函数（参数是原来方块的位置、缓存，先消去原有位置的方块）
  448. void box_to_Box_Ram(unsigned char tpx,unsigned char tpy,unsigned int tpbox)
  449. {
  450.         unsigned char i;
  451.         unsigned int temp;
  452.         temp=tpbox;
  453.         for(i=0;i<4;i++)
  454.         {
  455.                 Box_Ram[3-i+tpy]=Box_Ram[3-i+tpy]&(~((temp&0x000f)<<(9-tpx)));
  456.                 temp=temp>>4;
  457.         }//从游戏点阵缓存中删除以前的方块
  458.         temp=s_box.box;
  459.         for(i=0;i<4;i++)
  460.         {
  461.                 Box_Ram[3-i+s_box.y]=((temp&0x000f)<<(9-s_box.x))|Box_Ram[3-i+s_box.y];
  462.                 temp=temp>>4;
  463.         }//在游戏点阵缓存中加入新的方块
  464. }
  465. //显示数字函数（
  466.   //x表示x坐标,
  467.   //y表示y坐标,
  468.   //tpdata表示要显示的数字）
  469. //显示速度函数
  470. void show_num(unsigned char x,
  471.                                           unsigned char y,
  472.                                           unsigned char tpdata)
  473. {
  474.         unsigned char i;
  475.         for(i=0;i<4;i++)
  476.         {
  477.                 LCD_display_byte(x+i,y,num_data[tpdata*4+i]);       
  478.         }
  479. }
  480. void show_speed_num(unsigned char x,unsigned char y)
  481. {
  482.         show_num(x,y,speed_num);
  483. }
  484. //显示得分函数
  485. void show_score_num(unsigned char x,unsigned char y)
  486. {
  487.         show_num(x,y,destroy_row_num/10000);
  488.         show_num(x+=5,y,(destroy_row_num%10000)/1000);
  489.         show_num(x+=5,y,(destroy_row_num%1000)/100);
  490.         show_num(x+=5,y,(destroy_row_num%100)/10);
  491.         show_num(x+=5,y,destroy_row_num%10);
  492. }
  493. //消行函数
  494. void destroy_row()
  495. {
  496.         unsigned char i,j=0;
  497.         unsigned char tpflag[4]={0,0,0,0};//最多一次只能消四行，所以设置四个标志位即可,初值为0
  498.         for(i=0;i<16;i++)
  499.         {
  500.                 if((Box_Ram[i]&0x3ffc)==0x3ffc)
  501.                 {
  502.                         tpflag[j]=i+1;//tpflag为0表示不标志，1表示第0行缓存为0xffff，n表示第n+1行缓存为0xffff
  503.                         destroy_row_num++;//消除的行数加一
  504.                         /*如不把Box_Ram[19]定义成idata类型的话加入这段代码显示数据区就溢出了*/
  505.                         if(destroy_row_num%30==0&&speed_num!=9)
  506.                         {
  507.                                 speed_num++;//消够三十行游戏速度加一
  508.                                 show_speed_num(13,4);//调用显示游戏速度函数
  509.                         }
  510.                         /*如不把Box_Ram[19]定义成idata类型的话加入这段代码显示数据区就溢出了*/
  511.                         j++;
  512.                         if(j==4)
  513.                         {
  514.                                 break;
  515.                         }//检查完有四行要消除则退出检查循环
  516.                 }
  517.         }//依次检测是否有行缓存为0xffff，如果是则标志tpflag为此行的行号
  518.         for(j=0;j<4;j++)
  519.         {
  520.                 if(tpflag[j]!=0)
  521.                 {
  522.                         for(i=tpflag[j]-1;i>0;i--)
  523.                         {
  524.                         Box_Ram[i]=Box_Ram[i-1];
  525.                         Box_Ram[0]=0x2004;
  526.                         }
  527.                 }
  528.         }//被标志的行依次被上一行所取代，即被消去
  529.         show_score_num(3,1);
  530. }
  531. //显示下一个方块函数
  532. void show_next_box()
  533. {
  534.         unsigned char i,tpdata;
  535.         unsigned int temp;
  536.         temp=box_read_data(next_mode,next_shape);
  537.         for(i=0;i<4;i++)
  538.         {
  539.                 tpdata=0x00;
  540.                 if(  ((temp>>(15-i))&0x0001)==1  )
  541.                 {
  542.                         tpdata=0x0f;
  543.                 }
  544.                 if(  ((temp>>(11-i))&0x0001)==1  )
  545.                 {
  546.                         tpdata|=0xf0;
  547.                 }
  548.                 LCD_display_byte(7+i*4,6,tpdata);
  549.                 LCD_display_byte(8+i*4,6,0xbb&tpdata);
  550.                 LCD_display_byte(9+i*4,6,0xdd&tpdata);
  551.                 LCD_display_byte(10+i*4,6,tpdata);       
  552.                 tpdata=0x00;
  553.                 if(  ((temp>>(7-i))&0x0001)==1  )
  554.                 {
  555.                         tpdata=0x0f;
  556.                 }
  557.                 if(  ((temp>>(3-i))&0x0001)==1  )
  558.                 {
  559.                         tpdata|=0xf0;
  560.                 }
  561.                 LCD_display_byte(7+i*4,7,tpdata);
  562.                 LCD_display_byte(8+i*4,7,0xbb&tpdata);
  563.                 LCD_display_byte(9+i*4,7,0xdd&tpdata);
  564.                 LCD_display_byte(10+i*4,7,tpdata);               
  565.         }
  566. }
  567. //方块生成函数
  568. void box_build()
  569. {
  570.         s_box.mode=next_mode;
  571.         s_box.shape=next_shape;
  572.         s_box.x=3;
  573.         s_box.y=0;
  574.         next_mode=TL0%7;//产生随机数，但是是伪随机的
  575.         next_shape=TL0%4;//产生随机数，但是是伪随机的
  576.         show_next_box();//放到game_execute()函数中不知道为什么就是不正常显示
  577. }
  578. void game_button()
  579. {
  580.        
  581.     switch(basic_button())
  582.     {
  583.         case 3: if(s_box.y!=0)//3表示button_a被按下
  584.                 {
  585.                     EA=0;//关中断，如果不关的话可能引起游戏显示混乱
  586.                     speaker=0;
  587.                     if(s_box.shape==3&&check_cover(s_box.x,s_box.y,box_read_data(s_box.mode,0)))
  588.                     {
  589.                                                        
  590.                         s_box.shape=0;
  591.                         box_load();
  592.                         box_to_Box_Ram(s_box.x,s_box.y,box_read_data(s_box.mode,3));
  593.                     }
  594.                     else if(check_cover(s_box.x,s_box.y,box_read_data(s_box.mode,0)))
  595.                     {        if(check_cover(s_box.x,s_box.y,box_read_data(s_box.mode,s_box.shape+1)))
  596.                                                         {       
  597.                                                                 s_box.shape++;
  598.                                                                 box_load();
  599.                                                                 box_to_Box_Ram(s_box.x,s_box.y,box_read_data(s_box.mode,s_box.shape-1));
  600.                                                         }
  601.                      }
  602.                     EA=1;//开中断
  603.                     speaker=1;
  604.                                         }break;
  605.         case 1: if(s_box.y!=0)//1表示down被按下
  606.         {
  607.             EA=0;//关中断，如果不关的话可能引起游戏显示混乱
  608.             speaker=0;
  609.             while(check_cover(s_box.x,s_box.y+1,s_box.box))//检测是否能下降，指导不能再下降为止
  610.             {
  611.                 s_box.y++;
  612.                 box_to_Box_Ram(s_box.x,s_box.y-1,s_box.box);
  613.             }
  614.             destroy_row();
  615.             box_build();
  616.             box_load();
  617.                                         //        game_over_flag=check_game_over();//游戏结束标志位置1表示游戏结束
  618.                                         //        next_box();
  619.             box_to_Box_Ram(s_box.x,s_box.y,s_box.box);
  620.             EA=1;//开中断
  621.             speaker=1;
  622.             }break;
  623.         case 4: if(s_box.y!=0)//4表示left被按下
  624.         {
  625.             EA=0;//关中断，如果不关的话可能引起游戏显示混乱
  626.             speaker=0;
  627.             if(check_cover(s_box.x-1,s_box.y,s_box.box))
  628.             {
  629.                 s_box.x--;
  630.                 box_to_Box_Ram(s_box.x+1,s_box.y,s_box.box);
  631.             }
  632.             EA=1;//开中断
  633.             speaker=1;
  634.         }break;
  635.         case 5: if(s_box.y!=0)//5表示right被按下
  636.                 {
  637.                     EA=0;//关中断，如果不关的话可能引起游戏显示混乱
  638.                     speaker=0;
  639.                     if(check_cover(s_box.x+1,s_box.y,s_box.box))
  640.                     {
  641.                         s_box.x++;
  642.                         box_to_Box_Ram(s_box.x-1,s_box.y,s_box.box);
  643.                     }
  644.                                                 EA=1;//开中断
  645.                                                 speaker=1;
  646.                                         }break;
  647.         case 2: //2表示up被按下
  648.             speaker=0;
  649.             pause_game_flag=~pause_game_flag;//游戏暂停标志取反
  650.             while(up==0);
  651.             speaker=1;
  652.             break;
  653.         default:;
  654.     }       
  655. }
  656. //检查游戏结束函数（游戏结束返回1，游戏没有结束返回0）
  657. bit check_game_over()
  658. {
  659.         unsigned char i;
  660.         bit tpflag=0;
  661.         unsigned int temp;
  662.         temp=s_box.box;
  663.         for(i=0;i<4;i++)
  664.         {
  665.                 if((((temp&0x000f)<<(9-s_box.x))&Box_Ram[3-i+s_box.y])!=0x0000)
  666.                 {
  667.                         tpflag=1;
  668.                 }
  669.                 temp=temp>>4;
  670.         }//检查新建方块是否和原有图形重叠,重叠置标志位tpflag为1,不重叠不置标志位，即tpflag为0
  671.         return(tpflag);
  672. }
  673. //游戏执行函数（控制方块下落，检测是否到底，如果到底调用消行函数）
  674. void game_execute()
  675. {
  676.         if(box_down_reg<20-(speed_num<<1))
  677.         {                                  
  678.                 box_down_reg++;
  679.         }
  680.         else
  681.         {
  682.                 box_down_reg=0;
  683.                 if(check_cover(s_box.x,s_box.y+1,s_box.box))
  684.                 {
  685.                         s_box.y++;
  686.                         box_to_Box_Ram(s_box.x,s_box.y-1,s_box.box);
  687.                 }//检测是否还可以下降，如果还能下降则继续下降
  688.                 else
  689.                 {
  690.                         destroy_row();
  691.                         box_build();
  692.                         box_load();
  693.                         game_over_flag=check_game_over();//游戏结束标志位置1表示游戏结束
  694.                         box_to_Box_Ram(s_box.x,s_box.y,s_box.box);
  695.                         box_down_reg=(20-(speed_num<<1)-1);//为了使方块一出现就能变换形状，所以需要尽快使得方块下降一行，不知道为什么最高行不能变换形状
  696.                 }//如果不能下降则调用消行函数检查是否可以消行，之后重新建立方块
  697.         }       
  698. }
  699. //选择游戏速度函数
  700. void select_speed()
  701. {
  702.         unsigned char i;
  703.         bit tpflag=1;//置循环标志位为1
  704.         LCD_clear();
  705.         for(i=0;i<128;i++)
  706.         {
  707.                 LCD_display_byte(i,0,0xff);
  708.                 LCD_display_byte(i,7,0xff);
  709.         }
  710.         LCD_display_byte(60,4,0x7f);
  711.         LCD_display_byte(59,4,0x3e);
  712.         LCD_display_byte(58,4,0x1c);
  713.         LCD_display_byte(57,4,0x08);
  714.         LCD_display_byte(67,4,0x7f);
  715.         LCD_display_byte(68,4,0x3e);
  716.         LCD_display_byte(69,4,0x1c);
  717.         LCD_display_byte(70,4,0x08);
  718.         LCD_display_word(speed_data,24,3,52);
  719.         show_speed_num(62,4);
  720.         while(tpflag)
  721.         {
  722.                 switch(basic_button())
  723.                 {
  724.                         case 4: if(speed_num!=0)
  725.                                         {
  726.                                                 speaker=0;
  727.                                                 speed_num--;
  728.                                                 show_speed_num(62,4);
  729.                                                 speaker=1;
  730.                                         }
  731.                                         while(left==0);
  732.                                         break;
  733.                         case 5: if(speed_num!=9)
  734.                                         {
  735.                                             speaker=0;
  736.                                                 speed_num++;
  737.                                                 show_speed_num(62,4);
  738.                                                 speaker=1;
  739.                                         }
  740.                                         while(right==0);
  741.                                         break;
  742.                         case 6: tpflag=0;
  743.                                  speaker=0;
  744.                                         while(button_b==0);
  745.                                         speaker=1;
  746.                                         break;
  747.                         default:;
  748.                 }
  749.         }//选择游戏速度循环
  750. }
  751. //游戏开始显示画面
  752. void game_start_show()
  753. {
  754.         bit tpflag=1;//置循环标志位为1
  755.         LCD_full_draw(start_pic);
  756.         while(tpflag)
  757.         {
  758.                 switch(basic_button())
  759.                 {
  760.                         case 6: tpflag=0;
  761.                                 speaker=0;
  762.                                         while(button_b==0);
  763.                                         speaker=1;
  764.                                         break;
  765.                         default:;
  766.                 }
  767.         }//game_start_show循环
  768. }
  769. //游戏初始化函数
  770. void game_initialize()
  771. {
  772.         box_down_reg=0;
  773.         next_mode=6;
  774.         next_shape=2;
  775.         destroy_row_num=0;
  776.         game_over_flag=0;
  777.         pause_game_flag=0;
  778.         LCD_clear();
  779.         time0_reg=0;
  780.         display_basic();       
  781.         LCD_display_word(score_data,24,0,3);
  782.         LCD_display_word(speed_data,24,3,3);
  783.         show_score_num(3,1);
  784.         show_speed_num(13,4);
  785. }
  786. //定时器0初始化函数
  787. void time0_initialize()
  788. {
  789.         TMOD=0x03;//定时器0，16位工作方式
  790.         TR0=1; //启动定时器
  791.         ET0=1; //打开定时器0中断
  792.                         //默认中断优先级为低
  793.         EA=1; //打开总中断
  794. }
  795. //俄罗斯方块游戏主函数
  796. void Tetris_main()
  797. {
  798.         unsigned char i;
  799.         for(i=0;i<19;i++)
  800.         {
  801.                 Box_Ram[i]=Box_Ram_data[i];
  802.         };//载入游戏初始显示画面
  803.         LCD_draw(mpic);
  804.         game_over_flag=0;//游戏结束标志位置0表示游戏未结束
  805.         box_build();
  806.         box_load();
  807. //        next_box();
  808.         box_to_Box_Ram(s_box.x,s_box.y,s_box.box);
  809.         box_down_reg=(20-(speed_num<<1)-1);//为了使方块一出现就能变换形状，所以需要尽快使得方块下降一行，不知道为什么最高行不能变换形状
  810.         time0_initialize();
  811.         while(!game_over_flag)//如果游戏结束标志位置1，表示游戏结束，打破循环，调用游戏结束画面显示函数
  812.         {
  813.                 game_button();
  814.         }
  815.         EA=0;//游戏结束后关中断
  816. }
  817. //游戏结束画面显示函数
  818. void game_over_show()
  819. {
  820.         unsigned char i;
  821.         bit tpflag=1;//置循环标志位为1
  822.         LCD_full_draw(over_pic);
  823.         while(button_a==0);
  824.         while(tpflag)
  825. ……………………

  827. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
0.png

所有资料51hei提供下载:
俄罗斯方块完整资料.7z (1.25 MB, 下载次数: 380)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:590216 发表于 2019-7-25 14:43 | 显示全部楼层
哇这个看起来很清楚，想试一试
回复

使用道具 举报

ID:275030 发表于 2019-7-25 17:13 | 显示全部楼层
下载学习一下LCD使用方法，谢谢分享
回复

使用道具 举报

ID:407535 发表于 2019-7-25 17:30 | 显示全部楼层
膜拜大佬！
回复

使用道具 举报

ID:712698 发表于 2020-3-21 09:54 | 显示全部楼层
代码报错
回复

使用道具 举报

ID:562148 发表于 2020-3-27 15:40 | 显示全部楼层
看起来不错
回复

使用道具 举报

ID:619259 发表于 2020-3-29 19:15 | 显示全部楼层
大神
回复

使用道具 举报

ID:718740 发表于 2020-3-30 13:46 | 显示全部楼层
膜拜大佬！
回复

使用道具 举报

ID:187521 发表于 2021-2-22 22:59 | 显示全部楼层
精彩的比赛
回复

使用道具 举报

ID:800711 发表于 2021-2-23 13:40 | 显示全部楼层
好家伙，刚好拿来学习。
回复

使用道具 举报

ID:884588 发表于 2021-2-26 10:47 | 显示全部楼层
牛逼！！！！
回复

使用道具 举报

ID:652804 发表于 2021-3-2 19:16 | 显示全部楼层
下载学习一下LCD使用方法，谢谢分享。
回复

使用道具 举报

ID:369562 发表于 2021-3-6 12:38 | 显示全部楼层
取模方式是啥
回复

使用道具 举报

ID:582255 发表于 2021-3-6 22:01 | 显示全部楼层
对我来说不可实现。。。
回复

使用道具 举报

ID:949285 发表于 2021-7-7 15:18 | 显示全部楼层
膜拜大佬
回复

使用道具 举报

ID:982529 发表于 2021-11-23 10:50 来自手机 | 显示全部楼层
实物LCD12864,,好像不显示图案，不知道是不是接错脚了
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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