找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 25653|回復(fù): 39
打印 上一主題 下一主題
收起左側(cè)

原創(chuàng)51單片機俄羅斯方塊程序 12864屏顯示 代碼有詳細(xì)注釋

  [復(fù)制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:140725 發(fā)表于 2017-3-6 03:46 | 只看該作者 |只看大圖 回帖獎勵 |倒序瀏覽 |閱讀模式
給51黑電子論壇的朋友們分享一個很優(yōu)秀的俄羅斯方塊程序，lcd12864屏幕 是用普通的51單片機做的，P3.4口，短按就可以開始運行了。效果如下圖所示：

完整的源碼下載：
俄羅斯方塊全部源碼.zip (147.88 KB, 下載次數(shù): 599)



Tetris.c源程序文件內(nèi)容：
  1. /*******************************************************
  2. * 文件名稱：Tetris.c
  3. * 單 片 機：STC89C52RC
  4. * 簡    述：使用LCD12864顯示的俄羅斯方塊程序
  5. * 功    能：計分，下一個方塊預(yù)覽，歡迎結(jié)束界面，長按連續(xù)左右移，暫停（按鍵Left+Turn）
  6. * 作    者：劉琦
  7. * 完成日期：4月21日
  8. * IO口設(shè)定：按鍵
  9.                         sbit key_sr_left=P3^7;
  10.                         sbit key_sr_turn=P3^6;
  11.                         sbit key_sr_right=P3^5;
  12.                         sbit key_sr_down=P3^4;
  13.                         LCD12864
  14.                         sbit RS_Port=P1^0;
  15.                         sbit RW_Port=P1^1;
  16.                         sbit E_Port=P2^5;
  17.                         sbit PSB_Port=P1^2;
  18.                         sbit RST_Port=P1^4;
  19.                         數(shù)碼管鎖存器
  20.                         sbit dula=P2^6;
  21.                         sbit wela=P2^7;

  23. *******************************************************/

  25. /*****************************頭文件區(qū)*****************************************************/
  26. #include<reg52.h>
  27. //#include"STC15F2K60S2.h"
  28. #include"task_key.h"
  29. #include"task_activation.h"
  30. #include"12864b.h"
  31. #include"TaskBlock.h"
  32. #include"Block.h"
  33. /*****************************宏定義區(qū)*****************************************************/

  35. //需要判斷是否刷新的任務(wù)總數(shù)
  36. //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  37. #define NUM_TASK_FLAG 7
  38. //需要定時刷新的任務(wù)總數(shù)
  39. //1TaskGoingDown,2KeyService
  40. #define NUM_TASK_REFRESH 3
  41. //刷新頻率
  42. #define TIME_PER_SEC 200                                                        //每次進入中斷的頻率，200Hz
  43. #define TIME_CLOCK 11059200                                                        //晶振頻率
  44. #define TIME_KEY_SERVICE_50HZ  TIME_PER_SEC/50          //按鍵服務(wù)頻率，0.02s
  45. #define TIME_TASKGOINGDOWN_2HZ  TIME_PER_SEC/2          //下落頻率，0.5s

  47. /******************************子函數(shù)聲明區(qū)***********************************************/

  49. void initial_myself(void);   
  50. void initial_peripheral(void);
  51. void delay100ms(void);        

  53. /******************************全局變量定義區(qū)***********************************************/
  54. unsigned char uc_state=1;//狀態(tài)標(biāo)示:1歡迎界面，2等待開始界面，3下落界面，4死亡界面，5暫停界面
  55. enum Block{S1,S2,Z1,Z2,L1,L2,L3,L4,J1,J2,J3,J4,I1,I2,O1,T_1,T_2,T_3,T_4}enumBlock;//方塊編號
  56. unsigned char ucBlockNow=0;//當(dāng)前方塊
  57. unsigned char ucBlockNext=0;//下一個方塊

  59. unsigned char ucFlagScreenChange=1;//界面變更標(biāo)志，界面更改時置1，激活task_activation

  61. unsigned char ucCoordinate[2];//方塊的旋轉(zhuǎn)點坐標(biāo)，橫H，豎S
  62. unsigned char xdata ucxMap[10][20];//整張屏幕的標(biāo)記地圖，用來記錄未消除方塊位置，有方塊則為1
  63. unsigned char ucxBlockPosition[4][2];//方塊的4個小方塊坐標(biāo),[0][0],[0][1]為旋轉(zhuǎn)點坐標(biāo)H,S

  65. unsigned int uc_delay_task_cnt[NUM_TASK_REFRESH];//任務(wù)刷新延遲
  66. unsigned char uc_flag_taskrefresh[NUM_TASK_FLAG];//任務(wù)刷新標(biāo)志

  68. unsigned long int ucScore=0;//得分

  70. /******************************主函數(shù)開始***********************************************/
  71. void main(void)
  72. {
  73.         unsigned char i=0;
  74.         initial_myself();
  75.         delay100ms();   
  76.     initial_peripheral();


  79.         while(1)
  80.         {
  81.                 if(ucFlagScreenChange==1)//界面變更標(biāo)志為1時，進行任務(wù)激活，防止一直刷新界面
  82.                 {
  83.                         task_activation(uc_state);
  84.                         ucFlagScreenChange=0;
  85.                 }
  86.                 if(uc_delay_task_cnt[2]==0)//20HZ頻率刷新key_service
  87.                 {
  88.                         task_key_service();
  89.                         ET0=0;//在中斷中也有可能變化的變量在更改前時先關(guān)閉中斷
  90.                         uc_delay_task_cnt[2]=TIME_KEY_SERVICE_50HZ;//延遲重置
  91.                         ET0=1;
  92.                 }
  93.                 if(uc_flag_taskrefresh[5]&&uc_delay_task_cnt[1]==0)//需要時,2HZ頻率刷新TaskGoingDown
  94.                 {
  95.                         if(!TaskGoingDown())//下落失敗
  96.                         {
  97.                                 //將當(dāng)前方塊位置寫入Map
  98.                                 for(i=0;i<4;i++)
  99.                                 {
  100.                                         ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]=1;
  101.                                 }
  102.                                 //調(diào)用消除方塊函數(shù)
  103.                                 TaskClear();
  104.                         }
  105.                         ET0=0;//在中斷中也有可能變化的變量在更改前時先關(guān)閉中斷
  106.                         uc_delay_task_cnt[1]=TIME_TASKGOINGDOWN_2HZ;//延遲重置
  107.                         ET0=1;
  108.                 }

  110.         }
  111. }

  113. //中斷函數(shù)
  114. void timer0(void) interrupt 1
  115. {
  116.         unsigned char i;
  117.         TR0=0;
  118.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
  119.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
  120.         //task_delay[]減到0時，相應(yīng)的函數(shù)準(zhǔn)備就緒
  121.         for(i=0;i<NUM_TASK_REFRESH;i++)
  122.         {
  123.                 if(uc_delay_task_cnt[i]!=0)//延遲不為0時才減
  124.                         {uc_delay_task_cnt[i]--;};
  125.         }
  126.         task_key_scan();//按鍵掃描函數(shù)，放在中斷中，保證準(zhǔn)時掃描
  127.         TR0=1;
  128. }

  130. //初始化區(qū)
  131. void initial_myself(void)//第一區(qū) 初始化單片機
  132. {
  133.         unsigned char i;
  134.         for(i=0;i<NUM_TASK_REFRESH;i++)uc_delay_task_cnt[i]=0;//初始化讓所有任務(wù)就緒
  135.         TMOD=0X21; //定時器0為16位不自動重裝，用來定時；定時器1為8位自動重裝，用來產(chǎn)生隨機數(shù)
  136.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
  137.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
  138.         TH1=0;
  139.         TL1=0;
  140. }

  142. void initial_peripheral(void) //第二區(qū) 初始化外圍
  143. {
  144.         Lcd_Init();//初始化12864
  145.         EA=1;     //開總中斷
  146.         ET0=1;    //允許定時器0中斷，定時器1無需開啟中斷
  147.     TR0=1;    //啟動定時器0
  148.     TR1=1;         //啟動定時器1
  149. }

  151. void delay100ms(void)                //@11.0592MHz
  152. {
  153.         unsigned char i, j, k;

  155.         ;
  156.         ;
  157.         i = 5;
  158.         j = 52;
  159.         k = 195;
  160.         do
  161.         {
  162.                 do
  163.                 {
  164.                         while (--k);
  165.                 } while (--j);
  166.         } while (--i);
  167. }
