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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机仿真论坛 › 51单片机+Proteus仿真的俄罗斯方块游戏程序设计
返回列表 发新帖
查看: 3253|回复: 1
收起左侧

51单片机+Proteus仿真的俄罗斯方块游戏程序设计

[复制链接]
ID:517871 发表于 2019-5-9 17:09 | 显示全部楼层 |阅读模式
俄罗斯方块仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
俄罗斯方块.png

单片机俄罗斯方块源程序如下:
  1. #include <AT89X51.H>

  3. #define DOWNTIME 30
  4. #define MAXHANG 20
  5. #define MAXLIE  16
  6. #define MAXPIX  3
  7. #define PUSHON  50

  9. #define LCD P2
  10. #define EN  P3_0
  11. #define RW  P3_1
  12. #define RS  P3_2
  13. #define CS1 P3_3
  14. #define CS2 P3_4

  16. #define KEYLEFT P1_0
  17. #define KEYDOWN P1_7
  18. #define KEYRIGH P1_6
  19. #define KEYROTATION P1_1

  21. unsigned char gkey=0xff,keystate=0,t0ms1=0,t0ms=0,downtimegap=0;
  22. unsigned char miao=0,fen=0;
  23. unsigned char downok;
  24. bit keyflag,timeupdate,fashionupdate;
  25. unsigned char idata cubeMap[MAXHANG][2];
  26. typedef struct{
  27.                unsigned char code * box;
  28.                             unsigned char cube : 4;
  29.                            unsigned char state : 4;
  30.                            char row;
  31.                            char column;
  32.                            } block;
  33. block this;
  34. unsigned int score=0;
  35. unsigned char speed=1;
  36. unsigned char code bittable[8]={1,2,4,8,0x10,0x20,0x40,0x80};
  37. unsigned char code cube[]=
  38. {
  39. /*  ■
  40.   ■■■
  41. */
  42. 0,4,0xe,0,  0,2,6,2,     0,7,2,0,     4,6,4,0,

  44. /*■
  45.   ■■■
  46. */
  47. 0,8,0xe,0,  0,4,4,0xc,   0,0,0xe,2,   0,6,4,4,
  48. /*■■■
  49.   ■   
  50. */
  51. 0,0xe,8,0,  0,4,4,6,     0,1,7,0,     6,2,2,0,
  52. /*■■
  53.     ■■
  54. */
  55. 0,0xc,6,0,  0,2,6,4,     0,6,3,0,     2,6,4,0,
  56. /*  ■■
  57.   ■■  
  58. */
  59. 0,6,0xc,0,  0,4,6,2,     0,3,6,0,     4,6,2,0,
  60. /*■■■■
  61. */
  62. 0,0xf,0,0,  4,4,4,4,     0,0,0xf,0,   2,2,2,2,
  63. /*■■
  64.   ■■
  65. */
  66. 0,6,6,0,    0,6,6,0,     0,6,6,0,     0,6,6,0
  67. };
  68. unsigned char code asii[]=
  69. {
  70.     0x3E,0x51,0x49,0x45,0x3E, // -0-
  71.     0x00,0x42,0x7F,0x40,0x00, // -1-
  72.     0x62,0x51,0x49,0x49,0x46, // -2-
  73.     0x21,0x41,0x49,0x4D,0x33, // -3-
  74.     0x18,0x14,0x12,0x7F,0x10, // -4-
  75.     0x27,0x45,0x45,0x45,0x39, // -5-
  76.     0x3C,0x4A,0x49,0x49,0x31, // -6-
  77.     0x01,0x71,0x09,0x05,0x03, // -7-
  78.     0x36,0x49,0x49,0x49,0x36, // -8-
  79.     0x46,0x49,0x49,0x29,0x1E, // -9-
  80.     0x00,0x36,0x36,0x00,0x00, // -:-10
  81. //next
  82.     0x7F,0x04,0x08,0x10,0x7F, // -N-11
  83.     0x7F,0x49,0x49,0x49,0x41, // -E-12
  84.     0x63,0x14,0x08,0x14,0x63, // -X-13
  85.     0x01,0x01,0x7F,0x01,0x01, // -T-14
  86. //speed
  87.     0x26,0x49,0x49,0x49,0x32, // -S-15
  88.     0x7F,0x09,0x09,0x09,0x06, // -P-16
  89.     0x7F,0x49,0x49,0x49,0x41, // -E-17
  90.     0x7F,0x41,0x41,0x41,0x3E, // -D-18
  91. //score
  92.     0x3E,0x41,0x41,0x41,0x22, // -C-19   
  93.     0x3E,0x41,0x41,0x41,0x3E, // -O-20
  94.     0x7F,0x09,0x19,0x29,0x46, // -R-21
  95.     0x00,0x00,0x00,0x00,0x00,  // - -22
  96. //GAME OVER
  97.     0x3E,0x41,0x51,0x51,0x72, // -G-23
  98.     0x7C,0x12,0x11,0x12,0x7C, // -A-24
  99.     0x7F,0x02,0x0C,0x02,0x7F, // -M-25
  100.     0x1F,0x20,0x40,0x20,0x1F, // -V-26
  101. //TIME
  102. //  0x00,0x41,0x7F,0x41,0x00  // -I-27
  103. };
  104. ////////////////////////////////////////////////////////////////////////////////
  105. void lcdCmd(unsigned char cmd)
  106. {
  107. bit ea;
  108. ea=EA;
  109. EA=0;
  110. EN=0;
  111. RW=0;
  112. RS=0;
  113. LCD=cmd;
  114. EN=1;
  115. EN=1;
  116. EN=0;
  117. EA=ea;
  118. }
  119. //-------------------------------------------------------------------------------
  120. void lcdWriteByte(unsigned char ch)
  121. {
  122. EN=0;
  123. RS=1;
  124. RW=0;
  125. LCD=ch;
  126. EN=1;
  127. EN=1;
  128. EN=0;
  129. }
  130. //--------------------------------------------------------------------------------
  131. void lcdSetPage(unsigned char page)
  132. {
  133.   page &=0x7;
  134.   page +=0xb8;
  135.   lcdCmd(page);
  136. }
  137. //--------------------------------------------------------------------------------
  138. void lcdSetColumn(unsigned char column)
  139. {
  140.   column &=0x3f;
  141.   column +=0x40;
  142.   lcdCmd(column);
  143. }
  144. //--------------------------------------------------------------------------------
  145. //character fron=5*8
  146. void lcdPlayChar(unsigned char index,unsigned char page,unsigned char colume)
  147. {
  148. unsigned char i,temp;
  149. unsigned int p;
  150. p=5*index;
  151. for(i=colume;i<colume+5;i++)
  152.   {
  153.     if(i<64)
  154.          {
  155.           CS1=1;
  156.           CS2=0;
  157.           temp=i;
  158.          }
  159.         else
  160.          {
  161.           CS1=0;
  162.           CS2=1;
  163.           temp=i-64;
  164.          }
  165.         lcdSetPage(page);
  166.         lcdSetColumn(temp);
  167.         lcdWriteByte(asii[p++]);
  168.   }
  169. }
  170. //---------------------------------------------------------------------------------
  171. //rectangle(3,0,50,60)
  172. void rectangle(void)
  173. {
  174.   unsigned char i,page;
  175.   CS1=1;
  176.   CS2=0;
  177.   lcdSetPage(0);  
  178.   lcdSetColumn(2);
  179.   EN=0;
  180.   RS=1;
  181.   RW=0;
  182.   LCD=0xff;
  183.   EN=1;
  184.   EN=1;
  185.   EN=0;
  186.   for(i=3;i<51;i++)
  187.    {
  188.      EN=0;
  189.      RS=1;
  190.      RW=0;
  191.      LCD=0x1;
  192.      EN=1;
  193.      EN=1;
  194.      EN=0;   
  195.    }
  196.   EN=0;
  197.   RS=1;
  198.   RW=0;
  199.   LCD=0xff;
  200.   EN=1;
  201.   EN=1;
  202.   EN=0;
  203. //---------------------------
  204. for(page=1;page<7;page++)
  205. {
  206.   lcdSetPage(page);  
  207.   lcdSetColumn(2);
  208.   EN=0;
  209.   RS=1;
  210.   RW=0;
  211.   LCD=0xff;
  212.   EN=1;
  213.   EN=1;
  214.   EN=0;
  215.   for(i=3;i<51;i++)
  216.    {
  217.      EN=0;
  218.      RS=1;
  219.      RW=0;
  220.      LCD=0x0;
  221.      EN=1;
  222.      EN=1;
  223.      EN=0;   
  224.    }
  225.   EN=0;
  226.   RS=1;
  227.   RW=0;
  228.   LCD=0xff;
  229.   EN=1;
  230.   EN=1;
  231.   EN=0;
  232. }
  233. //---------------------------
  234.   lcdSetPage(7);  
  235.   lcdSetColumn(2);
  236.   EN=0;
  237.   RS=1;
  238.   RW=0;
  239.   LCD=0x1f;
  240.   EN=1;
  241.   EN=1;
  242.   EN=0;
  243.   for(i=3;i<51;i++)
  244.    {
  245.      EN=0;
  246.      RS=1;
  247.      RW=0;
  248.      LCD=0x10;
  249.      EN=1;
  250.      EN=1;
  251.      EN=0;   
  252.    }
  253.   EN=0;
  254.   RS=1;
  255.   RW=0;
  256.   LCD=0x1f;
  257.   EN=1;
  258.   EN=1;
  259.   EN=0;
  260. }
  261. //--------------------------------------------------------------------
  262. //x:列；y行，页 3*3
  263. void lcdPutPix(unsigned char x, unsigned char y,unsigned char flag)
  264. {
  265.   unsigned char i,dat,bitmask,nextbit;
  266.   bit bflag,pflag,ea;
  267.   x=x*MAXPIX;
  268.   y=y*MAXPIX;
  269.   bflag=0;
  270.   pflag=0;
  271.   i=y%8;
  272.   if(i==0)
  273.    bitmask=0x7;
  274.   else if(i==1)
  275.    bitmask=0xe;
  276.   else if(i==2)
  277.    bitmask=0x1c;
  278.   else if(i==3)
  279.    bitmask=0x38;
  280.   else if(i==4)
  281.    bitmask=0x70;
  282.   else if(i==5)
  283.    bitmask=0xe0;
  284.   else if(i==6)
  285.    {
  286.     bflag=1;
  287.     bitmask=0xc0;
  288.     nextbit=1;
  289.    }
  290.   else if(i==7)
  291.    {
  292.     bflag=1;
  293.     bitmask=0x80;
  294.     nextbit=3;
  295.    }
  296.   if(x<62)
  297.    {
  298.     CS1=1;
  299.     CS2=0;
  300.    }
  301.   else if(x>63)
  302.    {
  303.     x-=64;
  304.     CS1=0;
  305.     CS2=1;
  306.    }
  307.   else
  308.    pflag=1;
  309.   lcdSetPage(y/8);
  310.   for(i=x;i<x+MAXPIX;i++)
  311.    {
  312.     if(pflag)
  313.      {
  314.       if(i==62 || i==63)
  315.        {
  316.          CS1=1;
  317.          CS2=0;
  318.          lcdSetPage(y/8);
  319.         }
  320.       else if(pflag && i==64)
  321.        {
  322.         CS1=0;
  323.         CS2=1;
  324.         lcdSetPage(y/8);
  325.        }
  326.       }
  327.      lcdSetColumn(i);
  328.      ea=EA;
  329.      EA=0;
  330.      EN=0;
  331.      LCD=0xff;
  332.      RS=1;
  333.      RW=1;
  334.      EN=1;
  335.      EN=0;

  337.      EN=1;
  338.      dat=LCD;
  339.      EN=0;
  340.      if(flag==1)
  341.        dat|=bitmask;
  342.      else
  343.        dat&=~bitmask;
  344.      lcdSetColumn(i);  

  346.      EN=0;
  347.      RW=0;
  348.      RS=1;
  349.      LCD=dat;
  350.      EN=1;
  351.      EN=1;
  352.      EN=0;
  353.      EA=ea;
  354.    }
  355. if(bflag)
  356.   {
  357.    lcdSetPage(y/8+1);
  358.    for(i=x;i<x+MAXPIX;i++)
  359.    {
  360.     if(pflag)
  361.      {
  362.       if(i==62 || i==63)
  363.        {
  364.         CS1=1;
  365.         CS2=0;
  366.         lcdSetPage(y/8+1);
  367.        }
  368.       else if(pflag && i==64)
  369.        {
  370.         CS1=0;
  371.         CS2=1;
  372.         lcdSetPage(y/8+1);
  373.        }
  374.       }
  375.      lcdSetColumn(i);
  376.      ea=EA;
  377.      EA=0;
  378.      EN=0;
  379.      LCD=0xff;
  380.      RS=1;
  381.      RW=1;
  382.      EN=1;
  383.      EN=0;

  385.      EN=1;
  386.      dat=LCD;
  387.      EN=0;
  388.      if(flag==1)
  389.        dat|=nextbit;
  390.      else
  391.        dat&=~nextbit;
  392.      lcdSetColumn(i);  

  394.      EN=0;
  395.      RW=0;
  396.      RS=1;
  397.      LCD=dat;
  398.      EN=1;
  399.      EN=1;
  400.      EN=0;
  401.      EA=ea;  
  402.   }
  403. }
  404. }
  405. //------------------------------------------------------------------
  406. void lcdClear(void)
  407. {
  408.   unsigned char i,page;
  409.   CS1=1;
  410.   CS2=0;
  411.   for(page=0;page<8;page++)
  412.    {
  413.     lcdSetPage(page);
  414.     lcdSetColumn(0);
  415.     for(i=0;i<64;i++)
  416.            lcdWriteByte(0);
  417.    }
  418.   CS1=0;
  419.   CS2=1;
  420.   for(page=0;page<8;page++)
  421.    {
  422.     lcdSetPage(page);
  423.     lcdSetColumn(0);
  424.     for(i=0;i<64;i++)
  425.            lcdWriteByte(0);
  426.    }
  427. }
  428. //-----------------------------------------------------------------
  429. #define STAR 53
  430. #define WIDE 6
  431. void lcdIni(void)
  432. {
  433. lcdCmd(0x3f);
  434. lcdCmd(0xc0);
  435. lcdClear();
  436. rectangle();
  437. //NEXT
  438. lcdPlayChar(11,0,STAR);
  439. lcdPlayChar(12,0,STAR+1*WIDE);
  440. lcdPlayChar(13,0,STAR+2*WIDE);
  441. lcdPlayChar(14,0,STAR+3*WIDE);
  442. //SPEED
  443. lcdPlayChar(15,3,STAR);
  444. lcdPlayChar(16,3,STAR+1*WIDE);
  445. lcdPlayChar(17,3,STAR+2*WIDE);
  446. lcdPlayChar(17,3,STAR+3*WIDE);
  447. lcdPlayChar(18,3,STAR+4*WIDE);
  448. //01
  449. lcdPlayChar(0,4,STAR+2*WIDE);
  450. lcdPlayChar(1,4,STAR+3*WIDE);

  452. //SCORE
  453. lcdPlayChar(15,5,STAR);
  454. lcdPlayChar(19,5,STAR+1*WIDE);
  455. lcdPlayChar(20,5,STAR+2*WIDE);
  456. lcdPlayChar(21,5,STAR+3*WIDE);
  457. lcdPlayChar(12,5,STAR+4*WIDE);

  459. lcdPlayChar(0,6,STAR+1*WIDE);
  460. lcdPlayChar(0,6,STAR+2*WIDE);
  461. lcdPlayChar(0,6,STAR+3*WIDE);
  462. lcdPlayChar(0,6,STAR+4*WIDE);
  463. //TIME
  464. lcdPlayChar(0,7,STAR);
  465. lcdPlayChar(0,7,STAR+1*WIDE);
  466. lcdPlayChar(10,7,STAR+2*WIDE);
  467. lcdPlayChar(0,7,STAR+3*WIDE);
  468. lcdPlayChar(0,7,STAR+4*WIDE);
  469. }
  470. //-----------------------------------------------------------------
  471. void showScoreSpeed(void)
  472. {
  473.   unsigned char num[5];
  474.   char i;
  475.   unsigned int temp;
  476.   temp=score;
  477.   for(i=0;i<5;i++)
  478.    {
  479.      num[i]=temp%10;
  480.          temp=temp/10;
  481.    }
  482.   for(i=4;i>0;i--)
  483.    {
  484.      if(num[i]==0)
  485.           num[i]=22;
  486.          else
  487.           break;
  488.    }
  489.   for(i=4;i>-1;i--)
  490.    lcdPlayChar(num[i],6,STAR+(4-i)*WIDE);

  492. lcdPlayChar(speed/10,4,STAR+2*WIDE);
  493. lcdPlayChar(speed%10,4,STAR+3*WIDE);
  494. }
  495. //-------------------------------------------------------------------
  496. void timeServer(void)
  497. {
  498.   if(timeupdate)
  499.    {
  500.     timeupdate=0;
  501.     lcdPlayChar(fen/10,7,STAR);
  502.     lcdPlayChar(fen%10,7,STAR+1*WIDE);
  503.     lcdPlayChar(10,7,STAR+2*WIDE);
  504.     lcdPlayChar(miao/10,7,STAR+3*WIDE);
  505.     lcdPlayChar(miao%10,7,STAR+4*WIDE);   
  506.    }
  507.   if(fashionupdate)
  508.    {
  509.      fashionupdate=0;
  510.      lcdPlayChar(22,7,STAR+2*WIDE);
  511.    }
  512. }
  513. //===================================================================
  514. void t0isr(void) interrupt 1
  515. {
  516.   unsigned char key;
  517.   TH0=(65536-10000)/256;
  518.   TL0=(65536-10000)%256;
  519.   downtimegap++;
  520.   t0ms=++t0ms%100;
  521.   if(t0ms==0)
  522.    {
  523.      timeupdate=1;
  524.      miao=++miao%60;
  525.          if(miao==0)
  526.           fen=++fen%60;
  527.    }
  528.   if(t0ms==50)
  529.    fashionupdate=1;
  530. //----------------------------
  531.   key=0xff;
  532.   KEYLEFT=1;
  533.   KEYRIGH=1;
  534.   KEYROTATION=1;
  535.   KEYDOWN=1;
  536.   if(!KEYLEFT)
  537.     key=0;
  538.   if(!KEYRIGH)
  539.     key=1;
  540.   if(!KEYROTATION)
  541.     key=2;
  542.   if(!KEYDOWN)
  543.     key=3;

  545.   switch(keystate)
  546.    {
  547.     case 0: if(key!=gkey)
  548.                  {
  549.                           gkey=key;
  550.                           keystate=1;
  551.                          }
  552.                         break;
  553.    case 1: if(key==gkey)
  554.              {
  555.                            t0ms1=0;
  556.                            keystate=2;
  557.                            if(key!=0xff)
  558.                              keyflag=1;
  559.                          }
  560.                    else
  561.                      keystate=0;
  562.                    break;
  563.    case 2: if(key==gkey)
  564.              {
  565.                            if(t0ms1<PUSHON)
  566.                              t0ms1++;
  567.                          }
  568.                    else
  569.                     {
  570.                           keystate=0;
  571.                           keyflag=0;
  572.                           gkey=0xff;
  573.                         }
  574.                    break;
  575.    }

  577. }
  578. //===================================================================
  579. void showNextCube(unsigned char code * p,unsigned char x,unsigned char y)
  580. {
  581. unsigned char i,j,temp;
  582.   for(i=0;i<4;i++)
  583.    {  
  584.       temp=1;
  585.       for(j=0;j<4;j++)
  586.       {
  587.         if(p[i] & temp)
  588.          lcdPutPix(x+j,y+i,1);
  589.         else
  590.          lcdPutPix(x+j,y+i,0);
  591.         temp<<=1;
  592.       }
  593.    }  
  594. }
  595. //------------------------------------------------------------------
  596. void createCube(void)
  597. {
  598.   static unsigned char next;
  599.   this.cube=next;
  600.   next=TL0%7;
  601.   this.row=0;
  602.   this.column=6;
  603.   this.state=0;
  604.   this.box=cube+16*this.cube;
  605.   showNextCube(cube+16*next,19,3);
  606. }
  607. //------------------------------------------------------------------
  608. void showCubeMap(void)
  609. {
  610. unsigned char hang,lie,temp;
  611. for(hang=MAXHANG-1;hang>0;hang--)
  612.   {
  613.    if(cubeMap[hang][0]==0 && cubeMap[hang][1]==0)
  614.      break;

  616.    for(lie=0;lie<(MAXLIE/8);lie++)
  617.     {
  618.      temp=8*lie;
  619.      if(cubeMap[hang][lie]&0x01)
  620.        lcdPutPix(temp+1,hang,1);

  622.      if(cubeMap[hang][lie]&0x02)
  623.        lcdPutPix(temp+2,hang,1);

  625.      if(cubeMap[hang][lie]&0x04)
  626.        lcdPutPix(temp+3,hang,1);

  628.      if(cubeMap[hang][lie]&0x08)
  629.        lcdPutPix(temp+4,hang,1);

  631.      if(cubeMap[hang][lie]&0x10)
  632.        lcdPutPix(temp+5,hang,1);

  634.      if(cubeMap[hang][lie]&0x20)
  635.        lcdPutPix(temp+6,hang,1);

  637.      if(cubeMap[hang][lie]&0x40)
  638.        lcdPutPix(temp+7,hang,1);

  640.      if(cubeMap[hang][lie]&0x80)
  641.        lcdPutPix(temp+8,hang,1);
  642.     }
  643.   }
  644. }
  645. //-------------------------------------------------------------------
  646. void writeCubeToMap(void)
  647. {
  648.   unsigned char row,column,temp;
  649.   unsigned char hang,lie;
  650.   for(row=0;row<4;row++)
  651.    {
  652.      temp=1;
  653.      for(column=0;column<4;column++)
  654.           {
  655.             if(this.box[row] & temp)
  656.                  {
  657.                    hang=this.row+row;
  658.                    lie=this.column+column;
  659.            cubeMap[hang][lie/8] |=bittable[lie%8];
  660.                lcdPutPix(lie+1,hang,1);                          
  661.                  }
  662.                 temp<<=1;
  663.           }
  664.    }
  665. }
  666. //-------------------------------------------------------------------
  667. void clearCubeFromMap(void)
  668. {
  669.   unsigned char row,column,temp;
  670.   unsigned char hang,lie;
  671.   for(row=0;row<4;row++)
  672.    {
  673.      temp=1;
  674.      for(column=0;column<4;column++)
  675.           {
  676.             if(this.box[row] & temp)
  677.                  {
  678.                    hang=this.row+row;
  679.                    lie=this.column+column;
  680.            cubeMap[hang][lie/8] &=~bittable[lie%8];
  681.                lcdPutPix(lie+1,hang,0);                  
  682.                  }
  683.                 temp<<=1;
  684.           }
  685.    }
  686. }
  687. //-------------------------------------------------------------------
  688. unsigned char checkBorder(void)
  689. {
  690. if(this.box[3]!=0 && this.row>(MAXHANG-4))
  691.     return 1;
  692.   else if(this.box[2]!=0 && this.row>(MAXHANG-3))
  693.     return 1;
  694.   else if(this.box[1]!=0 && this.row>(MAXHANG-2))
  695.     return 1;
  696.   else if(this.box[0]!=0 && this.row>(MAXHANG-1))
  697.     return 1;
  698. //---------------------
  699.   if((this.box[0] & 0x01) || (this.box[1] & 0x01) || (this.box[2] & 0x01) ||(this.box[3] & 0x01) )
  700.    {
  701.      if(this.column<0)
  702.       return 1;
  703.    }   
  704.   else if((this.box[0] & 0x02) || (this.box[1] & 0x02) || (this.box[2] & 0x02) ||(this.box[3] & 0x02) )
  705.    {
  706.      if(this.column<-1)
  707.       return 1;
  708.    }
  709.   else if((this.box[0] & 0x04) || (this.box[1] & 0x04) || (this.box[2] & 0x04) ||(this.box[3] & 0x04) )
  710.    {
  711.      if(this.column<-2)
  712.       return 1;
  713.    }
  714.    else if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
  715.    {
  716.      if(this.column<-3)
  717.       return 1;
  718.    }
  719. //---------------------
  720.   if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
  721.    {
  722.      if(this.column>(MAXLIE-4))
  723.       return 1;
  724.    }   
  725.   else if((this.box[0] & 0x04) || (this.box[1] & 0x04) || (this.box[2] & 0x04) ||(this.box[3] & 0x04) )
  726.    {
  727.      if(this.column>(MAXLIE-3))
  728.       return 1;
  729.    }
  730.   else if((this.box[0] & 0x02) || (this.box[1] & 0x02) || (this.box[2] & 0x02) ||(this.box[3] & 0x02) )
  731.    {
  732.      if(this.column>(MAXLIE-2))
  733.       return 1;
  734.    }
  735.   else if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
  736.    {
  737.      if(this.column>(MAXLIE-1))
  738.       return 1;
  739.    }
  740. //--------------------
  741.   return 0;
  742. }
  743. //------------------------------------------------------------------
  744. unsigned char checkClask(void)
  745. {
  746.   unsigned char row,column,temp;
  747.   unsigned char hang,lie;
  748.   for(row=0;row<4;row++)
  749.    {
  750.      temp=1;
  751.      for(column=0;column<4;column++)
  752.           {
  753.             if(this.box[row] & temp)
  754.                {
  755.                     hang=this.row+row;
  756.                         lie=this.column+column;
  757.                     if(cubeMap[hang][lie/8] & bittable[lie%8])
  758.                           return 1;
  759.                   }
  760.                 temp<<=1;
  761.           }
  762.    }
  763.   return 0;
  764. }
  765. //-------------------------------------------------------------------
  766. void checkMap(void)
  767. {
  768.   unsigned char i,j,delete;
  769.   bit full;
  770.   full=0;
  771.   delete=0;
  772.   for(i=MAXHANG-1;i>0;i--)
  773.    {
  774.      if(cubeMap[i][0]==0 && cubeMap[i][1]==0)
  775.             break;
  776.          if(cubeMap[i][0]==0xff && cubeMap[i][1]==0xff)
  777.            {
  778.              delete++;
  779.                  full=1;
  780.                  for(j=i;j>0;j--)
  781.                   {
  782.                     cubeMap[j][0]=cubeMap[j-1][0];
  783.                     cubeMap[j][1]=cubeMap[j-1][1];
  784.                   }
  785.                  i++;
  786.                  cubeMap[0][0]=0;
  787.                  cubeMap[0][1]=0;
  788.            }
  789.    }
  790. if(full)
  791.   {
  792.     if(delete==1)
  793.           score++;
  794.         else if(delete==2)
  795.           score+=4;
  796.         else if(delete==3)
  797.           score+=9;
  798.         else if(delete==4)
  799.           score+=16;
  800.         rectangle();
  801.         showCubeMap();
  802.     if(score<50)
  803.          speed=1;
  804.         else if(score<100)
  805.          speed=2;
  806.         else if(score<500)
  807.          speed=3;
  808.         else if(score<1000)
  809.          speed=4;
  810.         else if(score<5000)
  811.          speed=5;
  812.         else if(score<10000)
  813.          speed=6;
  814.         else if(score<20000)
  815.          speed=7;
  816.         else if(score<30000)
  817.          speed=8;
  818.         else if(score<40000)
  819.          speed=9;
  820.         else if(score<50000)
  821.          speed=10;
  822.         else if(score<60000)
  823.          speed=11;
  824.         else
  825.          speed=12;  
  826.         showScoreSpeed();
  827.   }
  828. }
  829. //-------------------------------------------------------------------
  830. void moveLeft(void)
  831. {
  832.   clearCubeFromMap();
  833.   this.column--;
  834.   if(checkBorder() || checkClask())
  835.     this.column++;
  836.   writeCubeToMap();
  837. }
  838. //-------------------------------------------------------------------
  839. void moveRigh(void)
  840. {
  841.   clearCubeFromMap();
  842.   this.column++;
  843.   if(checkBorder() || checkClask())
  844.     this.column--;
  845.   writeCubeToMap();
  846. }
  847. //-------------------------------------------------------------------
  848. void moveDown(void)
  849. {
  850.   clearCubeFromMap();
  851.   this.row++;
  852.   if(checkBorder() || checkClask())
  853.    {
  854.     this.row--;
  855.         downok=1;
  856.    }
  857.   else
  858.    downok=0;
  859.   writeCubeToMap();
  860.   if(downok)
  861.     checkMap();
  862. }
  863. //------------------------------------------------------------------
  864. void cubeRotation(void)
  865. {
  866.   unsigned char temp;
  867.   temp=this.state;
  868.   clearCubeFromMap();
  869.   this.state=++this.state%4;
  870.   this.box=cube+16*this.cube+4*this.state;
  871.   if(checkBorder() || checkClask())
  872.    {
  873.      this.state=temp;
  874.      this.box=cube+16*this.cube+4*this.state;
  875.    }
  876.   writeCubeToMap();
  877. }
  878. /////////////////////////////////////////////////////////////////////
  879. void main(void)
  880. {
  881.   TMOD=0x1;
  882.   TH0=(65536-10000)/256;
  883.   TL0=(65536-10000)%256;
  884.   EA=1;
  885.   ET0=1;
  886.   TR0=1;
  887.   lcdIni();
  888.   for(t0ms=0;t0ms<MAXHANG;t0ms++)
  889.    {
  890.      cubeMap[t0ms][0]=0;
  891.      cubeMap[t0ms][1]=0;
  892.    }
  893.   while(1)
  894.    {
  895.      createCube();
  896.          if(checkClask())
  897.           {
  898.        rectangle();
  899. #define SHOWSTAR 12
  900. #define GAP 8
  901.        lcdPlayChar(23,2,SHOWSTAR); //GAME
  902.        lcdPlayChar(24,2,SHOWSTAR+GAP);            
  903.        lcdPlayChar(25,2,SHOWSTAR+2*GAP);
  904.        lcdPlayChar(12,2,SHOWSTAR+3*GAP);

  906.        lcdPlayChar(20,4,SHOWSTAR); //OVER     
  907.        lcdPlayChar(26,4,SHOWSTAR+GAP);
  908.        lcdPlayChar(12,4,SHOWSTAR+2*GAP);
  909.        lcdPlayChar(21,4,SHOWSTAR+3*GAP);
  910.        t0ms=0;
  911.        while(t0ms<95);//延时2秒
  912.            t0ms=0;
  913.        while(t0ms<95);
  914.        ((void (code *) (void)) 0x0000) ( );           
  915.           }
  916.      while(1)
  917.           {
  918.                 timeServer();
  919.             if(keyflag)
  920.                  {
  921.                    keyflag=0;
  922.                    t0ms1=0;
  923.                    if(gkey==0)
  924.                      moveLeft();
  925.                    if(gkey==1)
  926.                      moveRigh();
  927.                    if(gkey==2)
  928.                      cubeRotation();
  929.                    if(gkey==3)
  930.                      moveDown();                     
  931.                  }
  932.        if(gkey==0 && t0ms1==PUSHON)
  933.             {
  934.                   t0ms1-=10;
  935.                   moveLeft();
  936.                 }
  937.        if(gkey==1 && t0ms1==PUSHON)
  938.             {
  939.                   t0ms1-=10;
  940.                   moveRigh();
  941.                 }
  942.        if(gkey==3 && t0ms1==PUSHON)
  943.             {
  944.                   t0ms1-=10;
  945.                   moveDown();
  946.                 }
  947.            if(downtimegap>(DOWNTIME-speed))
  948.             {
  949.              moveDown();
  950.                  downtimegap=0;
  951.                 }
  952.            if(downok)
  953.             {
  954.                   downok=0;
  955.                   break;
  956.                 }
  957.           }
  958.    }
  959. }
复制代码

0.png

全部资料51hei下载地址：
基于51单片机和Proteus仿真的俄罗斯方块游戏设计.zip (89.2 KB, 下载次数: 85)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:516650 发表于 2020-6-2 16:48 | 显示全部楼层
感谢楼主了
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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