C实现的俄罗斯方块

最新推荐文章于 2024-08-11 20:22:44 发布
最新推荐文章于 2024-08-11 20:22:44 发布
阅读量1.7k 收藏 4
点赞数 3
分类专栏： C/C++ 文章标签： c struct random up im
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnu_zxc/article/details/8067793
版权

        刚开始学习C的时候写的一个东西，好像只有在一些老旧的机器上能跑，今天有机会接触到了这样的一台机器，试了一下，还是可以跑得动的，好激动（虽然程序在内存释放方面是有问题的）附上代码：

#include "stdio.h"
#include "dos.h"
#include "conio.h"
#include "graphics.h"
#include "stdlib.h"
/***********************按键码***************************/
#define VK_LEFT   0x4b00
#define VK_RIGHT  0x4d00
#define VK_DOWN   0x5000
#define VK_UP     0x4800
#define VK_ESC    0x011b
#define VK_ENTER  0x1c0d
/*********************************************************/
#define MAXX  12
#define MAXY  23   /*You'd better not make it more! It's big enough now!!!!!!*/
#define BACKCOLOR  LIGHTGRAY
#define LINECOLOR  LIGHTMAGENTA
/*******************************************************/
int box[MAXX][MAXY];  /*0_empty,1_moving,2_fixed*/
int timelimite=18,key=0;
int x,y,timecounter=0;
int score=0,level=0,boxcolor[MAXX][MAXY];
char str1[20] ,str2[20];
struct diamond
{
    int x[4];
    int y[4];
    int startx;
    int starty;
    int color;
    struct diamond *next;
}  ;
/***********************************************************************************************************/
struct diamond * nowbox,*nextbox;

/*************************************************************************************************************/
void   interrupt   (   *oldhandler)();
/**************************************/
void   interrupt   newhandler( )
{
  timecounter++;
}
/*************************************************************************/
void forelook(void)
{
   int i;

   setfillstyle(SOLID_FILL,BLACK);
   bar(319,79,461,101) ;

   setfillstyle(SOLID_FILL,LIGHTBLUE);
   bar(320,80,460,100);
   setcolor(RED);
   settextstyle(TRIPLEX_FONT,HORIZ_DIR ,4 );
   outtextxy(340,90,"The next one:");

   setfillstyle(SLASH_FILL,BACKCOLOR);
   setcolor(LINECOLOR);
   bar(320,100,460,240);
   setfillstyle(SOLID_FILL ,BACKCOLOR);
   bar(330,110,450,230) ;
   for(i=0;i<7;i++)
     {
          line(330,110+20*i,450,110+20*i);
      }
   for(i=0;i<7;i++)
     {
          line(330+20*i,110,330+20*i,230);
     }
}
/*******************************************************/
void showlevel(void)
{
   if(score>=1000)
      {
         level+=1;
      }
   sprintf(str1, "LEVEL :   %d    ", level);
   sprintf(str2, "SCORE :   %d    ", score);

   setfillstyle(SOLID_FILL,BLACK);
   bar(319,289,321,351) ;
   outtextxy(320,290,str1);
   outtextxy(320,350,str2);
}
/******************************************************/
void beginface(void)
{
   int i,j;
   setfillstyle(SLASH_FILL,BACKCOLOR);
   setcolor(LINECOLOR);
   bar(60,20,60+20*MAXX,20+MAXY*20);
   setfillstyle(SOLID_FILL ,BACKCOLOR);
   bar(80,40,80+(MAXX-2)*20,40+(MAXY-2)*20) ;
   for(i=0;i<=MAXY-2;i++)
     {
        line(80,40+i*20,80+(MAXX-2)*20,40+i*20);
     }

   for(i=0;i<=MAXX-2;i++)
     {
        line(80+20*i,40,80+20*i,40+20*(MAXY-2)) ;
     }

   setfillstyle(SOLID_FILL,LIGHTBLUE);
   bar(0,0,639,20);
   setcolor(WHITE);
   settextstyle(TRIPLEX_FONT,HORIZ_DIR ,4 );
   outtextxy(5,10,"ZY_1              Welcome to my game!And have a nice time!");
   forelook();

   for(i=0;i<=MAXX;i++)
     {
           for(j=0;j<=MAXY;j++)
              {
                box[i][j]=0;
                boxcolor[i][j]=BACKCOLOR;
              }
     }

   for(i=0;i<MAXY;i++)
     {
        box[0][i]=2;
        boxcolor[0][i]=-1;
     }
   for(i=0;i<MAXY;i++)
     {
        box[MAXX-1][i]=2;
        boxcolor[MAXX-1][i]=-1;
     }
   for(i=0;i<MAXX;i++)
     {
        box[i][0]=2;
        boxcolor[i][0]=-1;
     }

   for(i=0;i<MAXX;i++)
     {
        box[i][MAXY-1]=2;
        boxcolor[i][MAXY-1]=-1;
     }

   line(440,439,430,443);line(440,439,450,443);line(440,439,440,447);
   line(450,453,430,453);line(450,453,440,449);line(450,453,440,458);
   line(430,463,440,457);line(430,463,440,467);line(430,463,450,463);
   line(440,478,440,469);line(440,478,450,473);line(440,478,430,473);

   outtextxy(320,419,"DIRECTIONS :");
   outtextxy(430,419,"ENTER:PAUSE");
   outtextxy(430,429,"ESC:OVER");
   outtextxy(440,439,"  :NEXT");
   outtextxy(440,449,"  :RIGHT");
   outtextxy(440,459,"  :LEFT");
   outtextxy(440,469,"  :DOWEN");

}
/*************************************/
struct diamond* box1(void)  /****/
{
    struct diamond *first;
    struct diamond *tnext;
    first=(struct diamond *)malloc(sizeof(struct diamond));
    tnext=(struct diamond *)malloc(sizeof(struct diamond));