復(fù)制代碼
  1. /*******************************************************
  2. * 文件名稱：task_activation.c
  3. * 單 片 機：STC89C52RC
  4. * 簡    述：任務(wù)激活子程序，uc_state:1歡迎界面，2等待界面，3下落界面，4死亡界面
  5. * 作    者：劉琦
  6. * 完成日期：2015年5月1日
  7. *******************************************************/
  8. #include"reg52.h"
  9. #include"12864b.h"
  10. #include"tetris.h"
  11. #include"TaskBlock.h"
  12. #include"Score.h"
  13. //#include"STC15F2K60S2.h"

  15. #define  xchar unsigned char code

  17. //歡迎詞
  18. xchar CorpInf[]=
  19. {
  20.         "來玩俄羅斯方塊！"
  21. };
  22. //死亡詞
  23. xchar CorpInf1[]=
  24. {
  25.         "不好意思你死了！"
  26. };

  28. void task_activation(unsigned char state)        
  29. {
  30.         unsigned char i=0,j=0;
  31.         switch(state)
  32.         {
  33.                 case 1: //歡迎界面
  34.                                 DisGBStr(CorpInf);                                //寫入歡迎詞
  35.                         //當(dāng)前界面需要刷新的任務(wù)
  36.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  37.                                 uc_flag_taskrefresh[1]=0;               
  38.                             uc_flag_taskrefresh[2]=0;
  39.                             uc_flag_taskrefresh[3]=0;
  40.                             uc_flag_taskrefresh[4]=1;
  41.                             uc_flag_taskrefresh[5]=0;
  42.                             uc_flag_taskrefresh[6]=0;
  43.                             break;
  44.                 case 2:        //等待界面
  45.                                 //清空所有顯示
  46.                                 Cram_Off();                //清空文本顯示
  47.                                 Clr_GDRAM();        //清空繪圖顯示
  48.                                 //畫出邊框
  49.                                 DrawLineY(7,1,62,1);
  50.                                 DrawLineX(7,127,1,1);
  51.                                 DrawLineX(7,127,62,1);

  53.                                 //將地圖數(shù)據(jù)清空
  54.                                 for(i=0;i<10;i++)
  55.                                 {
  56.                                         for(j=0;j<20;j++)
  57.                                         {
  58.                                                 ucxMap[i][j]=0;
  59.                                         }
  60.                                 }

  62.                                 ucScore=0;//計分清0

  64.                         //當(dāng)前界面需要刷新的任務(wù)
  65.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  66.                         uc_flag_taskrefresh[1]=0;
  67.                             uc_flag_taskrefresh[2]=0;
  68.                             uc_flag_taskrefresh[3]=0;
  69.                             uc_flag_taskrefresh[4]=1;
  70.                             uc_flag_taskrefresh[5]=0;
  71.                             uc_flag_taskrefresh[6]=0;
  72.                             break;
  73.                 case 3:        //下落界面
  74.                                 TaskScore ();                //寫分，刷新最開始的0000000
  75.                                 TaskComingNew();        //出新方塊
  76.                         //當(dāng)前界面需要刷新的任務(wù)
  77.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  78.                                 uc_flag_taskrefresh[1]=1;
  79.                             uc_flag_taskrefresh[2]=1;
  80.                             uc_flag_taskrefresh[3]=1;
  81.                             uc_flag_taskrefresh[4]=1;
  82.                             uc_flag_taskrefresh[5]=1;
  83.                             uc_flag_taskrefresh[6]=1;
  84.                             break;
  85.                 case 4:        //死亡界面
  86.                                 Cram_Off();                //清空文本顯示
  87.                                 Clr_GDRAM();        //清空繪圖顯示
  88.                                 DisGBStr(CorpInf1);
  89.                         //當(dāng)前界面需要刷新的任務(wù)
  90.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  91.                         uc_flag_taskrefresh[1]=0;
  92.                             uc_flag_taskrefresh[2]=0;
  93.                             uc_flag_taskrefresh[3]=0;
  94.                             uc_flag_taskrefresh[4]=1;
  95.                             uc_flag_taskrefresh[5]=0;
  96.                             uc_flag_taskrefresh[6]=0;
  97.                             break;
  98.                 case 5:        //暫停界面
  99.                         //當(dāng)前界面需要刷新的任務(wù)
  100.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  101.                         uc_flag_taskrefresh[1]=0;
  102.                             uc_flag_taskrefresh[2]=0;
  103.                             uc_flag_taskrefresh[3]=0;
  104.                             uc_flag_taskrefresh[4]=1;
  105.                             uc_flag_taskrefresh[5]=0;
  106.                             uc_flag_taskrefresh[6]=0;
  107.                             break;
  108.                 default:
  109.                             break;
  110.         }
  111. }
