标题: 51单片机+LCD12864做的贪食蛇和俄罗斯方块小游戏分享 [打印本页]
作者: 51黑sun    时间: 2016-7-7 04:52
标题: 51单片机+LCD12864做的贪食蛇和俄罗斯方块小游戏分享
贪食蛇和俄罗斯方块的单片机制作




  1. //12864并行接口参考程序，控制器st7920  
  2. #include "reg52.h"
  3. #include "Lcd12864.h"
  4. #include "Key.h"
  5. #define uchar unsigned char
  6. #define uint unsigned int

  8. static unsigned long Seed = 1;
  9. #define A 48271L
  10. #define M 2147483647L
  11. #define Q (M / A)
  12. #define R (M % A)
  13. /************************************
  14. 伪随机数发生器
  15. *************************************/
  16. double Random(void)
  17. {
  18.         long TmpSeed;
  19.         TmpSeed=A*(Seed%Q)-R*(Seed/Q);
  20.         if(TmpSeed>=0)
  21.                 Seed=TmpSeed;
  22.         else
  23.                 Seed=TmpSeed+M;
  24.         return (double)Seed/M;
  25. }

  27. /**************************************
  28. 为伪随机数发生器播种
  29. ***************************************/
  30. void InitRandom(unsigned long InitVal)
  31. {
  32.         Seed=InitVal;
  33. }

  35. //延时子程序
  36. void Delay(unsigned int t)
  37. {  
  38.         unsigned int i,j;
  39.         for(i=0;i<t;i++)
  40.                 for(j=0;j<10;j++);   
  41. }

  43. #define LGOU 0
  44. #define RGOU 1
  45. #define RZ        2
  46. #define LZ        3
  47. #define T        4
  48. #define GUN 5
  49. #define BOX 6
  50. unsigned int idata num[19+2]={
  51. 0xfff,//第1行，最下面
  52. 0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,
  53. 0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,//第2行到第20行共19行
  54. 0xfff//第21行，最上面

  56. };//定义共21行，其中num[0]为下墙壁行，num[20]为上墙壁行,每行12格，最左一格为左墙壁列，最右一格为右墙壁列
  57. unsigned char code Block[28][2]={
  58. /*
  59. *   口     口口口   口口
  60. *   口     口         口      口
  61. *   口口              口  口口口      
  62. */
  63. {0x88,0xc0},{0xe8,0x00},{0x62,0x20},{0x02,0xe0},
  64. /*
  65. *   口        口口 口口口
  66. *   口 口     口       口
  67. * 口口 口口口 口   
  68. */
  69. {0x22,0x60},{0x08,0xe0},{0xc8,0x80},{0xe2,0x00},  
  70. /*
  71. *   口
  72. *   口口         口口
  73. *     口       口口
  74. */
  75. {0x8c,0x40},{0x6c,0x00},{0x8c,0x40},{0x6c,0x00},
  76. /*
  77. *   口        口口
  78. * 口口          口口
  79. * 口
  80. */
  81. {0x4c,0x80},{0xc6,0x00},{0x4c,0x80},{0xc6,0x00},  
  82. /*
  83. *          口                口
  84. *   口     口口   口口口   口口
  85. * 口口口   口       口       口
  86. */
  87. {0x04,0xe0},{0x8c,0x80},{0xe4,0x00},{0x26,0x20},
  88. /*口
  89. * 口
  90. * 口       口口口口
  91. * 口
  92. */
  93. {0x44,0x44},{0x0f,0x00},{0x44,0x44},{0x0f,0x00},  
  94. /*
  95. * 口口
  96. * 口口
  97. */  
  98. {0x06,0x60},{0x06,0x60},{0x06,0x60},{0x06,0x60}
  99. };

  101. #define PASSSCORE 20
  102. struct Jimu
  103. {
  104.         unsigned int dat;
  105.          char x;
  106.         unsigned char y;
  107.         unsigned char type;
  108.         unsigned char change;
  109. }Sign[3];//积木结构体

  111. unsigned char SysFlag=0;
  112. #define NEWSIGNFLAG 0
  113. #define DEADFLAG 1
  114. #define PAUSEFLAG 2

  116. unsigned char Score=0;
  117. unsigned char Level=1;
  118. unsigned char DelayCnt=5;
  119. unsigned char KeyBuffer=0;
  120. #define RESEVER 1
  121. #define CHANGE 2
  122. #define DOWN 3
  123. #define LEFT 4
  124. #define RIGHT 5
  125. #define PAUSE 6

  127. /*********************************
  128. 初始化MPU
  129. **********************************/
  130. void InitCpu(void)
  131. {
  132.         TMOD=0x0;
  133.         TH0=0;
  134.         TL0=0;
  135.         TR0=1;
  136.         ET0=1;
  137.         EA=1;
  138. }

  140. /*****************************
  141. 定时中断服务子程序
  142. ******************************/
  143. void Timer0Int(void) interrupt 1
  144. {
  145.         switch(OSReadKey())
  146.         {
  147.                 case 9:
  148.                                 KeyBuffer=PAUSE;
  149.                                 break;
  150.                 case 13:
  151.                                 KeyBuffer=CHANGE;
  152.                                 break;
  153.                 case 17:
  154.                                 KeyBuffer=DOWN;
  155.                                 break;
  156.                 case 21:
  157.                                 KeyBuffer=RIGHT;
  158.                                 break;
  159.                    case 25:
  160.                                 KeyBuffer=LEFT;
  161.                                 break;
  162.                 default:
  163.                                 break;
  164.         }
  165. }

  167. /******************************
  168. 画墙壁，初始化界面
  169. *******************************/
  170. void DrawBoard(void)
  171. {
  172.         unsigned char n;
  173.         for(n=0;n<12;n++)
  174.         {
  175.                 Lcd_Rectangle(3*n,0,3*n+2,2,1);
  176.                 Lcd_Rectangle(3*n,60,3*n+2,62,1);
  177.         }
  178.         for(n=0;n<20;n++)
  179.         {
  180.                 Lcd_Rectangle(0,3*n,2,3*n+2,1);
  181.                 Lcd_Rectangle(33,3*n,35,3*n+2,1);               
  182.         }
  183.         Lcd_WriteStr(4,0,"TOTO原创");
  184.         Lcd_WriteStr(3,2,"Score:");
  185.         Lcd_WriteStr(3,3,"Level:");
  186. }

  188. /***********************************
  189. 游戏结束处理
  190. ************************************/
  191. void GameOver(void)
  192. {
  193.         if((SysFlag&(1<<deadflag))!=0)
  194.                 Lcd_WriteStr(3,1,"You Fail");
  195.         else
  196.                 Lcd_WriteStr(3,1,"You Pass");
  197. }

  199. unsigned int code MaskTab[16]={
  200. 0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
  201. 0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000
  202. };

  204. /**********************************
  205. 根据积木图标左下坐标X，Y来画出积木图标
  206. ***********************************/
  207. void DrawSign(struct Jimu Temp,unsigned char DrawMode)
  208. {
  209.         unsigned char m,n;
  210.         for(m=0;m<4;m++)
  211.                 for(n=0;n<4;n++)
  212.                 {
  213.                         if((Temp.dat&MaskTab[4*m+n])!=0)
  214.                                 Lcd_Rectangle(Temp.x+n*3,Temp.y-2-3*m,Temp.x+n*3+2,Temp.y-3*m,DrawMode);
  215.                 }
  216. }

  218. /********************************
  219. 将积木图标值融入num数据中
  220. 也即把积木图标固定，无法再下降
  221. *********************************/
  222. FixSign(void)
  223. {
  224.         unsigned char m,n;
  225.         for(m=0;m<4;m++)//行循环
  226.                 for(n=0;n<4;n++)//列循环
  227.                 {
  228.                         if((Sign[0].dat&MaskTab[4*m+n])!=0)
  229.                         {
  230.                                 num[20-(Sign[0].y-2)/3+m]|=MaskTab[11-Sign[0].x/3-n];
  231.                         }
  232.                 }
  233. }

  235. /********************************
  236. 判断积木图标中方块是否与障碍方块重合
  237. *********************************/
  238. unsigned char CheckIf(void)
  239. {
  240.         unsigned char m,n;
  241.         for(m=0;m<4;m++)//行循环
  242.                 for(n=0;n<4;n++)//列循环
  243.                 {
  244.                         if((Sign[1].dat&MaskTab[4*m+n])!=0)
  245.                         {
  246.                                 if((num[20-(Sign[1].y-2)/3+m]&MaskTab[11-Sign[1].x/3-n])!=0)
  247.                                         return 0;
  248.                         }
  249.                 }
  250.         return 1;
  251. }

  253. /********************************
  254. 判断积木图标是否可以继续下降一格
  255. ********************************/
  256. unsigned char CheckIfDown(void)
  257. {
  258.         Sign[1]=Sign[0];//
  259.         Sign[1].y+=3;//假设下降一格        
  260.         return CheckIf();
  261.         
  262. }

  264. /********************************
  265. 判断积木图标是否可以向左移动
  266. *********************************/
  267. unsigned char CheckIfLeft(void)
  268. {
  269.         Sign[1]=Sign[0];
  270.         Sign[1].x-=3;        
  271.         return CheckIf();
  272. }

  274. /********************************
  275. 判断积木图标是否可以向右移动
  276. *********************************/
  277. unsigned char CheckIfRight(void)
  278. {
  279.         Sign[1]=Sign[0];
  280.         Sign[1].x+=3;        
  281.         return CheckIf();
  282. }

  284. /********************************
  285. 判断是否可以旋转
  286. *********************************/
  287. unsigned char CheckIfRoll(void)
  288. {
  289.         unsigned char i;
  290.         unsigned int Temp;
  291.         Sign[1]=Sign[0];
  292.         if(++Sign[1].change>3)
  293.                 Sign[1].change=0;
  294.            i=Sign[1].type*4+Sign[1].change;
  295.         Temp=(unsigned int)Block[i][0]<<8;
  296.         Temp=Temp|Block[i][1];
  297.         Sign[1].dat=Temp;
  298.         
  299.         return CheckIf();
  300. }

  302. /********************************
  303. 寻找满格的行并做消除处理
  304. 最多寻找4个满行并做消除
  305. *********************************/
  306. void DelFull(void)
  307. {
  308.         unsigned char m,n;
  309.         unsigned char Temp;
  310.         unsigned char Flag=0;
  311.         Temp=(Sign[0].y-2)/3;
  312.         if(Temp>=20)//防止越过了下边界
  313.                 Temp=1;
  314.         else
  315.                 Temp=20-Temp;
  316.         for(n=Temp+3;n>=Temp;n--)//积木图标的最顶行开始寻找满行比较有利于运算
  317.         {
  318.                 if(num[n]==0xfff)
  319.                 {
  320.                         Flag=1;
  321.                         for(m=n+1;m<=19;m++)
  322.                         {
  323.                                 num[m-1]=num[m];
  324.                         }
  325.                         num[m]=0x801;
  326.                         Score++;//每找到一个满行，则分数加1
  327.                 }
  328.         }
  329.         if(Flag)//为加速而设置并判断的标志，有已固定的积木有满格消行变化则重画积木界面
  330.         {
  331.                 for(m=Temp;m<=19;m++)//为加速，不必要重第一行重画起，只需要从积木图标最下行开始往上的重画
  332.                         for(n=1;n<=10;n++)
  333.                         {
  334.                                 if((num[m]&MaskTab[n])==0)
  335.                                 {        
  336.                                         if(Lcd_ReadPixel(30-(n-1)*3,57-(m-1)*3)!=0)//为加速而做的读象素操作
  337.                                         {
  338.                                                 Lcd_Rectangle(30-(n-1)*3,57-(m-1)*3,30-(n-1)*3+2,57-(m-1)*3+2,0);
  339.                                         }
  340.                                 }
  341.                                    else
  342.                                 {
  343.                                         if(Lcd_ReadPixel(30-(n-1)*3,57-(m-1)*3)==0)//为加速而做的读象素操作
  344.                                         {
  345.                                                 Lcd_Rectangle(30-(n-1)*3,57-(m-1)*3,30-(n-1)*3+2,57-(m-1)*3+2,1);
  346.                                         }
  347.                                 }
  348.                         }
  349.         }
  350. }


  353. /*******************************
  354. 随机产生一个积木图标放到预产生区域并显示出来
  355. ********************************/
  356. void CreatSign(void)
  357. {
  358.         unsigned char n;
  359.         unsigned int Temp;

  361.         DrawSign(Sign[2],0);//先清除

  363.         n=Random()*28;
  364.         Temp=(unsigned int)Block[n][0]<<8;
  365.         Temp=Temp|Block[n][1];
  366.         Sign[2].dat=Temp;
  367.         Sign[2].x=45;
  368.         Sign[2].y=4*3+2;
  369.         Sign[2].type=n/4;
  370.         Sign[2].change=n%4;
  371.         DrawSign(Sign[2],1);//后画出
  372. }

  374. void PrintScore(void)
  375. {
  376.         unsigned char Str[3];
  377.         Str[0]=(Score/10)|0x30;
  378.         Str[1]=(Score%10)|0x30;
  379.         Str[2]=0;
  380.         Lcd_WriteStr(6,2,Str);
  381. }

  383. void PrintLevel(void)
  384. {
  385.         unsigned char Str[3];
  386.         Str[0]=(Level/10)|0x30;
  387.         Str[1]=(Level%10)|0x30;
  388.         Str[2]=0;
  389.         Lcd_WriteStr(6,3,Str);
  390. }

  392. /********************************
  393. 游戏的具体过程，也是贪吃蛇算法的关键部分
  394. *********************************/
  395. void GamePlay(void)
  396. {
  397.         unsigned char m,n;
  398.         unsigned int Temp;
  399.         SysFlag|=1<<newsignflag; 刚开始初始化为需要产生新的积木图标
  400.         InitRandom(TL0);
  401.         Lcd_WriteStr(3,1,"Playing");
  402.         PrintScore();
  403.         PrintLevel();
  404.         CreatSign();
  405.         while(1)
  406.         {        
  407.                 if((SysFlag&(1<<newsignflag))==1) 判是否需要产生新的积木图标
  408.                 {
  409.                         SysFlag&=~(1<<newsignflag);
  410.                         Sign[0]=Sign[2];
  411.                         CreatSign();
  412.                         Sign[0].x=12;
  413.                         Sign[0].y=14;

  415.                         for(m=0;m<4;m++)//行循环
  416.                         {
  417.                                 for(n=0;n<4;n++)//列循环
  418.                                 {
  419.                                         if((Sign[0].dat&MaskTab[15-m*4-n])==0)
  420.                                                 break;
  421.                                 }
  422.                                 if(n==4)
  423.                                         Sign[0].y-=3;
  424.                         }//将积木图标出现置顶
  425.                         
  426.                         for(m=0;m<4;m++)//行循环
  427.                                 for(n=0;n<4;n++)//列循环
  428.                                 {
  429.                                         if((Sign[0].dat&MaskTab[4*m+n])!=0)
  430.                                         {
  431.                                                 if((num[20-(Sign[0].y-2)/3+m]&MaskTab[11-Sign[0].x/3-n])!=0)
  432.                                                         SysFlag|=1<<deadflag;
  433.                                         }
  434.                                 }
  435.                         if((SysFlag&(1<<deadflag))!=0)
  436.                                 break;//如果产生新的积木图标中的方块与已固定好的方块重合，则死亡。游戏结束
  437.                         DrawSign(Sign[0],1);        
  438.                 }
  439.                 switch(KeyBuffer)
  440.                 {
  441.                         case LEFT:
  442.                                         KeyBuffer=0;
  443.                                         if((SysFlag&(1<<pauseflag))==0)
  444.                                         {
  445.                                                 if(CheckIfLeft())
  446.                                                 {
  447.                                                         DrawSign(Sign[0],0);
  448.                                                         Sign[0].x-=3;
  449.                                                         DrawSign(Sign[0],1);
  450.                                                 }
  451.                                         }
  452.                                         else
  453.                                         {
  454.                                                 if(++Level>=10)
  455.                                                         Level=1;
  456.                                                 PrintLevel();
  457.                                         }
  458.                                         break;
  459.                         case RIGHT:
  460.                                         KeyBuffer=0;
  461.                                         if((SysFlag&(1<<pauseflag))==0)
  462.                                         {
  463.                                                 if(CheckIfRight())
  464.                                                 {
  465.                                                         DrawSign(Sign[0],0);
  466.                                                         Sign[0].x+=3;
  467.                                                         DrawSign(Sign[0],1);        
  468.                                                 }
  469.                                         }
  470.                                         else
  471.                                         {
  472.                                                 if(++Level>=10)
  473.                                                         Level=1;
  474.                                                 PrintLevel();
  475.                                         }
  476.                                         break;
  477.                         case DOWN:
  478.                                         KeyBuffer=0;
  479.                                         if((SysFlag&(1<<pauseflag))==0)
  480.                                         {
  481.                                                 if(CheckIfDown())//判断是否能继续下降一格
  482.                                                 {
  483.                                                         DrawSign(Sign[0],0);
  484.                                                         Sign[0].y+=3;
  485.                                                         DrawSign(Sign[0],1);        
  486.                                                 }
  487.                                         }
  488.                                         break;
  489.                         case CHANGE:
  490.                                         KeyBuffer=0;
  491.                                         if((SysFlag&(1<<pauseflag))==0)
  492.                                         {
  493.                                                 if(CheckIfRoll())
  494.                                                 {
  495.                                                         DrawSign(Sign[0],0);
  496.                                                         if(++Sign[0].change>3)
  497.                                                                 Sign[0].change=0;
  498.                                                            m=Sign[0].type*4+Sign[0].change;
  499.                                                         Temp=(unsigned int)Block[m][0]<<8;
  500.                                                         Temp=Temp|Block[m][1];
  501.                                                         Sign[0].dat=Temp;
  502.                                                         DrawSign(Sign[0],1);
  503.                                                 }
  504.                                         }
  505.                                         break;
  506.                            case PAUSE:
  507.                                         KeyBuffer=0;
  508.                                         SysFlag^=1<<pauseflag;
  509.                                         if((SysFlag&(1<<pauseflag))==0)
  510.                                         {
  511.                                                 Lcd_WriteStr(3,1,"          ");
  512.                                                 Lcd_WriteStr(3,1,"Playing");
  513.                                         }
  514.                                         else
  515.                                         {
  516.                                                 Lcd_WriteStr(3,1,"          ");
  517.                                                 Lcd_WriteStr(3,1,"Pause");        
  518.                                         }
  519.                                         break;
  520.                     default:
  521.                                         break;
  522.                 }
  523.                 if((SysFlag&(1<<pauseflag))!=0)
  524.                         continue;
  525.                 Delay(500);
  526.                 if(++DelayCnt>=2*(11-Level))
  527.                 {
  528.                         DelayCnt=0;
  529.                         if(CheckIfDown())//判断是否能继续下降一格
  530.                         {
  531.                                 DrawSign(Sign[0],0);
  532.                                 Sign[0].y+=3;
  533.                                 DrawSign(Sign[0],1);
  534.                         }
  535.                         else
  536.                         {
  537.                                 FixSign();
  538.                                 DelFull();
  539.                                 PrintScore();
  540.                                 if(Score>=PASSSCORE)
  541.                                 {
  542.                                         SysFlag&=~(1<<deadflag);
  543.                                         break;//跳出玩游戏过程
  544.                                 }
  545.                                 SysFlag|=1<<newsignflag; 新的积木图标产生标志置1
  546.                         }
  547.                 }
  548.         }
  549. }

  551. void Main()
  552. {  
  553.         InitCpu();//初始化CPU
  554.         Lcd_Reset(); //初始化LCD屏
  555.         Lcd_Clear(0);//清屏
  556.         DrawBoard();//画界面
  557.         GamePlay();//玩游戏
  558.         GameOver();//游戏结束
  559.         while(1);//要想重玩，只能重启，可继续完善该游戏
  560. }
