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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机的俄罗斯方块程序与Proteus仿真图
返回列表 发新帖
查看: 1542|回复: 0
打印 上一主题 下一主题
收起左侧

基于51单片机的俄罗斯方块程序与Proteus仿真图

[复制链接]
跳转到指定楼层
楼主
ID:1084173 发表于 2023-6-16 16:45 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
仿真在Proteus8.3运行正常，8.9不行
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

部分代码
  1. #include <REG52.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

  9. sbit change = P3^4;
  10. sbit OK = P3^5;
  11. sbit up = P3^2;
  12. sbit down = P3^0;
  13. sbit left = P3^1;
  14. sbit right = P3^3;
  15. sbit speaker=P3^6;

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

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

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

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

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

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

  860. void main()
  861. {
  862.     LCD_initialize();
  863.     LCD_clear();
  864.     while(1)
  865.     {
  866.         game_start_show();
  867.         select_speed();
  868.         game_initialize();//调用游戏初始化函数，初始化游戏所有变量以及在液晶屏上显示基本的信息
  869.         Tetris_main();
  870.         game_over_show();   
  871.     }   
  872. }
  873. //定时器0中断服务
  874. void timer0() interrupt 1
  875. {
  876.     TH0=0x00;
  877.     TL0=0x00;
  878.     if(time0_reg<10)
  879.     {                  
  880.         time0_reg++;
  881.     }
  882.     else
  883.     {
  884.         time0_reg=0;
  885.         if(pause_game_flag==0)
  886.         {
  887.             game_execute();
  888.             refurbish_display();
  889.         }
  890.     }
  891. }
复制代码

仿真在Proteus8.13 8.3运行正常，8.9不行
Keil代码与Proteus仿真下载: Proteus8.13仿真程序.7z (80.34 KB, 下载次数: 29)

评分

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

查看全部评分

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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