    first->next=tnext;
    tnext->next=first;
    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=0;
    first->y[2]=2;
    first->x[3]=0;
    first->y[3]=3;
    first->startx=5;
    first->starty=1;
    first->color=BLUE;

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=2;
    tnext->y[2]=0;
    tnext->x[3]=3;
    tnext->y[3]=0;
    tnext->startx=5;
    tnext->starty=1;
    tnext->color=BLUE;

    if(random(2))
       return first;
    else
       return first->next;
}

/******************************************/
struct diamond *box2(void)    /*    *    */
{                         /*    **   */
    struct diamond *first;/*      *  */
    struct diamond *tnext;
    first=(struct diamond *)malloc(sizeof(struct diamond));
    tnext=(struct diamond *)malloc(sizeof(struct diamond));


    first->next=tnext;
    tnext->next=first;
    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=1;
    first->y[2]=1;
    first->x[3]=1;
    first->y[3]=2;
    first->startx=5;
    first->starty=2;
    first->color=GREEN;

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=1;
    tnext->y[2]=-1;
    tnext->x[3]=2;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=2;
    tnext->color=GREEN;

    if(random(2))
       return first;
    else
       return first->next;
}

/********************************************/
struct diamond *box3()       /*     *       */
{                            /*    **       */
    struct diamond *first;   /*    *        */
    struct diamond *tnext;
    first=(struct diamond *)malloc(sizeof(struct diamond));
    tnext=(struct diamond *)malloc(sizeof(struct diamond));


    first->next=tnext;
    tnext->next=first;
    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=-1;
    first->y[2]=1;
    first->x[3]=-1;
    first->y[3]=2;
    first->startx=5;
    first->starty=1;
    first->color=RED;

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=1;
    tnext->y[2]=1;
    tnext->x[3]=2;
    tnext->y[3]=1;
    tnext->startx=5;
    tnext->starty=1;
    tnext->color=RED;

    if(random(2))
       return first;
    else
       return first->next;
}


/*****************************************************/
struct diamond *box4()      /*   **     */
{                           /*   **    */
    struct diamond *first;

    first=(struct diamond *)malloc(sizeof(struct diamond));