復(fù)制代碼
  1. #include"reg52.h"
  2. //#include"STC15F2K60S2.h"
  3. #include"tetris.h"
  4. #include"Block.h"
  5. #include"TaskBlock.h"

  7. #define CONST_KEY_TIME 10    //按鍵去抖動延時的時間

  9. //#define const_time_0_25s  111   //0.25秒鐘的時間需要的定時中斷次數(shù)
  10. //#define const_time_0_5s     222   //0.5秒鐘的時間需要的定時中斷次數(shù)

  12. #define const_time_0_25s  60   //0.125秒鐘的時間需要的定時中斷次數(shù)
  13. #define const_time_0_5s     60   //0.125秒鐘的時間需要的定時中斷次數(shù)


  16. sbit key_sr_left=P3^7;
  17. sbit key_sr_turn=P3^6;
  18. sbit key_sr_right=P3^5;
  19. sbit key_sr_down=P3^4;

  21. unsigned char ucKeySec=0;   //被觸發(fā)的按鍵編號

  23. unsigned int  uiKeyTimeCnt_left=0; //按鍵去抖動延時計數(shù)器
  24. unsigned int  uiKeyCtntyCnt_left=0; //按鍵連續(xù)觸發(fā)的間隔延時計數(shù)器
  25. unsigned char ucKeyLock_left=0; //按鍵觸發(fā)后自鎖的變量標(biāo)志

  27. unsigned int  uiKeyTimeCnt_turn=0; //按鍵去抖動延時計數(shù)器
  28. //unsigned int  uiKeyCtntyCnt_turn=0; //按鍵連續(xù)觸發(fā)的間隔延時計數(shù)器
  29. unsigned char ucKeyLock_turn=0; //按鍵觸發(fā)后自鎖的變量標(biāo)志

  31. unsigned int  uiKeyTimeCnt_right=0; //按鍵去抖動延時計數(shù)器
  32. unsigned int  uiKeyCtntyCnt_right=0; //按鍵連續(xù)觸發(fā)的間隔延時計數(shù)器
  33. unsigned char ucKeyLock_right=0; //按鍵觸發(fā)后自鎖的變量標(biāo)志

  35. unsigned int  uiKeyTimeCnt_down=0; //按鍵去抖動延時計數(shù)器
  36. unsigned char ucKeyLock_down=0; //按鍵觸發(fā)后自鎖的變量標(biāo)志

  38. unsigned int  uiKeyTimeCnt_pause=0; //按鍵去抖動延時計數(shù)器
  39. unsigned char ucKeyLock_pause=0; //按鍵觸發(fā)后自鎖的變量標(biāo)志

  41. //放在中斷中，其中的每個按鍵的標(biāo)志位為1時才刷新
  42. void task_key_scan(void)
  43. {
  44.         if(uc_flag_taskrefresh[1])
  45.         {
  46.                 if(key_sr_left==1)//left
  47.                   {
  48.                      ucKeyLock_left=0;
  49.                      uiKeyTimeCnt_left=0;
  50.                          uiKeyCtntyCnt_left=0;   
  51.                  }
  52.             else if(ucKeyLock_left==0)
  53.                  {
  54.                      uiKeyTimeCnt_left++;
  55.                      if(uiKeyTimeCnt_left>CONST_KEY_TIME)
  56.                      {
  57.                         uiKeyTimeCnt_left=0;
  58.                         ucKeyLock_left=1;  
  59.                         ucKeySec=1;    //觸發(fā)1號鍵,left
  60.                      }
  61.             }
  62.                 else if(uiKeyTimeCnt_left<const_time_0_5s)
  63.                 {
  64.                          uiKeyTimeCnt_left++;
  65.                 }
  66.                 else
  67.                 {
  68.                          uiKeyCtntyCnt_left++;
  69.                          if(uiKeyCtntyCnt_left>const_time_0_25s)
  70.                          {
  71.                                  uiKeyCtntyCnt_left=0;
  72.                                 ucKeySec=1;    //觸發(fā)1號鍵,left
  73.                          }
  74.                 }
  75.         }

  77.         if(uc_flag_taskrefresh[2])
  78.         {
  79.                 if(key_sr_turn==1)//turn
  80.                   {
  81.                      ucKeyLock_turn=0;
  82.                      uiKeyTimeCnt_turn=0;
  83. //                         uiKeyCtntyCnt_turn=0;   
  84.                  }
  85.             else if(ucKeyLock_turn==0)
  86.                  {
  87.                      uiKeyTimeCnt_turn++;
  88.                      if(uiKeyTimeCnt_turn>CONST_KEY_TIME)
  89.                      {
  90.                         uiKeyTimeCnt_turn=0;
  91.                         ucKeyLock_turn=1;  
  92.                         ucKeySec=2;    //觸發(fā)2號鍵,turn
  93.                      }
  94.             }
  95.         }

  97.         if(uc_flag_taskrefresh[3])
  98.         {
  99.                 if(key_sr_right==1)//right
  100.                   {
  101.                      ucKeyLock_right=0;
  102.                      uiKeyTimeCnt_right=0;
  103.                          uiKeyCtntyCnt_right=0;   
  104.                  }
  105.             else if(ucKeyLock_right==0)
  106.                  {
  107.                      uiKeyTimeCnt_right++;
  108.                      if(uiKeyTimeCnt_right>CONST_KEY_TIME)
  109.                      {
  110.                         uiKeyTimeCnt_right=0;
  111.                         ucKeyLock_right=1;  
  112.                         ucKeySec=3;    //觸發(fā)3號鍵,right
  113.                      }
  114.             }
  115.                 else if(uiKeyTimeCnt_right<const_time_0_5s)
  116.                 {
  117.                          uiKeyTimeCnt_right++;
  118.                 }
  119.                 else
  120.                 {
  121.                          uiKeyCtntyCnt_right++;
  122.                          if(uiKeyCtntyCnt_right>const_time_0_25s)
  123.                          {
  124.                                  uiKeyCtntyCnt_right=0;
  125.                                 ucKeySec=3;    //觸發(fā)3號鍵,right
  126.                          }
  127.                 }
  128.         }

  130.         if(uc_flag_taskrefresh[4])
  131.         {
  132.                 if(key_sr_down==1)//down
  133.                   {
  134.                      ucKeyLock_down=0; //按鍵自鎖標(biāo)志清零
  135.                      uiKeyTimeCnt_down=0;//按鍵去抖動延時計數(shù)器清零   
  136.                  }
  137.             else if(ucKeyLock_down==0)//有按鍵按下，且是第一次被按下，并且當(dāng)前界面支持這個按鍵
  138.                  {
  139.                      uiKeyTimeCnt_down++; //累加定時中斷次數(shù)
  140.                           if(uiKeyTimeCnt_down>CONST_KEY_TIME)
  141.                      {
  142.                         uiKeyTimeCnt_down=0;
  143.                         ucKeyLock_down=1;  //自鎖按鍵置位,避免一直觸發(fā)
  144.                         ucKeySec=4;    //觸發(fā)4號鍵,down
  145.                      }
  146.             }
  147.         }

  149.         if(uc_flag_taskrefresh[6])
  150.         {                        
  151.           if(key_sr_left==1||key_sr_turn==1)//pause，按鍵左和按鍵旋轉(zhuǎn)未同時按下
  152.           {
  153.                  ucKeyLock_pause=0; //按鍵自鎖標(biāo)志清零
  154.                  uiKeyTimeCnt_pause=0;//按鍵去抖動延時計數(shù)器清零      
  155.           }
  156.                 else if(ucKeyLock_pause==0)//有按鍵按下，且是第一次被按下
  157.                 {
  158.                     uiKeyTimeCnt_pause++; //累加定時中斷次數(shù)
  159.                     if(uiKeyTimeCnt_pause>CONST_KEY_TIME)
  160.                     {
  161.                             uiKeyTimeCnt_pause=0;
  162.                         ucKeyLock_pause=1;  //自鎖按鍵置位,避免一直觸發(fā)
  163.                     ucKeySec=6;    //觸發(fā)6號鍵，暫停
  164.                     }
  165.                 }
  166.         }
  167. }

  169. //按鍵服務(wù)函數(shù)
  170. void task_key_service(void)
  171. {
  172.         unsigned char ucCheck=0;
  173.         unsigned char ucOldEnum=0;
  174.         unsigned char ucNewEnum=0;
  175.         unsigned char i=0;
  176.         switch(ucKeySec) //按鍵服務(wù)狀態(tài)切換
  177.           {
  178.             case 1:// 1號鍵,left
  179.                                 ucCoordinate[0]++;                                //旋轉(zhuǎn)點坐標(biāo)H+1
  180.                                 WriteBlockCoordinate();                        //寫入其他3個方塊坐標(biāo)
  181.                                 ucCheck=TaskCheck();                        //檢測碰撞
  182.                                 if(ucCheck)                                                //未碰撞，則左移
  183.                                 {
  184.                                         ucCoordinate[0]--;
  185.                                         ChangeBlock(0);
  186.                                         ucCoordinate[0]++;
  187.                                         ChangeBlock(1);
  188.                                 }
  189.                                 else                                                    //碰撞，不變
  190.                                 {
  191.                                         ucCoordinate[0]--;
  192.                                         WriteBlockCoordinate();
  193.                                 }
  194.             break;
  195.                 case 2:// 2號鍵,turn
  196.                                 ucOldEnum=enumBlock;
  197.                                 switch(enumBlock)                                //旋轉(zhuǎn)后改變方塊編號
  198.                                 {
  199.                                         case S1:
  200.                                                         enumBlock=S2;
  201.                                         break;
  202.                                         case S2:
  203.                                                         enumBlock=S1;
  204.                                         break;
  205.                                         case Z1:
  206.                                                         enumBlock=Z2;
  207.                                         break;
  208.                                         case Z2:
  209.                                                         enumBlock=Z1;
  210.                                         break;
  211.                                         case L1:
  212.                                                         enumBlock=L2;
  213.                                         break;
  214.                                         case L2:
  215.                                                         enumBlock=L3;
  216.                                         break;
  217.                                         case L3:
  218.                                                         enumBlock=L4;
  219.                                         break;
  220.                                         case L4:
  221.                                                         enumBlock=L1;
  222.                                         break;
  223.                                         case J1:
  224.                                                         enumBlock=J2;
  225.                                         break;
  226.                                         case J2:
  227.                                                         enumBlock=J3;
  228.                                         break;
  229.                                         case J3:
  230.                                                         enumBlock=J4;
  231.                                         break;
  232.                                         case J4:
  233.                                                         enumBlock=J1;
  234.                                         break;
  235.                                         case I1:
  236.                                                         enumBlock=I2;
  237.                                         break;
  238.                                         case I2:
  239.                                                         enumBlock=I1;
  240.                                         break;
  241.                                         case O1:
  242.                                                         enumBlock=O1;
  243.                                         break;
  244.                                         case T_1:
  245.                                                         enumBlock=T_2;
  246.                                         break;
  247.                                         case T_2:
  248.                                                         enumBlock=T_3;
  249.                                         break;
  250.                                         case T_3:
  251.                                                         enumBlock=T_4;
  252.                                         break;
  253.                                         case T_4:
  254.                                                         enumBlock=T_1;
  255.                                         break;
  256.                                         default:
  257.                                         break;
  258.                                 }
  259.                                 WriteBlockCoordinate();
  260.                                 ucCheck=TaskCheck();
  261.                                 if(ucCheck)
  262.                                 {
  263.                                         ucNewEnum=enumBlock;
  264.                                         enumBlock=ucOldEnum;
  265.                                         ChangeBlock(0);
  266.                                         enumBlock=ucNewEnum;
  267.                                         ChangeBlock(1);
  268.                                 }
  269.                                 else
  270.                                 {
  271.                                         enumBlock=ucOldEnum;
  272.                                         WriteBlockCoordinate();
  273.                                 }

  275.             break;
  276.             case 3:// 3號鍵,right
  277.                                 ucCoordinate[0]--;
  278.                                 WriteBlockCoordinate();
  279.                                 ucCheck=TaskCheck();
  280.                                 if(ucCheck)
  281.                                 {
  282.                                         ucCoordinate[0]++;
  283.                                         ChangeBlock(0);
  284.                                         ucCoordinate[0]--;
  285.                                         ChangeBlock(1);
  286.                                 }
  287.                                 else
  288.                                 {
  289.                                         ucCoordinate[0]++;
  290.                                         WriteBlockCoordinate();
  291.                                 }

  293.             break;
  294.                 case 4:// 4號鍵,down
  295.                                 //根據(jù)所處界面不同，按鍵down的功能不同
  296.                                 switch(uc_state)
  297.                                 {
  298.                                         case 1:
  299.                                                         ucBlockNow=TL1%7;                //準(zhǔn)備進入等待界面，就先產(chǎn)生當(dāng)前隨機方塊
  300.                                                         uc_state=2;                                 //進入等待界面
  301.                                                         ucFlagScreenChange=1;        //激活界面變更
  302.                                         break;
  303.                                         case 2:
  304.                                                         uc_state=3;                                //進入下落界面
  305.                                                         ucFlagScreenChange=1;
  306.                                         break;
  307.                                         case 3:        //在下落界面下，down為直接下落到底
  308.                                                         ET0=0;//關(guān)閉計時器0，出新后開啟，防止直接下落
  309.                                                         ChangeBlock(0);                 //先清除當(dāng)前的圖形
  310.                                                         do                                                //循環(huán)模擬下落并檢測，直到失敗
  311.                                                         {
  312.                                                                 ucCoordinate[1]++;
  313.                                                                 WriteBlockCoordinate();
  314.                                                                 ucCheck=TaskCheck();
  315.                                                         }
  316.                                                         while(ucCheck);
  317.                                                         ucCoordinate[1]--;                //恢復(fù)到最后一次成功的坐標(biāo)
  318.                                                         WriteBlockCoordinate();
  319.                                                         ChangeBlock(1);                        //畫方塊

  321.                                                         //立即寫入，并消除，防止到底后還可以移動
  322.                                                         //寫入Map
  323.                                                         for(i=0;i<4;i++)
  324.                                                         {
  325.                                                                 ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]=1;
  326.                                                         }
  327.                                                         //調(diào)用消除
  328.                                                         TaskClear();
  329.                                                         //刷新下落延遲，防止出新后，直接下落
  330.                                                         ET0=1;
  331.                                         break;
  332.                                         case 4:        //死亡界面
  333.                                                         ucBlockNow=TL1%7;                //準(zhǔn)備進入等待界面，就先產(chǎn)生當(dāng)前隨機方塊
  334.                                                         uc_state=2;                                 //進入等待界面
  335.                                                         ucFlagScreenChange=1;
  336.                                         break;
  337.                                         case 5:        //暫停界面
  338.                                                         uc_state=3;                                //進入下落界面
  339.                                                         //開啟下落界面時的相關(guān)任務(wù)
  340.                                                         uc_flag_taskrefresh[1]=1;
  341.                                                     uc_flag_taskrefresh[2]=1;
  342.                                                     uc_flag_taskrefresh[3]=1;
  343.                                                     uc_flag_taskrefresh[4]=1;
  344.                                                     uc_flag_taskrefresh[5]=1;
  345.                                                     uc_flag_taskrefresh[6]=1;
  346.                                         break;
  347.                                 }
  348.             break;
  349.                 case 6:// 6號鍵,pause
  350.                                 uc_state=5;
  351.                                 ucFlagScreenChange=1;
  352.                 break;
  353.                 default:
  354.                 break;                 
  355.           }
  356.         ucKeySec=0;
  357. }
