久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

標題: 原創(chuàng)51單片機俄羅斯方塊程序 12864屏顯示 代碼有詳細注釋 [打印本頁]
作者: 51hei學習技術中    時間: 2017-3-6 03:46
標題: 原創(chuàng)51單片機俄羅斯方塊程序 12864屏顯示 代碼有詳細注釋
給51黑電子論壇的朋友們分享一個很優(yōu)秀的俄羅斯方塊程序，lcd12864屏幕 是用普通的51單片機做的，P3.4口，短按就可以開始運行了。效果如下圖所示：

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



Tetris.c源程序文件內容：
  1. /*******************************************************
  2. * 文件名稱：Tetris.c
  3. * 單 片 機：STC89C52RC
  4. * 簡    述：使用LCD12864顯示的俄羅斯方塊程序
  5. * 功    能：計分，下一個方塊預覽，歡迎結束界面，長按連續(xù)左右移，暫停（按鍵Left+Turn）
  6. * 作    者：劉琦
  7. * 完成日期：4月21日
  8. * IO口設定：按鍵
  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. //需要判斷是否刷新的任務總數(shù)
  36. //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  37. #define NUM_TASK_FLAG 7
  38. //需要定時刷新的任務總數(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          //按鍵服務頻率，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)標示: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;//當前方塊
  57. unsigned char ucBlockNext=0;//下一個方塊

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

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

  65. unsigned int uc_delay_task_cnt[NUM_TASK_REFRESH];//任務刷新延遲
  66. unsigned char uc_flag_taskrefresh[NUM_TASK_FLAG];//任務刷新標志

  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)//界面變更標志為1時，進行任務激活，防止一直刷新界面
  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;//在中斷中也有可能變化的變量在更改前時先關閉中斷
  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.                                 //將當前方塊位置寫入Map
  98.                                 for(i=0;i<4;i++)
  99.                                 {
  100.                                         ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]=1;
  101.                                 }
  102.                                 //調用消除方塊函數(shù)
  103.                                 TaskClear();
  104.                         }
  105.                         ET0=0;//在中斷中也有可能變化的變量在更改前時先關閉中斷
  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時，相應的函數(shù)準備就緒
  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ù)，放在中斷中，保證準時掃描
  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;//初始化讓所有任務就緒
  135.         TMOD=0X21; //定時器0為16位不自動重裝，用來定時；定時器1為8位自動重裝，用來產生隨機數(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. }
復制代碼
  1. /*******************************************************
  2. * 文件名稱：task_activation.c
  3. * 單 片 機：STC89C52RC
  4. * 簡    述：任務激活子程序，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.                         //當前界面需要刷新的任務
  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.                         //當前界面需要刷新的任務
  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.                         //當前界面需要刷新的任務
  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.                         //當前界面需要刷新的任務
  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.                         //當前界面需要刷新的任務
  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. }
復制代碼
  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ā)后自鎖的變量標志

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

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

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

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

  41. //放在中斷中，其中的每個按鍵的標志位為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; //按鍵自鎖標志清零
  135.                      uiKeyTimeCnt_down=0;//按鍵去抖動延時計數(shù)器清零   
  136.                  }
  137.             else if(ucKeyLock_down==0)//有按鍵按下，且是第一次被按下，并且當前界面支持這個按鍵
  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，按鍵左和按鍵旋轉未同時按下
  152.           {
  153.                  ucKeyLock_pause=0; //按鍵自鎖標志清零
  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. //按鍵服務函數(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) //按鍵服務狀態(tài)切換
  177.           {
  178.             case 1:// 1號鍵,left
  179.                                 ucCoordinate[0]++;                                //旋轉點坐標H+1
  180.                                 WriteBlockCoordinate();                        //寫入其他3個方塊坐標
  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)                                //旋轉后改變方塊編號
  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;                //準備進入等待界面，就先產生當前隨機方塊
  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;//關閉計時器0，出新后開啟，防止直接下落
  309.                                                         ChangeBlock(0);                 //先清除當前的圖形
  310.                                                         do                                                //循環(huán)模擬下落并檢測，直到失敗
  311.                                                         {
  312.                                                                 ucCoordinate[1]++;
  313.                                                                 WriteBlockCoordinate();
  314.                                                                 ucCheck=TaskCheck();
  315.                                                         }
  316.                                                         while(ucCheck);
  317.                                                         ucCoordinate[1]--;                //恢復到最后一次成功的坐標
  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.                                                         //調用消除
  328.                                                         TaskClear();
  329.                                                         //刷新下落延遲，防止出新后，直接下落
  330.                                                         ET0=1;
  331.                                         break;
  332.                                         case 4:        //死亡界面
  333.                                                         ucBlockNow=TL1%7;                //準備進入等待界面，就先產生當前隨機方塊
  334.                                                         uc_state=2;                                 //進入等待界面
  335.                                                         ucFlagScreenChange=1;
  336.                                         break;
  337.                                         case 5:        //暫停界面
  338.                                                         uc_state=3;                                //進入下落界面
  339.                                                         //開啟下落界面時的相關任務
  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. }
復制代碼
  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ù)說明:檢測左右移，下落，出新，旋轉
  17. * 輸入參數(shù):無
  18. * 返 回 值:成功失敗標示，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)//與地圖標記位置進行比較
  43.                 {
  44.                         ucReturn=0;
  45.                         return ucReturn;
  46.                 }
  47.         }
  48.         return ucReturn;
  49. }
  50. /*******************************************************
  51. * 函 數(shù) 名:unsigned char TaskGoingDown(void)
  52. * 功能描述:方塊下落
  53. * 函數(shù)說明:
  54. * 輸入參數(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]++;                                //旋轉點坐標，豎S+1
  62.         WriteBlockCoordinate();                        //將其他三個小方塊坐標寫入數(shù)組
  63.         ucCheck=TaskCheck();                        //檢測碰撞
  64.         if(ucCheck)                                                //無碰撞
  65.         {
  66.                 ucCoordinate[1]--;                        //坐標復位
  67.                 ChangeBlock(0);                                //在老位置消除方塊，只刷新有改變的位置，加快顯示速度
  68.                 ucCoordinate[1]++;                        //坐標+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. * 輸入參數(shù):無
  85. * 返 回 值:ucResult，1成功，0失敗
  86. *******************************************************/
  87. unsigned char TaskComingNew(void)
  88. {
  89.         unsigned char ucCheck=0;
  90.         unsigned char ucResult=0;
  91.         //寫入當前方塊的相關信息
  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);                //將預覽的方塊清除
  138.                 ucBlockNext=TL1%7;                        //產生隨機數(shù)，作為預覽方塊
  139.                 ChangeBlock(1);                         //畫新的方塊
  140.                 ChangeSmallBlock(1);                //畫新的預覽方塊
  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. * 輸入參數(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;//滿行、空行、待清除標志
  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.         //標記出來滿行及第一個空行
  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;//激活消除標記
  187.                         man[k]=i;//標記滿行
  188.                         count++;
  189.                         k++;
  190.                 }
  191.                 else if(flag_kong==1)
  192.                 {
  193.                          kong=i;
  194.                         break;//檢測到第一個空行，就退出循環(huán)
  195.                 }
  196.                 flag_man=1;//將滿行標志復位
  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]); //寫入當前Map，只寫有改變的行，加快顯示速度
  246.         }

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

