MM32SPIN27PS实现俄罗斯方块游戏

只看该作者 · 2023-2-23 16:06

大概思路
因为智能车实验室选拔需要（虽然很遗憾，今年学校实验室又不收大二的学生了），用MM32做一个俄罗斯方块的小游戏。整体方案的硬件部分由一个MM32SPIN27PS黑色芯片、五向按键开关以及1.8寸TFTLCD屏幕组成。分析下来主要实现要点有三个，游戏逻辑的实现，显示函数的实现，定时器的配置实现。

因为实验室提供了基础的调用教学和工程模板，没有配置环境等一系列问题，只需要调用工程模板里面的库函数实现上述三大功能。

画圆函数和画线函数

复制

void Gui_DrawLine(u16 x0, u16 y0,u16 x1, u16 y1,u16 Color)  



{



int dx,       // difference in x's



  dy,       // difference in y's



  dx2,      // dx,dy * 2



  dy2, 



  x_inc,     // amount in pixel space to move during drawing



  y_inc,     // amount in pixel space to move during drawing



  error,     // the discriminant i.e. error i.e. decision variable



  index;     // used for looping    



 



 



 Lcd_SetXY(x0,y0);



 dx = x1-x0;//计算x距离



 dy = y1-y0;//计算y距离



 



 if (dx>=0)



 {



      x_inc = 1;



 }



 else



 {



      x_inc = -1;



      dx  = -dx; 



 } 



 



 if (dy>=0)



 {



      y_inc = 1;



 } 



 else



 {



      y_inc = -1;



      dy  = -dy; 



 } 



 



 dx2 = dx << 1;



 dy2 = dy << 1;



 



 if (dx > dy)//x距离大于y距离，那么每个x轴上只有一个点，每个y轴上有若干个点



 {//且线的点数等于x距离，以x轴递增画点



      // initialize error term



      error = dy2 - dx; 



 



      // draw the line



      for (index=0; index <= dx; index++)//要画的点数不会超过x距离



      {



           //画点



           Gui_DrawPoint(x0,y0,Color);



           



           // test if error has overflowed



           if (error >= 0) //是否需要增加y坐标值



           {



                error-=dx2;



 



                // move to next line



                y0+=y_inc;//增加y坐标值



           } // end if error overflowed



 



           // adjust the error term



           error+=dy2;



 



           // move to the next pixel



           x0+=x_inc;//x坐标值每次画点后都递增1



      } // end for



 } // end if |slope| <= 1



 else//y轴大于x轴，则每个y轴上只有一个点，x轴若干个点



 {//以y轴为递增画点



      // initialize error term



      error = dx2 - dy; 



 



      // draw the line



      for (index=0; index <= dy; index++)



      {



           // set the pixel



           Gui_DrawPoint(x0,y0,Color);



 



           // test if error overflowed



           if (error >= 0)



           {



                error-=dy2;



 



                // move to next line



                x0+=x_inc;



           } 

           error+=dx2;

           y0+=y_inc;



      } 

 }

}

————————————————

只看该作者 · 2023-2-23 16:07

复制

void Gui_Circle(u16 X,u16 Y,u16 R,u16 fc) 



{ 



  unsigned short a,b; 



  int c; 



  a=0; 



  b=R; 



  c=3-2*R; 



  while (a<b) 



  { 



    Gui_DrawPoint(X+a,Y+b,fc);   //    7 



    Gui_DrawPoint(X-a,Y+b,fc);   //    6 



    Gui_DrawPoint(X+a,Y-b,fc);   //    2 



    Gui_DrawPoint(X-a,Y-b,fc);   //    3 



    Gui_DrawPoint(X+b,Y+a,fc);   //    8 



    Gui_DrawPoint(X-b,Y+a,fc);   //    5 



    Gui_DrawPoint(X+b,Y-a,fc);   //    1 



    Gui_DrawPoint(X-b,Y-a,fc);   //    4 



 



    if(c<0) c=c+4*a+6; 



    else 



    { 



      c=c+4*(a-b)+10; 



      b-=1; 



    } 



    a+=1; 



  } 



  if (a==b) 



  { 



    Gui_DrawPoint(X+a,Y+b,fc); 



    Gui_DrawPoint(X+a,Y+b,fc); 



    Gui_DrawPoint(X+a,Y-b,fc); 



    Gui_DrawPoint(X-a,Y-b,fc); 



    Gui_DrawPoint(X+b,Y+a,fc); 



    Gui_DrawPoint(X-b,Y+a,fc); 



    Gui_DrawPoint(X+b,Y-a,fc); 



    Gui_DrawPoint(X-b,Y-a,fc); 



  } 



}

