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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 原创51单片机俄罗斯方块程序 12864屏显示 代码有详细注 ...
返回列表 发新帖
查看: 25653|回复: 39
打印 上一主题 下一主题
收起左侧

原创51单片机俄罗斯方块程序 12864屏显示 代码有详细注释

  [复制链接]
跳转到指定楼层
楼主
ID:140725 发表于 2017-3-6 03:46 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
给51黑电子论坛的朋友们分享一个很优秀的俄罗斯方块程序，lcd12864屏幕 是用普通的51单片机做的，P3.4口，短按就可以开始运行了。效果如下图所示：

完整的源码下载：
俄罗斯方块全部源码.zip (147.88 KB, 下载次数: 599)



Tetris.c源程序文件内容：
  1. /*******************************************************
  2. * 文件名称：Tetris.c
  3. * 单 片 机：STC89C52RC
  4. * 简    述：使用LCD12864显示的俄罗斯方块程序
  5. * 功    能：计分，下一个方块预览，欢迎结束界面，长按连续左右移，暂停（按键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.                         数码管锁存器
  20.                         sbit dula=P2^6;
  21.                         sbit wela=P2^7;

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

  25. /*****************************头文件区*****************************************************/
  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. /*****************************宏定义区*****************************************************/

  35. //需要判断是否刷新的任务总数
  36. //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
  37. #define NUM_TASK_FLAG 7
  38. //需要定时刷新的任务总数
  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. /******************************子函数声明区***********************************************/

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

  53. /******************************全局变量定义区***********************************************/
  54. unsigned char uc_state=1;//状态标示: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. /******************************主函数开始***********************************************/
  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.                                 //调用消除方块函数
  103.                                 TaskClear();
  104.                         }
  105.                         ET0=0;//在中断中也有可能变化的变量在更改前时先关闭中断
  106.                         uc_delay_task_cnt[1]=TIME_TASKGOINGDOWN_2HZ;//延迟重置
  107.                         ET0=1;
  108.                 }

  110.         }
  111. }

  113. //中断函数
  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时，相应的函数准备就绪
  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();//按键扫描函数，放在中断中，保证准时扫描
  127.         TR0=1;
  128. }

  130. //初始化区
  131. void initial_myself(void)//第一区 初始化单片机
  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位自动重装，用来产生随机数
  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) //第二区 初始化外围
  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.                                 //将地图数据清空
  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秒钟的时间需要的定时中断次数
  10. //#define const_time_0_5s     222   //0.5秒钟的时间需要的定时中断次数

  12. #define const_time_0_25s  60   //0.125秒钟的时间需要的定时中断次数
  13. #define const_time_0_5s     60   //0.125秒钟的时间需要的定时中断次数


  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;   //被触发的按键编号

  23. unsigned int  uiKeyTimeCnt_left=0; //按键去抖动延时计数器
  24. unsigned int  uiKeyCtntyCnt_left=0; //按键连续触发的间隔延时计数器
  25. unsigned char ucKeyLock_left=0; //按键触发后自锁的变量标志

  27. unsigned int  uiKeyTimeCnt_turn=0; //按键去抖动延时计数器
  28. //unsigned int  uiKeyCtntyCnt_turn=0; //按键连续触发的间隔延时计数器
  29. unsigned char ucKeyLock_turn=0; //按键触发后自锁的变量标志

  31. unsigned int  uiKeyTimeCnt_right=0; //按键去抖动延时计数器
  32. unsigned int  uiKeyCtntyCnt_right=0; //按键连续触发的间隔延时计数器
  33. unsigned char ucKeyLock_right=0; //按键触发后自锁的变量标志

  35. unsigned int  uiKeyTimeCnt_down=0; //按键去抖动延时计数器
  36. unsigned char ucKeyLock_down=0; //按键触发后自锁的变量标志

  38. unsigned int  uiKeyTimeCnt_pause=0; //按键去抖动延时计数器
  39. unsigned char ucKeyLock_pause=0; //按键触发后自锁的变量标志

  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;    //触发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;    //触发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;    //触发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;    //触发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;    //触发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;//按键去抖动延时计数器清零   
  136.                  }
  137.             else if(ucKeyLock_down==0)//有按键按下，且是第一次被按下，并且当前界面支持这个按键
  138.                  {
  139.                      uiKeyTimeCnt_down++; //累加定时中断次数
  140.                           if(uiKeyTimeCnt_down>CONST_KEY_TIME)
  141.                      {
  142.                         uiKeyTimeCnt_down=0;
  143.                         ucKeyLock_down=1;  //自锁按键置位,避免一直触发
  144.                         ucKeySec=4;    //触发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;//按键去抖动延时计数器清零      
  155.           }
  156.                 else if(ucKeyLock_pause==0)//有按键按下，且是第一次被按下
  157.                 {
  158.                     uiKeyTimeCnt_pause++; //累加定时中断次数
  159.                     if(uiKeyTimeCnt_pause>CONST_KEY_TIME)
  160.                     {
  161.                             uiKeyTimeCnt_pause=0;
  162.                         ucKeyLock_pause=1;  //自锁按键置位,避免一直触发
  163.                     ucKeySec=6;    //触发6号键，暂停
  164.                     }
  165.                 }
  166.         }
  167. }

  169. //按键服务函数
  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) //按键服务状态切换
  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.                                 //根据所处界面不同，按键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                                                //循环模拟下落并检测，直到失败
  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. * 函 数 名:TaskCheck(void)
  15. * 功能描述:检测
  16. * 函数说明:检测左右移，下落，出新，旋转
  17. * 输入参数:无
  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. * 函 数 名:unsigned char TaskGoingDown(void)
  52. * 功能描述:方块下落
  53. * 函数说明:
  54. * 输入参数:无
  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();                        //将其他三个小方块坐标写入数组
  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. * 函 数 名:unsigned char TaskComingNew(void)
  82. * 功能描述:方块出新
  83. * 函数说明:
  84. * 输入参数:无
  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;                        //产生随机数，作为预览方块
  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. * 函 数 名:void TaskClear(void)
  153. * 功能描述:消除满行
  154. * 函数说明:消除满行，并出新
  155. * 输入参数:无
  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;                                          //满行位置数组，满行数量
  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;//检测到第一个空行，就退出循环
  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.         //将分数写入屏幕
  249.         TaskScore();
  250.         //出新的方块
  251.         ucResult=TaskComingNew();
  252.         //如果失败，就进入失败界面
  253.         if(ucResult==0)
  254.         {
  255.                 uc_state=4;
  256.                 ucFlagScreenChange=1;
  257.         }
  258. }