作者: zqy181818    時間: 2017-3-17 19:41
太厲害了
作者: bayga456    時間: 2017-3-18 09:45
這個要支持。正打算用匯編寫這個
作者: 還是看不穿    時間: 2017-5-4 10:18
謝謝分享!!!!1
作者: 1197338529    時間: 2017-5-15 15:51
這個io口怎么改？能不能詳細說下
作者: 越快樂越墮落    時間: 2017-6-28 19:01
編譯過不了，
作者: 越快樂越墮落    時間: 2017-6-30 16:28
花屏有點嚴重啊 為什么圖里的很清楚？？怎么解決
作者: 15576118519    時間: 2017-7-2 22:04
越快樂越墮落 發(fā)表于 2017-6-30 16:28
花屏有點嚴重啊 為什么圖里的很清楚？？怎么解決

圖里用的晶振是11兆的，如果你用的晶振是12兆的就要修改延時，否則可能會花屏。
作者: 772740573    時間: 2017-7-31 14:06
積分不夠
作者: Lanny_1    時間: 2017-8-1 08:34
學習學習
作者: gaohan130    時間: 2017-11-23 19:36
鎖存器用的什么型號的呢？
作者: 孤狼131    時間: 2017-12-26 19:35
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳
作者: Jerry0925    時間: 2017-12-28 16:17
孤狼131 發(fā)表于 2017-12-26 19:35
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

控制數(shù)碼管的段選與位選鎖存器的
作者: 孤狼131    時間: 2017-12-28 23:17
Jerry0925 發(fā)表于 2017-12-28 16:17
控制數(shù)碼管的段選與位選鎖存器的