只看该作者 · 2023-2-23 16:07

方块绘制函数
TFT显示屏为128*160，选取10*10作为一个方块，游戏界面可以设置为长15格，宽12格，右侧留出一格提前显示下一个俄罗斯方块。

只看该作者 · 2023-2-23 16:07

复制

void Draw_realbox(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=1;i<=8;i++)//绘制小方块内填充色8*8

        {

                for(n=1;n<=8;n++)

                {

                        lcd_drawpoint((x+i),(y+n),RED);        

                }        

        }

        for(i=0;i<=9;i++)//绘制小方块轮廓10*10

        {

                lcd_drawpoint((x+i),y,BLACK        );

                lcd_drawpoint((x+i),(y+9),BLACK        );                

                lcd_drawpoint(x,(y+i),BLACK        );                

                lcd_drawpoint((x+9),(y+i),BLACK        );                                

        }        

}



void Draw_realbox1(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=1;i<=3;i++)

        {

                for(n=1;n<=3;n++)

                {

                        lcd_drawpoint((x+i),(y+n),RED);        

                }        

        }

        for(i=0;i<=4;i++)

        {

                lcd_drawpoint((x+i),y,BLACK        );

                lcd_drawpoint((x+i),(y+4),BLACK        );                

                lcd_drawpoint(x,(y+i),BLACK        );                

                lcd_drawpoint((x+4),(y+i),BLACK        );                                

        }        

}

只看该作者 · 2023-2-23 16:07

复制

void Draw_realbox(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=1;i<=8;i++)//绘制小方块内填充色8*8

        {

                for(n=1;n<=8;n++)

                {

                        lcd_drawpoint((x+i),(y+n),RED);        

                }        

        }

        for(i=0;i<=9;i++)//绘制小方块轮廓10*10

        {

                lcd_drawpoint((x+i),y,BLACK        );

                lcd_drawpoint((x+i),(y+9),BLACK        );                

                lcd_drawpoint(x,(y+i),BLACK        );                

                lcd_drawpoint((x+9),(y+i),BLACK        );                                

        }        

}



void Draw_realbox1(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=1;i<=3;i++)

        {

                for(n=1;n<=3;n++)

                {

                        lcd_drawpoint((x+i),(y+n),RED);        

                }        

        }

        for(i=0;i<=4;i++)

        {

                lcd_drawpoint((x+i),y,BLACK        );

                lcd_drawpoint((x+i),(y+4),BLACK        );                

                lcd_drawpoint(x,(y+i),BLACK        );                

                lcd_drawpoint((x+4),(y+i),BLACK        );                                

        }        

}

只看该作者 · 2023-2-23 16:07

删除方块实现方法是绘制成白色

复制

void Del_realbox(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=0;i<=9;i++)

        {

                for(n=0;n<=9;n++)

                {

                        lcd_drawpoint((x+i),(y+n),WHITE);        

                }        

        }

}





void Del_realbox1(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=0;i<=4;i++)

        {

                for(n=0;n<=4;n++)

                {

                        lcd_drawpoint((x+i),(y+n),WHITE);        

                }        

        }

}

只看该作者 · 2023-2-23 16:07

删除方块实现方法是绘制成白色

复制

void Del_realbox(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=0;i<=9;i++)

        {

                for(n=0;n<=9;n++)

                {

                        lcd_drawpoint((x+i),(y+n),WHITE);        

                }        

        }

}





void Del_realbox1(uint16 x,uint16 y)

{

        uint8 i,n;

        for(i=0;i<=4;i++)

        {

                for(n=0;n<=4;n++)

                {

                        lcd_drawpoint((x+i),(y+n),WHITE);        

                }        

        }

}

只看该作者 · 2023-2-23 16:08

有了以上两个函数，我们只需要在规定的坐标处调用四次小方块绘制或删除函数。即可得到或消除一块完整的俄罗斯方块，利用random产生随机数，加上switch语句进行选择需要何种方块，总方块在switch中设计了19种。
图形绘制函数如下（部分）：