复制代码

俄罗斯方块, 源码下载, 单片机, 数码管, 源程序

评分

参与人数 7黑币 +46 收起 理由
adminhh + 12 很给力！
分经济 + 5 太强了，膜拜，哈哈
周超然 + 5 绝世好帖！
stkh + 5 很给力！
踏步如云 + 5 很给力！
苏眉ZH + 2 赞一个！
zhaok2013 + 12 绝世好帖！

查看全部评分

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

相关帖子
回复

使用道具 举报

沙发
ID:130231 发表于 2017-3-17 19:41 | 只看该作者
太厉害了
回复

使用道具 举报

板凳
ID:162136 发表于 2017-3-18 09:45 | 只看该作者
这个要支持。正打算用汇编写这个
回复

使用道具 举报

地板
ID:143525 发表于 2017-5-4 10:18 | 只看该作者
谢谢分享!!!!1
回复

使用道具 举报

5#
ID:199694 发表于 2017-5-15 15:51 | 只看该作者
这个io口怎么改？能不能详细说下
回复

使用道具 举报

6#
ID:99130 发表于 2017-6-28 19:01 | 只看该作者
编译过不了，
回复

使用道具 举报

7#
ID:99130 发表于 2017-6-30 16:28 | 只看该作者
花屏有点严重啊 为什么图里的很清楚？？怎么解决
回复

使用道具 举报

8#
ID:209954 发表于 2017-7-2 22:04 来自触屏版 | 只看该作者
越快乐越堕落 发表于 2017-6-30 16:28
花屏有点严重啊 为什么图里的很清楚？？怎么解决

图里用的晶振是11兆的，如果你用的晶振是12兆的就要修改延时，否则可能会花屏。
回复

使用道具 举报

9#
ID:223554 发表于 2017-7-31 14:06 | 只看该作者
积分不够
回复

使用道具 举报

10#
ID:216536 发表于 2017-8-1 08:34 | 只看该作者
学习学习
回复

使用道具 举报

11#
ID:231984 发表于 2017-11-23 19:36 | 只看该作者
锁存器用的什么型号的呢？
回复

使用道具 举报

12#
ID:266764 发表于 2017-12-26 19:35 | 只看该作者
我用清翔的开发板，其他引脚都改好了，但是dula=P2^6和wela=P2^7是什么东西的引脚
回复

使用道具 举报

13#
ID:166341 发表于 2017-12-28 16:17 | 只看该作者
孤狼131 发表于 2017-12-26 19:35
我用清翔的开发板，其他引脚都改好了，但是dula=P2^6和wela=P2^7是什么东西的引脚

控制数码管的段选与位选锁存器的
回复

使用道具 举报