復(fù)制代碼
  1. /*******************************************************
  2. * 文件名稱：TaskBlock.c
  3. * 單 片 機：STC89C52RC
  4. * 簡    述：方塊子程序，包含，下落，出新，消除，檢測
  5. * 作    者：劉琦
  6. * 完成日期：2015年4月21日
  7. *******************************************************/
  8. #include<reg52.h>
  9. #include"Tetris.h"
  10. #include"Block.h"
  11. #include"tetris.h"
  12. #include"Score.h"
  13. /*******************************************************
  14. * 函 數(shù) 名:TaskCheck(void)
  15. * 功能描述:檢測
  16. * 函數(shù)說明:檢測左右移，下落，出新，旋轉(zhuǎn)
  17. * 輸入?yún)?shù):無
  18. * 返 回 值:成功失敗標(biāo)示，ucReturn
  19. *******************************************************/
  20. unsigned char TaskCheck(void)
  21. {
  22.         unsigned char ucReturn=0;
  23.         unsigned char i=0;
  24.         //加入檢測部分,包括邊界檢測，碰撞檢測
  25.         //邊界檢測
  26.         for(i=0;i<4;i++)
  27.         {
  28.                 if(ucxBlockPosition[i][0]>=0&&ucxBlockPosition[i][0]<=9                        //檢測左右
  29.                    &&ucxBlockPosition[i][1]>=0&&ucxBlockPosition[i][1]<=19)                //檢測上下
  30.                 {
  31.                         ucReturn=1;
  32.                 }
  33.                 else
  34.                 {
  35.                         ucReturn=0;
  36.                         return ucReturn;//如果邊界檢測失敗，就不進行下面檢測，直接返回失敗
  37.                 }
  38.         }
  39.         //碰撞檢測
  40.         for(i=0;i<4;i++)
  41.         {
  42.                 if(ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]!=0)//與地圖標(biāo)記位置進行比較
  43.                 {
  44.                         ucReturn=0;
  45.                         return ucReturn;
  46.                 }
  47.         }
  48.         return ucReturn;
  49. }
  50. /*******************************************************
  51. * 函 數(shù) 名:unsigned char TaskGoingDown(void)
  52. * 功能描述:方塊下落
  53. * 函數(shù)說明:
  54. * 輸入?yún)?shù):無
  55. * 返 回 值:ucResult，1無碰撞，0碰撞
  56. *******************************************************/
  57. unsigned char TaskGoingDown(void)
  58. {
  59.         unsigned char ucCheck=0;
  60.         unsigned char ucResult=0;
  61.         ucCoordinate[1]++;                                //旋轉(zhuǎn)點坐標(biāo)，豎S+1
  62.         WriteBlockCoordinate();                        //將其他三個小方塊坐標(biāo)寫入數(shù)組
  63.         ucCheck=TaskCheck();                        //檢測碰撞
  64.         if(ucCheck)                                                //無碰撞
  65.         {
  66.                 ucCoordinate[1]--;                        //坐標(biāo)復(fù)位
  67.                 ChangeBlock(0);                                //在老位置消除方塊，只刷新有改變的位置，加快顯示速度
  68.                 ucCoordinate[1]++;                        //坐標(biāo)+1
  69.                 ChangeBlock(1);                                //在新位置畫方塊
  70.                 ucResult=1;
  71.         }
  72.         else                                                        //有碰撞，則不變
  73.         {
  74.                 ucCoordinate[1]--;                        
  75.                 WriteBlockCoordinate();
  76.                 ucResult=0;
  77.         }
  78.         return ucResult;
  79. }
  80. /*******************************************************
  81. * 函 數(shù) 名:unsigned char TaskComingNew(void)
  82. * 功能描述:方塊出新
  83. * 函數(shù)說明:
  84. * 輸入?yún)?shù):無
  85. * 返 回 值:ucResult，1成功，0失敗
  86. *******************************************************/
  87. unsigned char TaskComingNew(void)
  88. {
  89.         unsigned char ucCheck=0;
  90.         unsigned char ucResult=0;
  91.         //寫入當(dāng)前方塊的相關(guān)信息
  92.         switch(ucBlockNow)                                         
  93.         {
  94.                 case 0:
  95.                                 enumBlock=S1;
  96.                                 ucCoordinate[0]=4;
  97.                                 ucCoordinate[1]=0;
  98.                 break;
  99.                 case 1:
  100.                                 enumBlock=Z1;
  101.                                 ucCoordinate[0]=4;
  102.                                 ucCoordinate[1]=0;
  103.                 break;
  104.                 case 2:
  105.                                 enumBlock=L1;
  106.                                 ucCoordinate[0]=4;
  107.                                 ucCoordinate[1]=1;
  108.                 break;
  109.                 case 3:
  110.                                 enumBlock=J1;
  111.                                 ucCoordinate[0]=4;
  112.                                 ucCoordinate[1]=1;
  113.                 break;
  114.                 case 4:
  115.                                 enumBlock=I1;
  116.                                 ucCoordinate[0]=5;
  117.                                 ucCoordinate[1]=0;
  118.                 break;
  119.                 case 5:
  120.                                 enumBlock=O1;
  121.                                 ucCoordinate[0]=5;
  122.                                 ucCoordinate[1]=0;
  123.                 break;
  124.                 case 6:
  125.                                 enumBlock=T_1;
  126.                                 ucCoordinate[0]=4;
  127.                                 ucCoordinate[1]=0;
  128.                 break;
  129.                 default:
  130.                 break;
  131.         }
  132.         //檢測碰撞
  133.         WriteBlockCoordinate();        
  134.         ucCheck=TaskCheck();
  135.         if(ucCheck)                                                //成功
  136.         {
  137.                 ChangeSmallBlock(0);                //將預(yù)覽的方塊清除
  138.                 ucBlockNext=TL1%7;                        //產(chǎn)生隨機數(shù)，作為預(yù)覽方塊
  139.                 ChangeBlock(1);                         //畫新的方塊
  140.                 ChangeSmallBlock(1);                //畫新的預(yù)覽方塊
  141.                 ucBlockNow=ucBlockNext;
  142.                 ucResult=1;
  143.         }
  144.         else
  145.         {
  146.                 ucResult=0;
  147.         }

  149.         return ucResult;
  150. }
  151. /*******************************************************
  152. * 函 數(shù) 名:void TaskClear(void)
  153. * 功能描述:消除滿行
  154. * 函數(shù)說明:消除滿行，并出新
  155. * 輸入?yún)?shù):無
  156. * 返 回 值:無
  157. *******************************************************/
  158. void TaskClear(void)
  159. {
  160.         char i=0,j=0,n=0;
  161.         unsigned char m=0;
  162.         unsigned char k=0;
  163.         unsigned char flag_man=1,flag_kong=1,flag_clear=0;//滿行、空行、待清除標(biāo)志
  164.         unsigned char man[4],count=0;                                          //滿行位置數(shù)組，滿行數(shù)量
  165.         unsigned char kong=20;                                                          //空行位置
  166.         unsigned char oldkong=20;                                                  //用來儲存舊的空行位置

  168.         unsigned char ucResult=0;

  170.         //標(biāo)記出來滿行及第一個空行
  171.         for(i=19;i>=0;i--)
  172.         {
  173.                 for(j=9;j>=0;j--)
  174.                 {
  175.                         if(ucxMap[j][i]==0)
  176.                         {
  177.                                 flag_man=0;
  178.                         }
  179.                         else
  180.                         {
  181.                                 flag_kong=0;
  182.                         }
  183.                 }
  184.                 if(flag_man==1)
  185.                 {
  186.                         flag_clear=1;//激活消除標(biāo)記
  187.                         man[k]=i;//標(biāo)記滿行
  188.                         count++;
  189.                         k++;
  190.                 }
  191.                 else if(flag_kong==1)
  192.                 {
  193.                          kong=i;
  194.                         break;//檢測到第一個空行，就退出循環(huán)
  195.                 }
  196.                 flag_man=1;//將滿行標(biāo)志復(fù)位
  197.                 flag_kong=1;
  198.         }

  200.         //計分
  201.         switch(count)
  202.         {
  203.                 case 0:
  204.                                 ucScore=ucScore+100;
  205.                                 break;
  206.                 case 1:
  207.                                 ucScore=ucScore+200;
  208.                                 break;
  209.                 case 2:
  210.                                 ucScore=ucScore+400;
  211.                                 break;
  212.                 case 3:
  213.                                 ucScore=ucScore+700;
  214.                                 break;
  215.                 case 4:
  216.                                 ucScore=ucScore+1100;
  217.                                 break;
  218.                 default:
  219.                                 break;
  220.         }

  222.         oldkong=kong;
  223.         //消除滿行
  224.         if(flag_clear==1)
  225.         {
  226.                 while(count!=0)//至少有一個滿行，才進行消除
  227.                 {
  228.                         //逐行下移
  229.                         for(m=0;m<man[count-1]-kong-1;m++)
  230.                         {
  231.                                 for(n=9;n>=0;n--)
  232.                                 {
  233.                                         ucxMap[n][man[count-1]-m]=ucxMap[n][man[count-1]-m-1];        
  234.                                 }
  235.                         }
  236.                         //最上行清空
  237.                         for(n=0;n<10;n++)
  238.                         {
  239.                                 ucxMap[n][kong+1]=0;        
  240.                         }

  242.                         kong++;
  243.                         count--;
  244.                 }
  245.                 ChangeMap(oldkong-1,man[0]); //寫入當(dāng)前Map，只寫有改變的行，加快顯示速度
  246.         }

  248.         //將分?jǐn)?shù)寫入屏幕
  249.         TaskScore();
  250.         //出新的方塊
  251.         ucResult=TaskComingNew();
  252.         //如果失敗，就進入失敗界面
  253.         if(ucResult==0)
  254.         {
  255.                 uc_state=4;
  256.                 ucFlagScreenChange=1;
  257.         }
  258. }