复制

void Del_tuxing(uint16 x,uint16 y,uint8 what)

{

        switch (what)

        {

                case 1:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                }

                break;

                

                case 2:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x+20,y);

                Del_realbox(x+30,y);

                }

                break;

                

                case 3:

                {

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x,y+20);

                Del_realbox(x,y+30);

                }

                break;

                

                case 4:

                {

                Del_realbox(x+10,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x+20,y+10);

                }

                break;

                

                case 5:

                {

                Del_realbox(x+10,y+10);

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x,y+20);

                }

                break;



                case 6:

                {

                Del_realbox(x,y+10);

                Del_realbox(x+10,y);

                Del_realbox(x+10,y+10);

                Del_realbox(x+10,y+20);

                }

                break;

                

                case 7:

                {

                Del_realbox(x+10,y+10);

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x+20,y);

                }

                break;

        

                case 8:

                {

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x,y+20);

                Del_realbox(x+10,y+20);

                }

                break;

                

                case 9:

                {

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y);

                Del_realbox(x+20,y);

                }

                break;

                

                case 10:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x+10,y+10);

                Del_realbox(x+10,y+20);

                }

                break;

                

                case 11:

                {

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x+20,y+10);

                Del_realbox(x+20,y);

                }

                break;

                

                case 12:

                {

                Del_realbox(x+10,y);

                Del_realbox(x+10,y+10);

                Del_realbox(x+10,y+20);

                Del_realbox(x,y+20);

                }

                break;

                

                case 13:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x+20,y);

                Del_realbox(x+20,y+10);

                }

                break;

                

                case 14:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x,y+10);

                Del_realbox(x,y+20);

                }

                break;

                

                case 15:

                {

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x+20,y+10);

                }

                break;

                

                

                case 16:

                {

                Del_realbox(x+10,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x,y+20);

                }

                break;

                

                case 17:

                {

                Del_realbox(x,y);

                Del_realbox(x+10,y);

                Del_realbox(x+10,y+10);

                Del_realbox(x+20,y+10);

                }

                break;

                

                case 18:

                {

                Del_realbox(x,y);

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x+10,y+20);

                }

                break;

                

                case 19:

                {

                Del_realbox(x,y+10);

                Del_realbox(x+10,y+10);

                Del_realbox(x+10,y);

                Del_realbox(x+20,y);

                }

                break;

        

        

        

        

        }



}





void Del_tuxing1(uint16 x,uint16 y,uint8 what)

{

        switch (what)

        {

                case 1:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                }

                break;

                

                case 2:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x+10,y);

                Del_realbox1(x+15,y);

                }

                break;

                

                case 3:

                {

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x,y+10);

                Del_realbox1(x,y+15);

                }

                break;

                

                case 4:

                {

                Del_realbox1(x+5,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+10,y+5);

                }

                break;

                

                case 5:

                {

                Del_realbox1(x+5,y+5);

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x,y+10);

                }

                break;



                case 6:

                {

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+5,y+10);

                }

                break;

                

                case 7:

                {

                Del_realbox1(x+5,y+5);

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x+10,y);

                }

                break;

        

                case 8:

                {

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x,y+10);

                Del_realbox1(x+5,y+10);

                }

                break;

                

                case 9:

                {

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y);

                Del_realbox1(x+10,y);

                }

                break;

                

                case 10:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+5,y+10);

                }

                break;

                

                case 11:

                {

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+10,y+5);

                Del_realbox1(x+10,y);

                }

                break;

                

                case 12:

                {

                Del_realbox1(x+5,y);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+5,y+10);

                Del_realbox1(x,y+10);

                }

                break;

                

                case 13:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x+10,y);

                Del_realbox1(x+10,y+5);

                }

                break;

                

                case 14:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x,y+10);

                }

                break;

                

                case 15:

                {

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+10,y+5);

                }

                break;

                

                

                case 16:

                {

                Del_realbox1(x+5,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x,y+10);

                }

                break;

                

                case 17:

                {

                Del_realbox1(x,y);

                Del_realbox1(x+5,y);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+10,y+5);

                }

                break;

                

                case 18:

                {

                Del_realbox1(x,y);

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+5,y+10);

                }

                break;

                

                case 19:

                {

                Del_realbox1(x,y+5);

                Del_realbox1(x+5,y+5);

                Del_realbox1(x+5,y);

                Del_realbox1(x+10,y);

                }

                break;

        }



}