    first->next=first;

    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=1;
    first->y[1]=0;
    first->x[2]=0;
    first->y[2]=1;
    first->x[3]=1;
    first->y[3]=1;
    first->startx=5;
    first->starty=1;
    first->color=YELLOW;

       return first;

}


/******************************************/
struct diamond *box5()      /*     *       */
{                           /*    ***      */
    struct diamond *first;
    struct diamond *midd;
    struct diamond *tnext;
    int ra=random(4)+1,i;

    first=(struct diamond *)malloc(sizeof(struct diamond));

    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=1;
    first->y[2]=1;
    first->x[3]=-1;
    first->y[3]=1;
    first->startx=5;
    first->starty=2;
    first->color=LIGHTBLUE;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=1 ;
    tnext->y[2]=1;
    tnext->x[3]=1;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=2;
    tnext->color=LIGHTBLUE;

    first->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=-1;
    tnext->x[2]=0;
    tnext->y[2]=-1;
    tnext->x[3]=-1;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=2;
    tnext->color=LIGHTBLUE;

    midd->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=-1;
    tnext->y[1]=0;
    tnext->x[2]=-1;
    tnext->y[2]=1;
    tnext->x[3]=-1;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=2;
    tnext->color=LIGHTBLUE;
    midd->next=tnext;
    tnext->next=first;

    for(i=1;i<=ra;i++)
      {
         first=first->next;
      }
    return first;

}

/******************************************/
struct diamond *box6()      /*     *      */
{                           /*     *      */
    struct diamond *first;  /*     **     */
    struct diamond *midd;
    struct diamond *tnext;
    int ra=random(4)+1,i;

    first=(struct diamond *)malloc(sizeof(struct diamond));

    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=0;
    first->y[2]=2;
    first->x[3]=1;
    first->y[3]=2;
    first->startx=5;
    first->starty=3;
    first->color=CYAN;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=2 ;
    tnext->y[2]=0;
    tnext->x[3]=2;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=CYAN;

    first->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=0;
    tnext->y[1]=-1;
    tnext->x[2]=0 ;
    tnext->y[2]=-2;
    tnext->x[3]=-1;
    tnext->y[3]=-2;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=CYAN;

    midd->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=-1;
    tnext->y[1]=0;
    tnext->x[2]=-2;
    tnext->y[2]=0;
    tnext->x[3]=-2;
    tnext->y[3]=1;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=CYAN;
    midd->next=tnext;
    tnext->next=first;

    for(i=1;i<=ra;i++)
      {
         first=first->next;
      }
    return first;

}


/******************************************/
struct diamond *box7()      /*           */
{                           /*    ***      */
    struct diamond *first;
    struct diamond *midd;
    struct diamond *tnext;
    int ra=random(4)+1,i;

    first=(struct diamond *)malloc(sizeof(struct diamond));

    first->x[0]=0;
    first->y[0]=0;
    first->x[1]=0;
    first->y[1]=1;
    first->x[2]=-1;
    first->y[2]=2;
    first->x[3]=0;
    first->y[3]=2;
    first->startx=5;
    first->starty=3;
    first->color=LIGHTCYAN;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=-1;
    tnext->y[1]=0;
    tnext->x[2]=-2;
    tnext->y[2]=0;
    tnext->x[3]=-2;
    tnext->y[3]=-1;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=LIGHTCYAN;

    first->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=1;
    tnext->y[1]=0;
    tnext->x[2]=2;
    tnext->y[2]=0;
    tnext->x[3]=2;
    tnext->y[3]=1;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=LIGHTCYAN;

    midd->next=tnext;
    midd=tnext;

    tnext=(struct diamond *)malloc(sizeof(struct diamond));

    tnext->x[0]=0;
    tnext->y[0]=0;
    tnext->x[1]=0;
    tnext->y[1]=-1;
    tnext->x[2]=0;
    tnext->y[2]=-2;
    tnext->x[3]=1;
    tnext->y[3]=-2;
    tnext->startx=5;
    tnext->starty=3;
    tnext->color=LIGHTCYAN;
    midd->next=tnext;
    tnext->next=first;