復(fù)制代碼

評分

參與人數(shù) 7黑幣 +46 收起 理由
adminhh + 12 很給力！
分經(jīng)濟 + 5 太強了，膜拜，哈哈
周超然 + 5 絕世好帖！
stkh + 5 很給力！
踏步如云 + 5 很給力！
蘇眉ZH + 2 贊一個！
zhaok2013 + 12 絕世好帖！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏35 分享淘帖 頂頂6 踩踩
回復(fù)

使用道具 舉報

沙發(fā)
ID:130231 發(fā)表于 2017-3-17 19:41 | 只看該作者
太厲害了
回復(fù)

使用道具 舉報

板凳
ID:162136 發(fā)表于 2017-3-18 09:45 | 只看該作者
這個要支持。正打算用匯編寫這個
回復(fù)

使用道具 舉報

地板
ID:143525 發(fā)表于 2017-5-4 10:18 | 只看該作者
謝謝分享!!!!1
回復(fù)

使用道具 舉報

5#
ID:199694 發(fā)表于 2017-5-15 15:51 | 只看該作者
這個io口怎么改？能不能詳細(xì)說下
回復(fù)

使用道具 舉報

6#
ID:99130 發(fā)表于 2017-6-28 19:01 | 只看該作者
編譯過不了，
回復(fù)