14#
ID:266764 发表于 2017-12-28 23:17 | 只看该作者
Jerry0925 发表于 2017-12-28 16:17
控制数码管的段选与位选锁存器的

那你知道这个锁存器是哪个型号的吗
回复

使用道具 举报

15#
ID:224487 发表于 2018-1-5 00:33 | 只看该作者
按照接线连好单片机，为什么进入界面后无法运行，只有一个边框。本人刚接触单片机，还有很多不懂
回复

使用道具 举报

16#
ID:196311 发表于 2018-1-7 21:34 | 只看该作者
楼主很强大，下载学习下算法，谢谢分享
回复

使用道具 举报

17#
ID:273035 发表于 2018-1-8 09:28 来自触屏版 | 只看该作者
学习学习
回复

使用道具 举报

18#
ID:228939 发表于 2018-1-15 21:13 | 只看该作者
坐等超级玛丽
回复

使用道具 举报

19#
ID:288471 发表于 2018-3-6 22:57 | 只看该作者
高手啊  不错！！
回复

使用道具 举报

20#
ID:306312 发表于 2018-4-12 08:20 | 只看该作者
感谢楼主的无私奉献，给了我很大的启发
回复

使用道具 举报

21#
ID:319242 发表于 2018-5-2 22:39 | 只看该作者
感谢分享代码，经测试能够运行，但是移植到串行12864模块上很难，单片机RAM太小，无法缓存所有屏幕点阵，而并口LCD则可以直接读取屏幕内容。
回复

使用道具 举报

22#
ID:59433 发表于 2018-5-2 23:29 | 只看该作者
给个元器件电路图咯  谢谢
回复

使用道具 举报

23#
ID:320508 发表于 2018-11-29 14:22 | 只看该作者
好帖收藏一波
回复

使用道具 举报

24#
ID:20468 发表于 2018-11-29 19:41 | 只看该作者
这是好资料
回复

使用道具 举报

25#
ID:445953 发表于 2018-12-13 20:31 | 只看该作者
厉害厉害，支持一波
回复

使用道具 举报

26#
ID:3802 发表于 2019-1-25 14:31 | 只看该作者
太厉害了
回复

使用道具 举报

27#
ID:479216 发表于 2019-2-22 11:00 来自触屏版 | 只看该作者
楼主有没有更详细的资料啊，要买啥，焊哪里
回复

使用道具 举报

28#
ID:479299 发表于 2019-2-23 01:33 | 只看该作者
mark!mark!mark!mark!
回复

使用道具 举报

29#
ID:414624 发表于 2019-4-10 16:24 | 只看该作者
DB0-DB7是P0口吗，那要上啦电阻输出吗
回复

使用道具 举报

30#
ID:533791 发表于 2019-5-12 00:27 来自触屏版 | 只看该作者
孤狼131 发表于 2017-12-26 19:35
我用清翔的开发板，其他引脚都改好了，但是dula=P2^6和wela=P2^7是什么东西的引脚

我用的也是清翔的开发板，想请问你这个子程序到底怎么弄啊。我萌新，这个复制过去编译都过不了
回复

使用道具 举报

31#
ID:538436 发表于 2019-5-14 22:42 | 只看该作者
萌新求一下资料 么有币。。
回复

使用道具 举报

32#
ID:634589 发表于 2019-11-2 23:07 | 只看该作者
哇！！！这个才是硬核！！！！
回复

使用道具 举报

33#
ID:625113 发表于 2019-11-26 09:29 来自触屏版 | 只看该作者
大佬大佬，来学习学习
回复

使用道具 举报

34#
ID:663957 发表于 2019-12-28 10:40 | 只看该作者
linlexiao 发表于 2019-5-12 00:27
我用的也是清翔的开发板，想请问你这个子程序到底怎么弄啊。我萌新，这个复制过去编译都过不了

所以到底怎么搞啊
回复

使用道具 举报

35#
ID:59884 发表于 2020-1-6 19:54 | 只看该作者
谢谢楼主分享！
回复

使用道具 举报

36#
ID:669226 发表于 2020-1-24 19:30 | 只看该作者
感谢分享！！！
回复

使用道具 举报

37#
ID:185815 发表于 2020-2-4 21:25 | 只看该作者
感谢分享了，困家里没事做，D一个
回复

使用道具 举报

38#
ID:614068 发表于 2020-2-5 18:23 | 只看该作者
谢谢楼主分享，这个算是大型程序了，值得我学习啊。
回复

使用道具 举报

39#
ID:624009 发表于 2020-2-10 21:44 | 只看该作者
谢谢分享，楼主太厉害了
回复

使用道具 举报

40#
ID:808771 发表于 2020-8-24 09:31 | 只看该作者
感谢楼主的分享，稍后自己也试试看
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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