只看该作者 · 2023-2-23 16:08

数组实现逻辑
使用了15*12的数组来记录方块的位置，用0，1对当前方块进行标记，逻辑上可以进行后续的碰撞，方块消除的判断。需要区分改变数组状态并不等于直接显示，改变数组状态之后还需要调用相关的显示函数才可以实现实现相关的显示功能。
绘制一个状态

复制

void Draw_a_zhuangtai(uint16 x,uint16 y)

{

          zhuangtai[y/10][x/10+1]=1;

}

只看该作者 · 2023-2-23 16:08

删除一个状态

复制

void Del_a_zhuangtai(uint16 x,uint16 y)

{

          zhuangtai[y/10][x/10+1]=0;

}

只看该作者 · 2023-2-23 16:08

碰撞判断
使用求和的方式找出碰撞的方块。在方块没发生碰撞之前，对该数组求和的值为把目前数组扫一遍的值。当方块发生碰撞，两个方块之间的交集会使得方块占的值变化（变小），与原值比较后可得出方块是否碰撞，碰撞则返回一个值。

复制



int panduan(uint16 x,uint16 y,uint8 what,uint8 fangxiang)//碰撞检测

{

        uint16 sum1=0,sum2=0;

        uint8 i,n;

        uint8 sbuff[A][B];

        x=x/10+1;//得到换算后的真实坐标

        y=y/10;

        for(i=0;i<A;i++)

        {

                for(n=0;n<B;n++)

                {

                        sbuff[i][n]=zhuangtai[i][n];

                        sum1=sum1+zhuangtai[i][n];        

                }  

        }

        switch(fangxiang)

        {

                case 1:Left_zhuangtai_move((x-1)*10,10*y,what);break;

                case 2:Down_zhuangtai_move((x-1)*10,10*y,what);break;

                case 3:Right_zhuangtai_move((x-1)*10,10*y,what);break;

                case 4:change_zhuangtai();break;

                

        }

                for(i=0;i<A;i++)

        {

                

                for(n=0;n<B;n++)

                {

                        sum2=sum2+zhuangtai[i][n];        

                        zhuangtai[i][n]=sbuff[i][n];                        

    }

        }        

                return !(sum1==sum2);

}

只看该作者 · 2023-2-23 16:09

物理消除
由函数xiaochu()实现，每发生一次碰撞就检测一次是否满足消除条件

复制

void xiaochu()

{

        uint8 n;

        for(n=12;n>0;n--)

        {

                if(n>=12)

                {

                        n=12;

                }

                if(        (

                                        zhuangtai[n+1][1]&&zhuangtai[n+1][2]&&zhuangtai[n+1][3]&&zhuangtai[n+1][4]&&zhuangtai[n+1][5]&&zhuangtai[n+1][6]&&zhuangtai[n+1][7]&&zhuangtai[n+1][8]&&zhuangtai[n+1][9]&&zhuangtai[n+1][10]&&zhuangtai[n+1][11]

                                ) 

                                 &&

                                !(

                                        zhuangtai[n][1]&&zhuangtai[n][2]&&zhuangtai[n][3]&&zhuangtai[n][4]&&zhuangtai[n][5]&&zhuangtai[n][6]&&zhuangtai[n][7]&&zhuangtai[n][8]&&zhuangtai[n][9]&&zhuangtai[n][10]&&zhuangtai[n][11]

                                        )

                   )//描述：

                  

                {

                        lie_move(10*n);//将被消除行于其上一行交换 

                        n=n+2;

                }

                

                if((

                                !zhuangtai[n][1]&&!zhuangtai[n][2]&&!zhuangtai[n][3]&&!zhuangtai[n][4]&&!zhuangtai[n][5]&&!zhuangtai[n][6]&&!zhuangtai[n][7]&&!zhuangtai[n][8]&&!zhuangtai[n][9]&&!zhuangtai[n][10]&&!zhuangtai[n][11]

                                )//该条件用于判断换行是否完成（因为换行瞬间两行是清空的，即均为0）

                  )

                {

                        for(n=0;n<12 ;n++){

                                if(

                                                (

                                                zhuangtai[n][1]&&zhuangtai[n][2]&&zhuangtai[n][3]&&zhuangtai[n][4]&&zhuangtai[n][5]&&zhuangtai[n][6]&&zhuangtai[n][7]&&zhuangtai[n][8]&&zhuangtai[n][9]&&zhuangtai[n][10]&&zhuangtai[n][11]

                                                )

                                        ){

                                                Del_lie(n*10);

                                                fengshu++;

                                                display_fengshu();

                                        if(fengshu%10==0)

                                        {

                                                speed=speed-10;

                                                leave++;

                                                display_leave();                                

                                        }

                                }        

                        }

        break;                

                }

        }

}