    for(i=1;i<=ra;i++)
      {
         first=first->next;
      }
    return first;

}
/*************************************************************************/
struct diamond *getbox(void)
{
    struct diamond *box;
    switch (random(7)+1)
      {
        case 1:box=box1();break;
        case 2:box=box2();break;
        case 3:box=box3();break;
        case 4:box=box4();break;
        case 5:box=box5();break;
        case 6:box=box6();break;
        case 7:box=box7();break;
      }
      return box;
}

/*************************************************************************/
void shownext(struct diamond *Obox)
{
      int i,j;

      forelook();

      setfillstyle(SOLID_FILL ,Obox->color);

      for(i=0;i<4;i++)
         {
            floodfill(370+Obox->x[i]*20+1,150+Obox->y[i]*20+1,LINECOLOR) ;
         }
}
/*************************************************************************/
void drawbox(struct diamond *infor)
{
     int i;
     setfillstyle(SOLID_FILL ,infor->color);
     for(i=0;i<=3;i++)
       {
          floodfill(80+(infor->x[i]+x-1)*20+1,40+(infor->y[i]+y-1)*20+1,LINECOLOR);

           box[x+infor->x[i]][y+infor->y[i]]=1;

           boxcolor[x+infor->x[i]][y+infor->y[i]]=infor->color;
       }

}
/********************************************************/
void clearbox(struct diamond *infor)
{
     int i;
     setfillstyle(SOLID_FILL ,BACKCOLOR);
     for(i=0;i<=3;i++)
       {
           floodfill(80+(infor->x[i]+x-1)*20+1,40+(infor->y[i]+y-1)*20+1,LINECOLOR);

           box[x+infor->x[i]][y+infor->y[i]]=0;

           boxcolor[x+infor->x[i]][y+infor->y[i]]=BACKCOLOR;
       }
}
/*******************************************************************/
int ifboxfixed(void)
{
   int i,flag=0;

   for(i=0;i<4;i++)
      {
           if(box[x+nowbox->x[i]][y+nowbox->y[i]+1]==2)
              {
                 flag=1;
                 break;
              }
      }
   if(flag==1)
      {
           for(i=0;i<4;i++)
               {
                 box[x+nowbox->x[i]][y+nowbox->y[i]]=2;
               }
           return  1;
      }
   else
        return  0;
}
/*******************************************************************/
void goleft(void)
{
  int i,flag=0;
  oldhandler=getvect(0x1c);
  disable();
  setvect(0x1c,newhandler);
  enable();


  for(i=0;i<4;i++)
     {
         if(box[x+nowbox->x[i]-1][y+nowbox->y[i]]==2)
            {
              flag=1;
              break;
            }
     }

  if(flag==0)
     {
        clearbox(nowbox);
        x-=1;
        drawbox(nowbox);
     }
  else
     flag=0;
         
  disable();
  setvect(0x1c,oldhandler);
  enable();

}
/******************************************************************/
void goright(void)
{
  int i,flag=0;

  oldhandler=getvect(0x1c);
  disable();
  setvect(0x1c,newhandler);
  enable();

  for(i=0;i<4;i++)
    {
      if(box[x+nowbox->x[i]+1][y+nowbox->y[i]]==2)
          {
            flag=1 ;
            break;
          }
    }

  if(flag==0)
    {
       clearbox(nowbox);
       x+=1;
       drawbox(nowbox);
    }
  else
    flag=0;
        
  disable();
  setvect(0x1c,oldhandler);
  enable();

}
/******************************************************************/
void godown(void)
{
  int i,flag=0;

  oldhandler=getvect(0x1c);
  disable();
  setvect(0x1c,newhandler);
  enable();

  for(i=0;i<4;i++)
     {
       if(box[x+nowbox->x[i]][y+nowbox->y[i]+1]==2)

          {
             flag=1;
             break;
          }
     }

  if(flag==0)
     {
       clearbox(nowbox);
       y+=1;
       drawbox(nowbox);

     }

  else
       flag=0;

   disable();
   setvect(0x1c,oldhandler);
   enable();

}
/******************************************************************/
void gonext(void)
{
  int i,flag=0;

  oldhandler=getvect(0x1c);
  disable();
  setvect(0x1c,newhandler);
  enable();

  for(i=0;i<4;i++)
     {
       if(box[x+(nowbox->next)->x[i]][y+(nowbox->next)->y[i]]==2)

          {
             flag=1;
             break;
          }
     }

  if(flag==0)
     {

      clearbox(nowbox);
      nowbox=nowbox->next;
      drawbox(nowbox);
     }
  else
     flag=0;
         
  disable();
  setvect(0x1c,oldhandler);
  enable();

}
/******************************************************************/
int GAMEOVER(void)
{

  cleardevice();
  setbkcolor(RED) ;

  settextstyle(1, HORIZ_DIR,10);

  outtextxy(300,250,"YOU HAVE LOST !");

  sleep(3);
  closegraph();
  exit(0);

}
/*******************************************************************/
void clearline(int i)
{
  int m,n,j;

  for(m=i;m>1;m--)
     {
        for(n=1;n<MAXX-1;n++)

           {
           box[n][m] = box[n][m-1];
           boxcolor[n][m] =boxcolor[n][m-1];

           setfillstyle(SOLID_FILL ,boxcolor[n][m]);

           floodfill(80+(n-1)*20+1,40+(m-1)*20+1,LINECOLOR);
           }
     }
  for(j=1;j<MAXX-1;j++)
     {
        box[j][1]=0;

        setfillstyle(SOLID_FILL ,BACKCOLOR);

        floodfill(80+(j-1)*20+1,40+1,LINECOLOR);
     }
}
/******************************************************************/
void check(void)
{
  int i,j,flag1=0,flag2=0;

  for(i=1;i<MAXX-1;i++)
      {
          if(box[i][1]==2)
             {
                flag1=1;
                break;
             }
      }
  if(flag1==1)
      {

         flag1=0;
         GAMEOVER();  /*****************/
      }

  for(i=MAXY-2;i>1;i--)
      {
        for(j=1;j<MAXX-1;j++)
          {
             if(box[j][i]!=2)
                {
                  flag2=1;
                  break;
                 }
          }
        if(flag2==0)
          {
            clearline(i);
            score+=10;
          }
        else
          flag2=0;
      }
}
/******************************************************************/
void movedown(void)
{
  int i,flag=0;
  for(i=0;i<4;i++)
     {
       if(box[x+nowbox->x[i]][y+nowbox->y[i]+1]==2)
          {
             flag=1;
             break;
          }
     }

  if(flag==0)
     {
       clearbox(nowbox);
       y+=1;
       drawbox(nowbox);
     }
}
/********************************************************************/
void pause(void)
{
  disable();
  setvect(0x1c,oldhandler);
  enable();

  getch();

  oldhandler=getvect(0x1c);
  disable();
  setvect(0x1c, newhandler);
  enable();
}
/*************************************************************************/
void Intro( void )
{
    setbkcolor(BLUE) ;
    setcolor(GREEN) ;
    settextstyle(1, HORIZ_DIR,10);

    outtextxy(270,250,"MADE BY ZXC");

    sleep(3);
    cleardevice();
}
/********************************************************************/