复制代码




  1. #include "REG52.H"
  2. #include "Key.h"
  3. #define OS_LONG_KEY_EN 1//如果应用中需要处理长按键动作，则定义为1，否则定义为0（如果应用中不需要处理长按动作，则建议定义为0，以节省代码空间）

  5. /***********************************************
  6. 功能说明：按键驱动扫描
  7. 入口参数：无
  8. 出口参数：扫描一次键盘以获得按键句柄
  9. 注：交OSReadKey（）函数调用
  10. 需要根据实际硬件的键盘接口修改
  11. ***********************************************/
  12. unsigned char OSScanKey(void)
  13. {
  14.         unsigned char Temp;
  15.         unsigned char i;
  16.         P2=0xff;
  17.         Temp=P1;
  18.         for(i=0;i<8;i++)
  19.         {
  20.                 if((Temp&(1<<i))==0)
  21.                         break;
  22.         }
  23.         if(i<8)
  24.                 return i+1;
  25.         else
  26.                 return        0;
  27. }

  29. /**********************************************
  30. 功能说明：读取按键动作
  31. 入口参数：无
  32. 出口参数：返回按键动作
  33. 注：没有按键动作，则返回0，1号按键动作，返回1-4
  34. 2号按键动作，返回5-8，如此类推
  35. 返回1、5、..：确认短按按下
  36. 返回2、6、..：确认长按按下
  37. 返回3、7、..：确认短按松开
  38. 返回4、8、..：确认长按松开
  39. ***********************************************/
  40. unsigned char OSReadKey(void)
  41. {
  42.         static unsigned char KeyEventCnt=0;
  43.         static unsigned char KeySampleCnt=0;
  44.         static unsigned char KeyBuffer=0;
  45. #define SHORT_ON_DITHERING_COUNTER 3//定义短按按下去抖时间
  46. #define SHORT_OFF_DITHERING_COUNTER 3//定义短按松开去抖时间，一般与短按按下去抖时间相同

  48. #if OS_LONG_KEY_EN>0
  49.         static unsigned int LongKeySampleCnt=0;
  50.         #define LONG_ON_DITHERING_COUNTER 250//定义长按按下确认需要的时间，如果是每1MS调用一次OSReadKey()，则1000意味着这个时间为1S
  51.         #define LONG_OFF_DITHERING_COUNTER 3//定义长按松开去抖时间，一般和短按去抖时间相同
  52. #endif
  53.         unsigned char KeyTemp;
  54.         KeyTemp=OSScanKey();
  55.         switch(KeyEventCnt)
  56.         {
  57.                 case 0:
  58.                         if(KeyTemp!=0)
  59.                         {
  60.                                 KeySampleCnt=0;
  61.                                 KeyBuffer=KeyTemp;
  62.                                 KeyEventCnt=1;     
  63.                         }
  64.                         return 0;//no key on,return 0
  65.                         break;
  66.                
  67.                 #if OS_LONG_KEY_EN>0        
  68.                 case 1:
  69.                         if(KeyTemp!=KeyBuffer)
  70.                         {
  71.                                 KeyEventCnt=0;
  72.                                 return 0;//is dithering,return 0
  73.                         }
  74.                         else
  75.                         {
  76.                                 if(++KeySampleCnt>SHORT_ON_DITHERING_COUNTER)
  77.                                 {
  78.                                         KeySampleCnt=0;
  79.                                         KeyEventCnt=2;
  80.                                         LongKeySampleCnt=0;
  81.                                         return ((KeyBuffer-1)<<2)+1;//sure that key on,return (KeyBuffer-1)<<2+1
  82.                                 }
  83.                                 else
  84.                                         return 0;//not sure that key on,return 0                 
  85.                         }
  86.                         break;
  87.                                 
  88.                 case 2:
  89.                         if(++LongKeySampleCnt>LONG_ON_DITHERING_COUNTER)
  90.                         {
  91.                                 KeySampleCnt=0;
  92.                                 KeyEventCnt=3;
  93.                                 return ((KeyBuffer-1)<<2)+2; //sure that key long on,return (KeyBuffer-1)<<2+2
  94.                         }
  95.                         else
  96.                         {
  97.                                 if(KeyTemp!=KeyBuffer)
  98.                                 {
  99.                                         if(++KeySampleCnt>SHORT_OFF_DITHERING_COUNTER)
  100.                                         {
  101.                                                 KeyEventCnt=0;
  102.                                                 return ((KeyBuffer-1)<<2)+3;//after short on to off,(KeyBuffer-1)<<2+3
  103.                                         }
  104.                                         else
  105.                                                 return 0;
  106.                                 }
  107.                                 else
  108.                                 {
  109.                                         KeySampleCnt=0;
  110.                                         return 0;
  111.                                 }
  112.                         }
  113.                         break;
  114.                
  115.                 case 3:
  116.                         if(KeyTemp!=KeyBuffer)
  117.                         {
  118.                                 if(++KeySampleCnt>LONG_OFF_DITHERING_COUNTER)
  119.                                 {
  120.                                         KeyEventCnt=0;
  121.                                         return ((KeyBuffer-1)<<2)+4;  //after long key on turn to off,(KeyBuffer-1)<<2+4
  122.                                 }
  123.                                 else
  124.                                         return 0;
  125.                         }
  126.                         else
  127.                         {
  128.                                 KeySampleCnt=0;
  129.                                 return 0;
  130.                         }
  131.                         break;
  132.                
  133.                 #else
  134.                 case 1:
  135.                         if(KeyTemp!=KeyBuffer)
  136.                         {
  137.                                 KeyEventCnt=0;
  138.                                 return 0;//is dithering,return 0
  139.                         }
  140.                         else
  141.                         {
  142.                                 if(++KeySampleCnt>=SHORT_ON_DITHERING_COUNTER)
  143.                                 {
  144.                                         KeySampleCnt=0;
  145.                                         KeyEventCnt=2;
  146.                                         return ((KeyBuffer-1)<<2)+1;//sure that key on,return (KeyBuffer-1)<<2+1
  147.                                 }
  148.                                 else
  149.                                         return 0;//not sure that key on,return 0                 
  150.                         }
  151.                         break;
  152.                                 
  153.                 case 2:
  154.                         if(KeyTemp!=KeyBuffer)
  155.                         {
  156.                                 if(++KeySampleCnt>=SHORT_OFF_DITHERING_COUNTER)
  157.                                 {
  158.                                         KeyEventCnt=0;
  159.                                         return ((KeyBuffer-1)<<2)+3;//after short on to off,(KeyBuffer-1)<<2+3
  160.                                 }
  161.                                 else
  162.                                         return 0;
  163.                         }
  164.                         else
  165.                         {
  166.                                 KeySampleCnt=0;
  167.                                 return 0;
  168.                         }
  169.                         break;
  170.                 #endif

  172.                 default:break;
  173.         }
  174.         return 0;
  175. }
  176. /***************************************************************/
