標題: 基于51單片機的俄羅斯方塊程序與Proteus仿真圖 [打印本頁]
作者: 小林很簡單    時間: 2023-6-16 16:45
標題: 基于51單片機的俄羅斯方塊程序與Proteus仿真圖
仿真在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;//定義所消的行數(shù)
  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檢測忙狀態(tài)函數(shù)
  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. //寫顯示數(shù)據(jù)（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初始化函數(shù)
  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清屏函數(shù)
  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顯示字符串函數(shù)（word表示要顯示的字符串,
  126. //length表示要顯示的字符串寬度,
  127. //x表示首字符所在行數(shù),
  128. //y表示首字符所在列數(shù)）
  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畫全屏函數(shù)
  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顯示一個字節(jié)函數(shù)（
  173.   //x表示x坐標,
  174.   //y表示y坐標,
  175.   //tpdata表示要顯示的數(shù)據(jù)）
  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. //基本界面顯示函數(shù)
  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. //刷新游戲區(qū)域函數(shù)
  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. //游戲中按鍵識別程序（有優(yōu)先級，從高到低依次是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)//按鍵一直被按下時設置時間間隔觸發(fā)
  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)//按鍵一直被按下時設置時間間隔觸發(fā)
  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)//按鍵一直被按下時設置時間間隔觸發(fā)
  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))//按鍵一直被按下時設置時間間隔觸發(fā)
  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))//按鍵一直被按下時設置時間間隔觸發(fā)
  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. //檢查覆蓋函數(shù)（檢查此時帶入的參數(shù)所確定的方塊是否會覆蓋原有圖形，不會覆蓋返回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.     }//先將現(xiàn)有的方塊從游戲點陣緩存中刪除
  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. //方塊緩存數(shù)據(jù)函數(shù)（輸入方塊類型和形狀即可獲得方塊緩存數(shù)據(jù)）
  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. //方塊載入函數(shù)
  444. void box_load()
  445. {
  446.     s_box.box=box_read_data(s_box.mode,s_box.shape);
  447. }
  448. //方塊映射游戲點陣緩存函數(shù)（參數(shù)是原來方塊的位置、緩存，先消去原有位置的方塊）
  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. //顯示數(shù)字函數(shù)（
  467.   //x表示x坐標,
  468.   //y表示y坐標,
  469.   //tpdata表示要顯示的數(shù)字）
  470. //顯示速度函數(shù)
  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. //顯示得分函數(shù)
  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. //消行函數(shù)
  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++;//消除的行數(shù)加一
  505.             /*如不把Box_Ram[19]定義成idata類型的話加入這段代碼顯示數(shù)據(jù)區(qū)就溢出了*/
  506.             if(destroy_row_num%30==0&&speed_num!=9)
  507.             {
  508.                 speed_num++;//消夠三十行游戲速度加一
  509.                 show_speed_num(13,4);//調用顯示游戲速度函數(shù)
  510.             }
  511.             /*如不把Box_Ram[19]定義成idata類型的話加入這段代碼顯示數(shù)據(jù)區(qū)就溢出了*/
  512.             j++;
  513.             if(j==4)
  514.             {
  515.                 break;
  516.             }//檢查完有四行要消除則退出檢查循環(huán)
  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. //顯示下一個方塊函數(shù)
  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. //方塊生成函數(shù)
  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;//產生隨機數(shù)，但是是偽隨機的
  576.     next_shape=TL0%4;//產生隨機數(shù)，但是是偽隨機的
  577.     show_next_box();//放到game_execute()函數(shù)中不知道為什么就是不正常顯示(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. //檢查游戲結束函數(shù)（游戲結束返回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. //游戲執(zhí)行函數(shù)（控制方塊下落，檢測是否到底，如果到底調用消行函數(shù)）
  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.         }//檢測是否還可以下降，如果還能下降則繼續(xù)下降
  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);//為了使方塊一出現(xiàn)就能變換形狀，所以需要盡快使得方塊下降一行，不知道為什么最高行不能變換形狀
  697.         }//如果不能下降則調用消行函數(shù)檢查是否可以消行，之后重新建立方塊
  698.     }   
  699. }
  700. //選擇游戲速度函數(shù)
  701. void select_speed()
  702. {
  703.     unsigned char i;
  704.     bit tpflag=1;//置循環(huán)標志位為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.     }//選擇游戲速度循環(huán)
  751. }
  752. //游戲開始顯示畫面
  753. void game_start_show()
  754. {
  755.     bit tpflag=1;//置循環(huán)標志位為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循環(huán)
  769. }
  770. //游戲初始化函數(shù)
  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初始化函數(shù)
  788. void time0_initialize()
  789. {
  790.     TMOD=0x03;//定時器0，16位工作方式
  791.     TR0=1; //啟動定時器
  792.     ET0=1; //打開定時器0中斷
  793.             //默認中斷優(yōu)先級為低
  794.     EA=1; //打開總中斷
  795. }
  796. //俄羅斯方塊游戲主函數(shù)
  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);//為了使方塊一出現(xiàn)就能變換形狀，所以需要盡快使得方塊下降一行，不知道為什么最高行不能變換形狀
  811.     time0_initialize();
  812.     while(!game_over_flag)//如果游戲結束標志位置1，表示游戲結束，打破循環(huán)，調用游戲結束畫面顯示函數(shù)
  813.     {
  814.         game_button();
  815.     }
  816.     EA=0;//游戲結束后關中斷
  817. }
  818. //游戲結束畫面顯示函數(shù)
  819. void game_over_show()
  820. {
  821.     unsigned char i;
  822.     bit tpflag=1;//置循環(huán)標志位為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畫面循環(huán)
  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.     }//游戲得分顯示循環(huán)
  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();//調用游戲初始化函數(shù)，初始化游戲所有變量以及在液晶屏上顯示基本的信息
  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, 下載次數(shù): 29)




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1