int main(void)
{
int m,gd=DETECT,gm,timelimite=36 ;


initgraph(&gd,&gm,"c:\\");
randomize();

Intro();
beginface();

setbkcolor(BLACK) ;

nowbox=getbox();
nextbox=getbox();
x=nowbox->startx;
y=nowbox->starty;

   for(;;)
       {
           shownext(nextbox);
           drawbox(nowbox); 

           oldhandler=getvect(0x1c);
           disable();
           setvect(0x1c, newhandler);
           enable();

           for(;;)
               {
                         if(bioskey(1))
                            key=bioskey(0);
                         else
                            key=0;
                         switch(key)
                                {
                                   case 0:break;
                                   case VK_LEFT:    goleft();   break;
                                   case VK_RIGHT:   goright();  break;
                                   case VK_DOWN:    godown();   break;
                                   case VK_UP:      gonext();   break;
                                   case VK_ENTER:    pause();    break;
                                   case VK_ESC:     closegraph();exit(0);
                                   default :break;
                                }

                         if(timecounter>timelimite)
                            {
                               timecounter=0;
                               movedown();
                            }

                         if( ifboxfixed() )
                            {
                               timecounter=0;
                               break;
                            }

               }
               check();
               showlevel();
               nowbox=nextbox;
               nextbox=getbox();
               x=nowbox->startx;
               y=nowbox->starty;
       }




    return 0;
}