那你知道這個鎖存器是哪個型號的嗎
作者: dexter    時間: 2018-1-5 00:33
按照接線連好單片機，為什么進入界面后無法運行，只有一個邊框。本人剛接觸單片機，還有很多不懂
作者: jxdianqi    時間: 2018-1-7 21:34
樓主很強大，下載學習下算法，謝謝分享
作者: 攸央    時間: 2018-1-8 09:28
學習學習
作者: 孤獨求敗    時間: 2018-1-15 21:13
坐等超級瑪麗
作者: wafush    時間: 2018-3-6 22:57
高手啊  不錯！！
作者: 13lxw    時間: 2018-4-12 08:20
感謝樓主的無私奉獻，給了我很大的啟發(fā)
作者: mlpl    時間: 2018-5-2 22:39
感謝分享代碼，經測試能夠運行，但是移植到串行12864模塊上很難，單片機RAM太小，無法緩存所有屏幕點陣，而并口LCD則可以直接讀取屏幕內容。
作者: plaodj    時間: 2018-5-2 23:29
給個元器件電路圖咯  謝謝
作者: 山狼    時間: 2018-11-29 14:22
好帖收藏一波
作者: wangbo    時間: 2018-11-29 19:41
這是好資料
作者: 是迷麓麓Yai    時間: 2018-12-13 20:31
厲害厲害，支持一波
作者: qzyhlf    時間: 2019-1-25 14:31
太厲害了
作者: kadnn    時間: 2019-2-22 11:00
樓主有沒有更詳細的資料啊，要買啥，焊哪里
作者: 蹦蹦跳跳    時間: 2019-2-23 01:33
mark!mark!mark!mark!
作者: wyh_3069    時間: 2019-4-10 16:24
DB0-DB7是P0口嗎，那要上啦電阻輸出嗎
作者: linlexiao    時間: 2019-5-12 00:27
孤狼131 發(fā)表于 2017-12-26 19:35
我用清翔的開發(fā)板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

我用的也是清翔的開發(fā)板，想請問你這個子程序到底怎么弄啊。我萌新，這個復制過去編譯都過不了
作者: 一只大狐貍    時間: 2019-5-14 22:42
萌新求一下資料 么有幣。。
作者: 啊啊啊單片機    時間: 2019-11-2 23:07
哇！！！這個才是硬核！！！！
作者: luozhao    時間: 2019-11-26 09:29
大佬大佬，來學習學習
作者: LazyRise    時間: 2019-12-28 10:40
linlexiao 發(fā)表于 2019-5-12 00:27
我用的也是清翔的開發(fā)板，想請問你這個子程序到底怎么弄啊。我萌新，這個復制過去編譯都過不了

所以到底怎么搞啊
作者: 盛世游龍    時間: 2020-1-6 19:54
謝謝樓主分享！
作者: Swagger8    時間: 2020-1-24 19:30
感謝分享！！！
作者: 老河口    時間: 2020-2-4 21:25
感謝分享了，困家里沒事做，D一個
作者: abcd5690    時間: 2020-2-5 18:23
謝謝樓主分享，這個算是大型程序了，值得我學習啊。
作者: cdong58    時間: 2020-2-10 21:44
謝謝分享，樓主太厲害了
作者: 青箜    時間: 2020-8-24 09:31
感謝樓主的分享，稍后自己也試試看



歡迎光臨 (http://www.zg4o1577.cn/bbs/) Powered by Discuz! X3.1
主站蜘蛛池模板： 国产日韩精品在线 | 午夜激情免费视频 | 97碰碰碰 | 午夜不卡福利视频 | 日本一区二区高清不卡 | 成人a网 | 色偷偷888欧美精品久久久 | 成人欧美一区二区三区色青冈 | 91手机精品视频 | 在线观看亚洲欧美 | 成人免费看片又大又黄 | 亚洲精品在线视频 | 天天拍天天色 | 国产亚洲一区二区三区在线观看 | 日韩精品一区二区三区四区 | 一区| 69热视频在线观看 | 中文字幕视频在线观看 | 欧美8一10sex性hd | 日韩精品在线播放 | 97av视频在线 | 色吊丝在线 | 日韩高清中文字幕 | 欧美一级久久 | 亚洲美女在线一区 | 久久久久国产精品午夜一区 | 午夜在线视频 | 精品99在线 | 噜噜噜噜狠狠狠7777视频 | 91性高湖久久久久久久久_久久99 | 国产我和子的乱视频网站 | 狠狠干狠狠操 | 91色在线视频 | 凹凸日日摸日日碰夜夜 | 国产精品永久免费 | 欧美一区两区 | 天天操天天干天天曰 | 国产精品久久国产精品久久 | 欧美一区二区视频 | 久国产视频 | 精品久久一 |