复制代码

er.rar

63.09 KB, 下载次数: 421, 下载积分: 黑币 -5

蛇.rar

86 KB, 下载次数: 440, 下载积分: 黑币 -5

作者: dydd    时间: 2016-9-10 13:39
有电路图吗
作者: 小和尚    时间: 2017-2-4 11:47
存了，慢慢研究
作者: 937166474    时间: 2017-5-1 15:41
额额，没有电路图啊，有些地方表示不知道怎么回事啊
作者: king1234    时间: 2017-7-5 20:15
有电路图吗，楼主
作者: hth_123    时间: 2017-10-20 10:37
按键怎么定义啊？接口怎么修改？
作者: hllt    时间: 2017-11-16 15:00
很好的程序，刚好有用！
作者: xxxevery    时间: 2017-11-30 18:08
不错的程序，学习一下啊
作者: Barret    时间: 2017-12-3 17:16
按键电路怎么接啊   按键用不了
作者: 黎明即起    时间: 2017-12-8 20:06
感谢楼主，还在学习当中，
作者: 黎明即起    时间: 2017-12-8 20:07
很好，有启发作用
作者: seawalker2018    时间: 2017-12-28 18:53
下载下来看看
作者: 小清新    时间: 2017-12-29 09:59
按键定义了咩啊？跪求大哥告诉
作者: sky_    时间: 2018-1-29 14:54
很厉害
作者: sky_    时间: 2018-1-29 14:55
楼主很厉害
作者: liuzclzc    时间: 2018-2-6 20:31
很优秀的学习资料。
作者: hnwangkg_ezio    时间: 2018-3-1 11:15
可以可以
作者: JACKLI    时间: 2018-4-17 20:18
加上电路图的话就更完美了
作者: life_阳子    时间: 2018-6-20 23:51
很好的资料
作者: 233boomer    时间: 2018-7-7 10:41
好东西啊，感谢楼主
作者: Wu.CR    时间: 2018-7-7 16:14
贪吃蛇游戏键盘定义
上下左右分别为P1^5 1^6 1^4 1^3  级别键为P1^2对应1-9,1为最快速，9为最慢速
作者: chinarally@    时间: 2018-7-9 00:12
收下，慢慢看
作者: XE-72    时间: 2018-7-9 22:05
真厉害，给力！
作者: 小怪兽zqa    时间: 2018-7-11 14:51
楼主大大的程序很nice，感谢
作者: 小怪兽zqa    时间: 2018-7-12 08:51
我想问一下er的文件不是俄罗斯方块吗，为什么我下载下来是贪吃蛇的
作者: 孤岛勇者    时间: 2018-7-19 17:38
求电路图
作者: juicellllllllll    时间: 2018-9-6 14:40
真的厉害
作者: xiedong77777    时间: 2018-11-28 14:10
俄罗斯方块有bug、有的图形不能最左
作者: 梦里见回复    时间: 2018-11-29 09:37
非常感谢楼主
作者: ljc_hz    时间: 2018-12-3 15:14
谢谢，刚好在找怎么单独显示点阵图的方法，赞一个·
作者: pojian    时间: 2018-12-5 09:35
求电路图楼主
作者: 快捷键    时间: 2018-12-12 15:52
很给力，感谢楼主的分享，谢谢
作者: 123456789DWW    时间: 2018-12-12 16:51
很好的东西
作者: cmsyh    时间: 2019-1-7 22:25
希望可以得到学习
作者: gh001    时间: 2019-1-8 08:18
弄的挺好的的，以前用汇编写过，C显得简单多了
作者: buyu2011    时间: 2019-3-14 20:43
感谢大佬，装逼必备
作者: 微小苛    时间: 2019-3-15 06:52
先看看，等币够了来下！
作者: yanshangyan    时间: 2019-4-19 20:52
求电路图！！！！
作者: 65994949    时间: 2019-5-1 23:21
收下程序  慢慢消化
作者: YJZL    时间: 2019-7-27 08:53
亲测 很棒  
作者: LSIY717    时间: 2019-7-29 12:37
可以求个电路图吗？
作者: mikehhq    时间: 2021-5-12 10:54
等积分够了试试看
作者: HAISONC    时间: 2021-5-15 17:10
这个是高阶学习的好资料啊，点赞！！！！！！！！！！！！！！！！
作者: hzh173    时间: 2021-10-26 13:50
你这两个压缩包里的程序跟压缩包的名字是反的，蛇包里是俄罗斯方块，er包里是贪吃蛇，修改一下吧，别让人下错了。
作者: 没啥好名    时间: 2021-11-12 17:35
端口定义在哪里
作者: xhcl    时间: 2022-1-2 18:49
楼主up！就差一个仿真liao
作者: maomao12    时间: 2023-6-2 16:25
俄罗斯方块按键引脚定义

贪吃蛇按键引脚定义



作者: 蓝曳    时间: 2023-6-15 08:44
等积分够了下一个试试
作者: yyqx1234    时间: 2023-6-19 22:25
太厉害了吧，在哪运行



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1