图片：


hnu_zxc
关注
专栏目录
Linux c 基础实现简易俄罗斯方块
m0_74341824的博客
11-15 582
简易版，还有点小ｂｕｇ．
C++标准库 vector排序
hnuzxc的专栏
09-03 12万+
前天要做一个对C++ STL的vector容器做一个排序操作，之前一直把vector当做一个容量可自动变化的数组，是的，数组，所以打算按照对数组进行排序的方法：用快速排序或是冒泡排序等算法自己写一个排序的函数。后来觉得STL这么强大，应该有它自己的排序方法（没有好好学习啊），然后就去google了一下，果然有，而且可以自定义排序的函数，太强大了（而且效率应该比我自己写的要好吧）。 // Vect
俄罗斯方块（C语言实现）
热门推荐
2021dragon的博客
08-14 17万+
文章目录游戏说明游戏效果展示游戏代码游戏代码详解游戏框架构建隐藏光标光标跳转初始化界面初始化方块信息颜色设置画出方块空格覆盖合法性判断游戏主体逻辑函数判断得分与结束主函数 游戏说明 俄罗斯方块相信大家都知道，这里就不再介绍什么游戏背景了，我这里对本代码实现的俄罗斯方块作一些说明： 按方向键的左右键可实现方块的左右移动。 按方向键的下键可实现方块的加速下落。 按空格键可实现方块的顺时针旋转。 按Esc键可退出游戏。 按S键可暂停游戏，暂停游戏后按任意键继续游戏。 按R键可重新开始游戏。 除此之外，本游戏还
c语言实现俄罗斯方块
最新发布
cuitlse的博客
08-11 1084
case LEFT: if(pd(n,space_c,x,y-1)==1) //判断是否可以移动。int pd(int n,int space_c,int x,int y) //判断是否到底。///////////////////////////////////旋转后的21个形状。//////////////////////////////////基础7个形状。printf("是否重新开始游戏(y/n): ");
C语言实现俄罗斯方块
qq_54169998的博客
02-13 6万+
使用C语言完成俄罗斯方块。《俄罗斯方块》的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由小方块组成的不同形状的板块陆续从屏幕上方落下来，玩家通过调整板块的位置和方向，使它们在屏幕底部拼出完整的一条或几条。这些完整的横条会随即消失，给新落下来的板块腾出空间，与此同时，玩家得到分数奖励。没有被消除掉的方块不断堆积起来，一旦堆到屏幕顶端，玩家便告输，游戏结束。顾名思义，俄罗斯方块自然是俄罗斯人发明的。
用c++语言实现俄罗斯方块
weixin_42611177的博客
02-16 973
俄罗斯方块是一款经典的游戏，使用C语言实现可以考虑以下步骤： 创建游戏框架：可以使用C语言中的窗口库(如SDL或OpenGL)创建一个游戏窗口，以便显示游戏界面。 设计方块：定义俄罗斯方块的形状和颜色，可以使用二维数组表示方块的形状，每一种颜色用一个整数值表示。 控制方块移动：使用键盘输入函数来控制方块的移动、旋转等操作，并对方块进行边界检测，以避免超出游戏界面。 碰撞检测：当方块落到底部...
C 语言实现俄罗斯方块
03-21
linux的ubuntu 和红帽下，C语言实现俄罗斯方块，
用C实现的俄罗斯方块
03-08
俄罗斯方块，用Cfree和MinGW运行
俄罗斯方块c的实现
05-15
俄罗斯方块的实现，有要的看看
c/c++实现俄罗斯方块
12-24
使用C++和EasyX实现俄罗斯方块，我们需要关注以下几个关键点： 1. **窗口初始化**：首先，我们需要包含EasyX库，并设置一个窗口来显示游戏。EasyX提供了`initGraph`函数用于创建窗口，并使用`delay`函数控制帧率。 ...
俄罗斯方块，C实现
12-22
简单的俄罗斯方块程序，C语言实现，界面简洁友好
C语言Turbo C下实现俄罗斯方块
12-31
本文实例为大家分享了C语言俄罗斯方块的具体代码，供大家参考，具体内容如下 #include #include #include #include #include #ifdef __cplusplus #define __CPPARGS ... #else #define __CPPARGS #endif #...
C/C++求对数
hnuzxc的专栏
04-25 3万+
C的数学函数库定义了自然对数函数log，但没有定义以其他数为底的对数，可以通过换底公式来实现之： 测试代码： #include "stdio.h" #include "conio.h" #include #define E 2.718282 int main() { double a,b; a = log(100) / log(10);
数组下标为负数
hnuzxc的专栏
12-24 1万+
在使用数组的时候，相信大多数人首先想到的是“数组是从0开始的，数组的下标必须大于或等于0”，但是在处理一些数值计算的问题的时候，很可能会遇到下标为负数的问题，比如，在做9/7浮点小波变换的时候会有：x（m） =  x(-m) ,m＜０，在这种情况下，当要循环迭代计算的时候，就需要判断m是否为负数，这个还是有点麻烦的。         这个时候，如果我们知道m的最小值，比如-4的时候，就可以考虑直
C++归并求交集，并集
hnuzxc的专栏
06-15 7331
对于两个有序的元素序列，在归并操作中作适当的处理即可得到二者的交集与并集，代码如下：   #include #include #include #include using namespace std; void vectorjiaoji(const vector& v1,const vector& v2,vector& des)//求交集 {
C\C++几个内存处理函数
hnuzxc的专栏
12-26 6780
1、memcpy void * memcpy ( void * destination, const void * source, size_t num ); 复制内存块 从source指向的位置直接复制num个字节的值到destination指向的内存块。 对于这个函数，source和destination指向的对象的底层类型是无关的；结果是数据的一个二进制复制。 这个函数
猫映射及其逆映射
hnuzxc的专栏
05-12 5644
猫映射是一种混沌系统，它将明文当做混沌系统的初始值进行迭代或演化来达到将明文进行置乱（加密）的效果。它也叫做Arnold映射，最早由Arnold和Avez提出。其映射方式如下：         当把（x，y）视为矩阵（长与宽相等）的坐标的时候，N即为矩阵的宽度，该过程可以将整个矩阵中的元素的位置打乱。事实上，在对图像进行混沌置乱以实现加密的时候，多采用猫映射来实现。需要指出的是，上式是可以迭
一个打印日志的C宏定义——TRACEOUT
hnuzxc的专栏
12-01 4361
在编程的时候，我们常常需要知道程序的运行状态，因而回用printf、cout或者AfxMessageBox等方式将信息打印出来。这样处理其实是很麻烦的，每个地方都要写这些代码，程序发布的时候又要手动注释或者删除这些代码，费时费力还容易出错。而本文则是介绍另外一种方式来获取程序的运行状态——打印日志，通过一个宏定义来把要打印的信息写到一个日志文件中，这样不仅可以记录程序每次运行的状态便于debug，
Win7 编译安装log4cxx c++日志类
hnuzxc的专栏
07-26 4031
log4cxx是Apache的Log4j的一个C++版本，我今天在win7+VS2010环境下进行了编译安装，中间出了一些问题，查资料发现每个人遇到的问题不完全相同，有一些我就没有遇到，这里记录一下我遇到的各个问题以及解决的方法。 首先要下载log4cxx 以及 apr 和 apr-util 源码： log4cxx:http://www.apache.org/dyn/closer.cgi/lo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值