使用道具 舉報

7#
ID:99130 發(fā)表于 2017-6-30 16:28 | 只看該作者
花屏有點嚴(yán)重啊 為什么圖里的很清楚？？怎么解決
回復(fù)

使用道具 舉報

8#
ID:209954 發(fā)表于 2017-7-2 22:04 來自觸屏版 | 只看該作者
越快樂越墮落 發(fā)表于 2017-6-30 16:28
花屏有點嚴(yán)重啊 為什么圖里的很清楚？？怎么解決

圖里用的晶振是11兆的，如果你用的晶振是12兆的就要修改延時，否則可能會花屏。
回復(fù)

使用道具 舉報

9#
ID:223554 發(fā)表于 2017-7-31 14:06 | 只看該作者
積分不夠
回復(fù)

使用道具 舉報

10#
ID:216536 發(fā)表于 2017-8-1 08:34 | 只看該作者
學(xué)習(xí)學(xué)習(xí)
回復(fù)

使用道具 舉報

11#
ID:231984 發(fā)表于 2017-11-23 19:36 | 只看該作者
鎖存器用的什么型號的呢？
回復(fù)

使用道具 舉報

12#
ID:266764 發(fā)表于 2017-12-26 19:35 | 只看該作者
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳
回復(fù)

使用道具 舉報