只看该作者 · 2023-2-23 16:09

其中，消除函数的“消除”功能是由调用换行函数lie_move（）和删行函数Del_lie（）实现的

复制

void lie_move(uint16 y)//交换上下两行的缓存值

{

        uint8 i;

        y=y/10;

        for(i=1;i<15;i++)

        {

                if(zhuangtai[y][i]==1)

                {

                        zhuangtai[y][i]=zhuangtai[y+1][i];

                        zhuangtai[y+1][i]=1;

                        

                                Del_realbox((i-1)*10,y*10);

                        Draw_realbox((i-1)*10,(y+1)*10);

                }

                else if(zhuangtai[y][i]==0)

                {

                        zhuangtai[y][i]=zhuangtai[y+1][i];

                        zhuangtai[y+1][i]=0;

                        

                                Del_realbox((i-1)*10,y*10);

                        Del_realbox((i-1)*10,(y+1)*10);

                }

        }

}

只看该作者 · 2023-2-23 16:09

复制

void Del_lie(uint16 y)//删除一行

{

        uint8 i;

        y=y/10;

        for(i=1;i<15;i++)

        {

                zhuangtai[y][i]=0;

                Del_realbox((i-1)*10,y*10);

        }

}

只看该作者 · 2023-2-23 16:09

形状控制函数
绘制出规定形状的俄罗斯方块的函数，一共有两个，change()函数用于绘制LCD上的，change_Zhuangtai()函数用于改变状态数组中的。

复制

void change()

{

        switch(what)

        {

                case 1:break;

                

                case 2:Del(x,y,2);Draw(x,y,3);what=3;break;

                case 3:Del(x,y,3);Draw(x,y,2);what=2;break;

                

                case 4:Del(x,y,4);Draw(x,y,5);what=5;break;

                case 5:Del(x,y,5);Draw(x,y,7);what=7;break;

                case 6:Del(x,y,6);Draw(x,y,4);what=4;break;

                case 7:Del(x,y,7);Draw(x,y,6);what=6;break;

                

                case 8:Del(x,y,8);Draw(x,y,9);what=9;break;

                case 9:Del(x,y,9);Draw(x,y,10);what=10;break;

                case 10:Del(x,y,10);Draw(x,y,11);what=11;break;

                case 11:Del(x,y,11);Draw(x,y,8);what=8;break;

                

                case 12:Del(x,y,12);Draw(x,y,15);what=15;break;

                case 13:Del(x,y,13);Draw(x,y,12);what=12;break;

                case 14:Del(x,y,14);Draw(x,y,13);what=13;break;

                case 15:Del(x,y,15);Draw(x,y,14);what=14;break;

                

                case 16:Del(x,y,16);Draw(x,y,17);what=17;break;

                case 17:Del(x,y,17);Draw(x,y,16);what=16;break;

                

                case 18:Del(x,y,18);Draw(x,y,19);what=19;break;

                case 19:Del(x,y,19);Draw(x,y,18);what=18;break;

        

        }

}

复制

void change_zhuangtai()