13#
ID:166341 發(fā)表于 2017-12-28 16:17 | 只看該作者
孤狼131 發(fā)表于 2017-12-26 19:35
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

控制數(shù)碼管的段選與位選鎖存器的
回復(fù)

使用道具 舉報

14#
ID:266764 發(fā)表于 2017-12-28 23:17 | 只看該作者
Jerry0925 發(fā)表于 2017-12-28 16:17
控制數(shù)碼管的段選與位選鎖存器的

那你知道這個鎖存器是哪個型號的嗎
回復(fù)

使用道具 舉報

15#
ID:224487 發(fā)表于 2018-1-5 00:33 | 只看該作者
按照接線連好單片機，為什么進入界面后無法運行，只有一個邊框。本人剛接觸單片機，還有很多不懂
回復(fù)

使用道具 舉報

16#
ID:196311 發(fā)表于 2018-1-7 21:34 | 只看該作者
樓主很強大，下載學(xué)習(xí)下算法，謝謝分享
回復(fù)

使用道具 舉報

17#
ID:273035 發(fā)表于 2018-1-8 09:28 來自觸屏版 | 只看該作者
學(xué)習(xí)學(xué)習(xí)
回復(fù)

使用道具 舉報

18#
ID:228939 發(fā)表于 2018-1-15 21:13 | 只看該作者
坐等超級瑪麗
回復(fù)