{

        switch(what)

        {

                case 1:break;

                case 2:Del_zhuangtai_tuxing(x,y,2);Draw_zhuangtai_tuxing(x,y,3);break;

                case 3:Del_zhuangtai_tuxing(x,y,3);Draw_zhuangtai_tuxing(x,y,2);break;

                case 4:Del_zhuangtai_tuxing(x,y,4);Draw_zhuangtai_tuxing(x,y,5);break;

                case 5:Del_zhuangtai_tuxing(x,y,5);Draw_zhuangtai_tuxing(x,y,7);break;

                case 6:Del_zhuangtai_tuxing(x,y,6);Draw_zhuangtai_tuxing(x,y,4);break;

                case 7:Del_zhuangtai_tuxing(x,y,7);Draw_zhuangtai_tuxing(x,y,6);break;

                case 8:Del_zhuangtai_tuxing(x,y,8);Draw_zhuangtai_tuxing(x,y,9);break;

                case 9:Del_zhuangtai_tuxing(x,y,9);Draw_zhuangtai_tuxing(x,y,10);break;

                case 10:Del_zhuangtai_tuxing(x,y,10);Draw_zhuangtai_tuxing(x,y,11);break;

                case 11:Del_zhuangtai_tuxing(x,y,11);Draw_zhuangtai_tuxing(x,y,8);break;

                case 12:Del_zhuangtai_tuxing(x,y,12);Draw_zhuangtai_tuxing(x,y,15);break;

                case 13:Del_zhuangtai_tuxing(x,y,13);Draw_zhuangtai_tuxing(x,y,12);break;

                case 14:Del_zhuangtai_tuxing(x,y,14);Draw_zhuangtai_tuxing(x,y,13);break;

                case 15:Del_zhuangtai_tuxing(x,y,15);Draw_zhuangtai_tuxing(x,y,14);break;

                case 16:Del_zhuangtai_tuxing(x,y,16);Draw_zhuangtai_tuxing(x,y,17);break;

                case 17:Del_zhuangtai_tuxing(x,y,17);Draw_zhuangtai_tuxing(x,y,16);break;

                case 18:Del_zhuangtai_tuxing(x,y,18);Draw_zhuangtai_tuxing(x,y,19);break;

                case 19:Del_zhuangtai_tuxing(x,y,19);Draw_zhuangtai_tuxing(x,y,18);break;

        

        }

}

只看该作者 · 2023-2-23 16:10

随机数的生成

复制

what=rand()%19+1;//what代表着不同俄罗斯方块

只看该作者 · 2023-2-23 16:10

方向控制
方块可进行左、右、下的移动，因此我们需要在接到指令后再对应坐标画出完整的俄罗斯方块并将原坐标处的图形消除，只需调用之前定义的图形调用/删除函数即可。值得注意的是，在移动图像的同时，我们也需要对状态数组中的数据进行相应的移动，为此我们需要一些整合后的函数如Down(),Left(),Right(),Del().

复制

void Down(uint16 x,uint16 y,uint8 what)//调用方向移动函数

{

        Down_zhuangtai_move(x,y,what);

        Down_tuxing_move(x,y,what);                        

}```



```c

void Left(uint16 x,uint16 y,uint8 what)

{

        Left_zhuangtai_move(x,y,what);

        Left_tuxing_move(x,y,what);                        

}

只看该作者 · 2023-2-23 16:10

2

复制

void Right(uint16 x,uint16 y,uint8 what)

{

        Right_zhuangtai_move(x,y,what);

        Right_tuxing_move(x,y,what);                        

}

只看该作者 · 2023-2-23 16:11

3

复制

void Del(uint16 x,uint16 y,uint8 what)

{

        Del_tuxing(x,y,what);

        Del_zhuangtai_tuxing(x,y,what);                        

}

只看该作者 · 2023-2-23 16:11

配合KEY_Scan()就可以实现方向判断。

复制

#define KEY_UP 1

#define KEY_DOWN 2

#define KEY_LEFT 3

#define KEY_RIGHT 4  

#define KEY_MID 5  

u8 Key_Scan(void)

{



        

        if(key_up&&(KB1||KB2||KB3||KB4||KB5))

        {



                systick_delay_ms(10);//去抖动// 

                key_up=0;

                if     (KB1)        

                        return KEY_UP;

                else if(KB2)

                        return KEY_DOWN;

                else if(KB3)

                        return KEY_LEFT;

                else if(KB4)

                        return KEY_RIGHT;

                else if(KB5)

                        return KEY_MID;

        }

        else if(!KB1&&!KB2&&!KB3&&!KB4&&!KB5)

        {

                key_up=1;

        }

         return 0;// 无按键按下        

}