使用道具 舉報

19#
ID:288471 發(fā)表于 2018-3-6 22:57 | 只看該作者
高手啊  不錯��！
回復(fù)

使用道具 舉報

20#
ID:306312 發(fā)表于 2018-4-12 08:20 | 只看該作者
感謝樓主的無私奉獻，給了我很大的啟發(fā)
回復(fù)

使用道具 舉報

21#
ID:319242 發(fā)表于 2018-5-2 22:39 | 只看該作者
感謝分享代碼，經(jīng)測試能夠運行，但是移植到串行12864模塊上很難，單片機RAM太小，無法緩存所有屏幕點陣，而并口LCD則可以直接讀取屏幕內(nèi)容。
回復(fù)

使用道具 舉報

22#
ID:59433 發(fā)表于 2018-5-2 23:29 | 只看該作者
給個元器件電路圖咯  謝謝
回復(fù)

使用道具 舉報

23#
ID:320508 發(fā)表于 2018-11-29 14:22 | 只看該作者
好帖收藏一波
回復(fù)

使用道具 舉報

24#
ID:20468 發(fā)表于 2018-11-29 19:41 | 只看該作者
這是好資料
回復(fù)

使用道具 舉報

25#
ID:445953 發(fā)表于 2018-12-13 20:31 | 只看該作者
厲害厲害，支持一波
回復(fù)

使用道具 舉報

26#
ID:3802 發(fā)表于 2019-1-25 14:31 | 只看該作者
太厲害了
回復(fù)

使用道具 舉報

27#
ID:479216 發(fā)表于 2019-2-22 11:00 來自觸屏版 | 只看該作者
樓主有沒有更詳細(xì)的資料啊，要買啥，焊哪里
回復(fù)

使用道具 舉報

28#
ID:479299 發(fā)表于 2019-2-23 01:33 | 只看該作者
mark!mark!mark!mark!
回復(fù)

使用道具 舉報

29#
ID:414624 發(fā)表于 2019-4-10 16:24 | 只看該作者
DB0-DB7是P0口嗎，那要上啦電阻輸出嗎
回復(fù)

使用道具 舉報

30#
ID:533791 發(fā)表于 2019-5-12 00:27 來自觸屏版 | 只看該作者
孤狼131 發(fā)表于 2017-12-26 19:35
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

我用的也是清翔的開發(fā)板，想請問你這個子程序到底怎么弄啊。我萌新，這個復(fù)制過去編譯都過不了
回復(fù)

使用道具 舉報

31#
ID:538436 發(fā)表于 2019-5-14 22:42 | 只看該作者
萌新求一下資料 么有幣。。
回復(fù)

使用道具 舉報

32#
ID:634589 發(fā)表于 2019-11-2 23:07 | 只看該作者
哇�。。∵@個才是硬核�。。�！
回復(fù)

使用道具 舉報

33#
ID:625113 發(fā)表于 2019-11-26 09:29 來自觸屏版 | 只看該作者
大佬大佬，來學(xué)習(xí)學(xué)習(xí)
回復(fù)

使用道具 舉報

34#
ID:663957 發(fā)表于 2019-12-28 10:40 | 只看該作者
linlexiao 發(fā)表于 2019-5-12 00:27
我用的也是清翔的開發(fā)板，想請問你這個子程序到底怎么弄啊。我萌新，這個復(fù)制過去編譯都過不了

所以到底怎么搞啊
回復(fù)

使用道具 舉報

35#
ID:59884 發(fā)表于 2020-1-6 19:54 | 只看該作者
謝謝樓主分享！
回復(fù)

使用道具 舉報

36#
ID:669226 發(fā)表于 2020-1-24 19:30 | 只看該作者
感謝分享�。�！
回復(fù)

使用道具 舉報

37#
ID:185815 發(fā)表于 2020-2-4 21:25 | 只看該作者
感謝分享了，困家里沒事做，D一個
回復(fù)

使用道具 舉報

38#
ID:614068 發(fā)表于 2020-2-5 18:23 | 只看該作者
謝謝樓主分享，這個算是大型程序了，值得我學(xué)習(xí)啊。
回復(fù)

使用道具 舉報

39#
ID:624009 發(fā)表于 2020-2-10 21:44 | 只看該作者
謝謝分享，樓主太厲害了
回復(fù)

使用道具 舉報

40#
ID:808771 發(fā)表于 2020-8-24 09:31 | 只看該作者
感謝樓主的分享，稍后自己也試試看
回復(fù)

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機教程網(wǎng)

快速回復(fù) 返回頂部 返回列表