俺用c语言写的一个天下算法最烂的俄罗斯方块程序

最新推荐文章于 2024-08-11 20:22:44 发布
最新推荐文章于 2024-08-11 20:22:44 发布
阅读量2.8k 收藏
点赞数 1
文章标签： 算法 语言 c struct graph initialization
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanz2000/article/details/13958
版权

 

/*tc3下调试通过，编译前将turboc目录下的egavga.bgi考到源程序所在目录下。
  另要在            */

#include <graphics.h>/* 定义boland图形库*/
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#define ESC 0x11b  /*定义键盘扫描码*/
#define UP 0x4800
#define DOWN 0x5000
#define LEFT 0x4b00
#define F1 0x3b00
#define RIGHT 0x4d00
#define YES 0x1579
#define NO 0x316e
#define RESTART 0x1372
/********************定义全局变量*****************************/
int grid[20][10];/*网格数组，0表示该格无方块，1则有运动方块，2则有静止方块*/
int level,score,interval;/*level--关数，score--消去的层数，
                           interval--下降的时间间隔（单位毫秒）*/
/**************************定义每种方块的形状***********************************/
static int I_SHAPE1[1][4]={1,1,1,1};/*I代表长条方块，O－－方形*/
static int I_SHAPE2[4][1]={1,
                           1,
                           1,
                           1};
static int O_SHAPE[2][2]={1,1,
     1,1};
static int T_SHAPE1[2][3]={1,1,1,
      0,1,0};
static int T_SHAPE2[3][2]={0,1,
      1,1,
      0,1};
static int T_SHAPE3[2][3]={0,1,0,
      1,1,1};
static int T_SHAPE4[3][2]={1,0,
      1,1,
      1,0};
static int L_SHAPE1[3][2]={1,0,
      1,0,
      1,1};
static int L_SHAPE2[2][3]={1,1,1,
      1,0,0};
static int L_SHAPE3[3][2]={1,1,
      0,1,
      0,1};
static int L_SHAPE4[2][3]={0,0,1,
      1,1,1};
static int J_SHAPE1[3][2]={0,1,
      0,1,
      1,1 };
static int J_SHAPE2[2][3]={1,0,0,
      1,1,1};
static int J_SHAPE3[3][2]={1,1,
      1,0,
      1,0 };
static int J_SHAPE4[2][3]={1,1,1,
      0,0,1};
static int Z_SHAPE1[2][3]={1,1,0,
      0,1,1};
static int Z_SHAPE2[3][2]={0,1,
      1,1,
      1,0 };
static int N_SHAPE1[2][3]={0,1,1,
      1,1,0};
static int N_SHAPE2[3][2]={1,0,
      1,1,
      0,1 };
/***************************定义方块的结构体*****************************/
struct block
{char type;/*方块的类型，共有I,O,T,L,J,Z,N七种类型*/
 int shape;/*每种方块的具体形状*/
 int x;/*方块最左上方的横坐标*/
 int y;/*方块最左上方的横坐标*/
 int color;/*方块的颜色*/
};
/***************************函数申明***********************************/
int ini_graph();/*初始化连接图形库graphic.h的驱动*/
int check_bottom();/*判断方块是否到容器底或下方已有别的方块，有则返回1，否则返回0*/
int check_top();/*判断方块是否到容器顶,也是游戏结束标志*/
int check_lborder();/*判断方块是否到容器左边缘或左边已有别的方块*/
int check_rborder();/*判断方块是否到容器右边缘或右边已有别的方块*/
int del_line();/*判断一行是否已满，如满则消格，返回1，否则返回0*/
void initial();/*初始化所有全局变量和界面*/
void restart();/*游戏结束后询问用户是退出还是重玩*/
void help();/*显示按键的帮助信息*/
void showscore();/*显示分数的界面*/
void test();/*测试grid[i][j]用的调试函数*/
void drawbar();/*画游戏的容器*/
void ini_grid();/*画容器里的格子*/
void show_next();/*在屏幕右上方显示下一个方块的信息*/
void drawblock();/*画方块*/
void clear_block();/*清除方块*/
void printscore();/*打印分数和关数*/
struct block create();/*随机产生一个新的方块*/
struct block change();/*旋转变换函数*/
/***************************主函数**********************************/
void main()
{int key;/* 用户按键*/
struct  block  nextblock,mblock;/*nextblock--下一个方块，mblock－－现在的方块*/
initial();
help(420,200);
showscore();
printscore();
nextblock=create();
loop: if(check_top(mblock)) restart();/*如果方块没到容器顶，进行loop循环*/
  printscore() ;
      mblock=nextblock;
      nextblock=create();
      show_next(nextblock);
while(1)
 { if(bioskey(1)!=0) key=bioskey(0);
      else key=0;
     switch(key)
     { case DOWN:{ if(check_bottom(mblock)==1)
        {  if(! del_line(mblock.y))
  { mblock.color=DARKGRAY;
   drawblock(mblock);}goto loop;}
    clear_block(mblock);
     mblock.y=mblock.y+20;
     drawblock(mblock);
   }
    break;
       case UP: mblock=change(mblock);break;
       case LEFT: if(!check_lborder(mblock)&&!check_bottom(mblock))
       {clear_block(mblock);mblock.x-=20;}  break;
       case RIGHT:if(!check_rborder(mblock)&&!check_bottom(mblock))
      {clear_block(mblock);mblock.x+=20;}
    break;
       case F1:test();break;
       case ESC: setfillstyle(1, DARKGRAY);
   bar(0,465,640,480);
   outtextxy(5,469,"Are you sure to exit (Y/N)...");
   while(1)
     { key=bioskey(0);
       if (key==NO)
                {initial();help(420,200);showscore();printscore();goto loop;}
                if(key==YES)
    {closegraph();exit(1);}
      }               break;
       default:{ if(check_bottom(mblock)==1)
   {  if(! del_line(mblock.y))
    { mblock.color=DARKGRAY;
    drawblock(mblock);
    }
    goto loop;
   }
    clear_block(mblock);
     mblock.y=mblock.y+20;
     drawblock(mblock);
      delay(interval);
        }
      }/*switch*/
  }/*while*/
}/*main*/
/*初始化所有全局变量和界面*/
void initial()
{int i,j;
 score=0;
 interval=500;
 for(i=0;i<20;i++)
  for(j=0;j<10;j++)
grid[i][j]=0;
ini_graph();
drawbar();
ini_grid();
}
/*画游戏的容器*/
void drawbar()
{int left,top,right,bottom;
left=200;
top= 40;
right=400;
bottom=440;
setfillstyle(1,LIGHTBLUE);
bar(left,top,right,bottom);
bar(480,40,560,120);
}
/*在容器画 20*10 的格子 */
void ini_grid()
{int i,j;
for(i=0;i<10;i++)
for(j=0;j<20;j++)
{rectangle(200+i*20,40+j*20,200+i*20+20,40+j*20+20);/*画主容器的格子*/
 }
for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 rectangle(480+i*20,40+j*20,480+i*20+20,40+j*20+20);/*画显示下一个方块的格子*/
}
/*随机产生一个新的方块*/
struct block create()
{struct block newblock ;
 int r;
 r=random(7);
 switch(r)
 {case(0):newblock.type='I';newblock.color=5; break;
  case(1):newblock.type='O';newblock.color=BLUE; break;
  case(2):newblock.type='T';newblock.color=BROWN; break;
  case(3):newblock.type='L';newblock.color=YELLOW; break;
  case(4):newblock.type='J';newblock.color=LIGHTGREEN; break;
  case(5):newblock.type='Z';newblock.color=GREEN; break;
  case(6):newblock.type='N';newblock.color=RED; break;
 }
 newblock.shape=1;
 newblock.x=300;
 newblock.y=40;
 return newblock;
}
/*消格函数，传递参数为方块的左上方的纵坐标值，如有消格，返回0，否则返回1*/
int del_line(int ty)
{int i,j ,b,i0,k,ret;
ret=0;
if (ty>=440) return 0;
i0=(ty-40)/20;
if(i0==19||i0==18||i0==17)b=19;
else b=i0+3;
for(k=i0;k<=b;k++)
 { for(j=0;j<10;j++)
   if(!grid[k][j])  break;
   if(j==10)  {score++;
        ret=1;
        for(i=k;i>0;i--)
        for(j=0;j<10;j++)
  { grid[i][j]=grid[i-1][j];
      if(!grid[i][j])
     {setfillstyle(1,LIGHTBLUE);
      setcolor(WHITE);
      rectangle(200+j*20,40+i*20,200+j*20+20,40+i*20+20);
      floodfill(200+j*20+10,40+i*20+10,WHITE);
     }
   else {setfillstyle(9,DARKGRAY);
         setcolor(DARKGRAY);
         rectangle(200+j*20,40+i*20,200+j*20+20,40+i*20+20);
         floodfill(200+j*20+10,40+i*20+10,DARKGRAY);
        }
  }
     }
 }
return ret;
}
/*判断方块是否到容器左边界或左方已有别的方块，有则返回1，否则返回0
传递参数为当前的的block结构实例变量， */
 int check_lborder(struct block cblock)
 {int i0,j0;
  j0=(cblock.x-200)/20;
  i0=(cblock.y-40)/20;
  if(cblock.x<=200) return 1;/*已经到达容器左边界*/
  switch(cblock.type)
   {case('I'):if(grid[i0][j0-1]) return 1; break;/*左边已有其他静止的方格*/
    case('O'):if(grid[i0][j0-1]) return 1; break;
    case('L'): switch(cblock.shape)
        {case(1):if(grid[i0][j0-1]||grid[i0+1][j0-1]||grid[i0+2][j0-1])
    return 1;  break;
        case(2):if(grid[i0][j0-1]||grid[i0+1][j0-1])
    return 1;     break;
        case(3):if(grid[i0][j0-1]||grid[i0+1][j0]||grid[i0+2][j0])
     return 1;   break;
        case(4): if(grid[i0][j0-1]||grid[i0+1][j0-1])
    return 1;break;
        }           break;
    case('J'):switch(cblock.shape)
        {case(1):if(grid[i0][j0]||grid[i0+1][j0]||grid[i0+2][j0-1])
      return 1;  break;
        case(2):if(grid[i0][j0-1]||grid[i0-1][j0-1])
    return 1;     break;
        case(3):if(grid[i0][j0-1]||grid[i0+1][j0-1]||grid[i0+2][j0-1])
     return 1;   break;
        case(4): if(grid[i0][j0-1]||grid[i0+1][j0+1])
     return 1;      break;
        }    break;
    case('T'):break;
    case('Z'):break;
    case('N'):break;
   }


 return 0;
 }
/*判断方块是否到容器右边界或右方已有别的方块，有则返回1，否则返回0
传递参数为当前的的block结构实例变量， */
int check_rborder(struct block cblock)
{int i0,j0;
j0=(cblock.x-200)/20;/*把方块的左上方的坐标x,y换算成相应数组grid[i][j]的下标i0,j0*/
i0=(cblock.y-40)/20;
switch(cblock.type)
  {case('I'):if(cblock.shape==1)
      {if(cblock.x+80>=400||grid[i0][j0+4]) return 1;}/*已经到达容器右边界或左边已有方块*/
       else {if(cblock.x+20>=400||grid[i0][j0+1])return 1;}
  break;
   case('O'): if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+2])
  return 1;   break;
   case('T'): switch(cblock.shape)
        {case(1): if(cblock.x+60>=400||grid[i0][j0+3]||grid[i0+1][j0+2])
       return 1;break;
  case(3): if(cblock.x+60>=400||grid[i0+1][j0+3]||grid[i0][j0+2])
       return 1;break;

  case(2):if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+2]||grid[i0+2][j0+2])
     return 1;break;
  case(4):if(cblock.x+40>=400||grid[i0][j0+1]||grid[i0+2][j0+1]||grid[i0+1][j0+2])
     return 1;break;
        }
    break;
   case('L'):switch(cblock.shape)
        {case(1): if(cblock.x+40>=400||grid[i0+2][j0+2]||grid[i0][j0+1]||grid[i0+1][j0+1])
         return 1;break;
  case(2): if(cblock.x+60>=400||grid[i0][j0+3]||grid[i0+1][j0+3])
     return 1;break;
  case(3): if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+2]||grid[i0+2][j0+2])
     return 1;break;
  case(4): if(cblock.x+60>=400||grid[i0][j0+3]||grid[i0+1][j0+3])
         return 1;break;
        } break;
   case('J'):switch(cblock.shape)
       {case(1): if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+2]||grid[i0+2][j0+2])
         return 1;break;
  case(2):if(cblock.x+60>=400||grid[i0][j0+1]||grid[i0+1][j0+3])
     return 1;break;
  case(3): if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+1]||grid[i0+2][j0+1])
     return 1;break;
  case(4): if(cblock.x+60>=400||grid[i0][j0+3]||grid[i0+1][j0+3])
         return 1;break;
        } break;
   case('Z'): switch(cblock.shape)
        {case(1): if(cblock.x+60>=400||grid[i0][j0+2]||grid[i0+1][j0+3])
       return 1;break;
  case(2):if(cblock.x+40>=400||grid[i0][j0+2]||grid[i0+1][j0+2]||grid[i0+2][j0+1])
     return 1;break;
        }break;
   case('N'): switch(cblock.shape)
        {case(1): if(cblock.x+60>=400||grid[i0][j0+3]||grid[i0+1][j0+2])
       return 1;break;
  case(2):if(cblock.x+40>=400||grid[i0][j0+1]||grid[i0+1][j0+2]||grid[i0+2][j0+2])
     return 1;break;
        } break;
  }
 return 0;
}
/*旋转变换函数，本游戏的核心程序之一，
传递参数为当前的的block结构实例变量，
判断当前位置是否能变换后 ，若能
返回变换后的block实例变量，否则
返回就原来传进来的block实例变量 */
struct block change(struct block cblock)
{int i,j,i0,j0;
j0=(cblock.x-200)/20;/*把方块的左上方的坐标x,y换算成相应数组grid[i][j]的下标i0,j0*/
i0=(cblock.y-40)/20;
 switch(cblock.type)
 {case('I'):switch(cblock.shape)
    { case(1):if (grid[i0+2][j0+1]||grid[i0+3][j0+1])
       return cblock;
       clear_block(cblock); cblock.x+=20; cblock.shape++;break;
      case(2):if (grid[i0][j0-1]||grid[i0][j0+1] || grid[i0][j0+2]||cblock.x>=360||cblock.x<=200)
       return cblock;/*如果变换后的格子上已经有其他方块，
                                     或变换后方块超出则不变换*/
       clear_block(cblock); cblock.x-=20;/*否则清楚原来的方块，计算出变换新的坐标*/
                     cblock.shape--;/*同一类型的方块进入下一个形状*/
                      break;
    }
   break;
  case('T'):switch(cblock.shape)
     {case(1):if(grid[i0-1][j0+1]) return cblock;
        clear_block(cblock);cblock.y-=20;
       cblock.shape++;  break;
      case(2):if(cblock.x>=360||grid[i0+1][j0+2])  return cblock;
        clear_block(cblock);cblock.shape++;break;
      case(3):if(grid[i0-1][j0+1]||grid[i0][j0+2])
       return cblock;
       clear_block(cblock);cblock.x+=20;cblock.y-=20;
     cblock.shape++;break;
      case(4):if(cblock.x<=200||grid[i0+1][j0-1])
       return cblock;
       clear_block(cblock);cblock.y+=20;cblock.x-=20;
       cblock.shape=1;  break;
     }                      break;
  case('L'):switch(cblock.shape)
     {case(1):if(grid[i0+2][j0-1]||grid[i0+1][j0+1]||cblock.x<=200)
       return cblock;
       clear_block(cblock);cblock.y+=20; cblock.x-=20;
       cblock.shape++;  break;
      case(2): if(grid[i0-1][j0]||grid[i0-1][j0+1]||grid[i0+1][j0+1])
        return cblock;
        clear_block(cblock);cblock.y-=20;
        cblock.shape++;break;
      case(3): if(grid[i0+2][j0-1]||grid[i0+2][j0]||cblock.x<=200)
       return cblock;
       clear_block(cblock);cblock.y+=20;cblock.x-=20;
       cblock.shape++;break;
      case(4): if(grid[i0][j0+1]||grid[i0-1][j0+1])
        return cblock;
        clear_block(cblock);cblock.y-=20;cblock.x+=20;
       cblock.shape=1;  break;
     }
     break;
  case('J'): switch(cblock.shape)
     {case(1):if(grid[i0+1][j0]||grid[i0+2][j0+2]||cblock.x>=360)
       return cblock;
       clear_block(cblock);cblock.y+=20;
       cblock.shape++;  break;
      case(2): if(grid[i0-1][j0+1]||grid[i0-1][j0])
       return cblock;
       clear_block(cblock);cblock.y-=20;
       cblock.shape++;break;
      case(3):if(grid[i0+1][j0+1]||grid[i0+2][j0+1]||grid[i0+1][j0-1])
       return cblock;
       clear_block(cblock);cblock.y+=20;cblock.x-=20;
        if(grid[i0-1][j0]||grid[i0-1][j0+1]||cblock.x<=200)
       return cblock;
       cblock.shape++;break;
      case(4): if(grid[i0-1][j0-2]||grid[i0+1][j0+1])
       return cblock;
       clear_block(cblock);cblock.y-=20;cblock.x+=20;
       cblock.shape=1;  break;
     }
        break;
   case('Z'):switch(cblock.shape)
    { case(1):if(grid[i0-1][j0+1]||grid[i0+1][j0])
       return cblock;
       clear_block(cblock);cblock.y-=20;
       cblock.shape++;break;
      case(2): if(grid[i0+2][j0+1]||grid[i0+2][j0+2])
        return cblock;
        clear_block(cblock);cblock.y+=20;
        cblock.shape--;break;
    }break;
   case('N'):switch(cblock.shape)
    { case(1):if(grid[i0][j0]||grid[i0-1][j0])
        return cblock;
       clear_block(cblock); cblock.y-=20;
       cblock.shape++;break;
      case(2):if(grid[i0+2][j0]||grid[i0+1][j0+2]||cblock.x>=360)
       return cblock;
       clear_block(cblock); cblock.y+=20; cblock.shape--;break;
    }break;
 }
return cblock;/*返回变换后的方块*/
}
/*画方块函数，传递参数为当前block实例变量*/
void drawblock(struct block drblock)
{int i0,j0,i,j;
j0=(drblock.x-200)/20;/*把方块的左上方的坐标x,y换算成相应数组grid[i][j]的下标i0,j0*/
i0=(drblock.y-40)/20;
setfillstyle(9,drblock.color);
setcolor(drblock.color);
switch(drblock.type)
 {case('I'):if(drblock.shape==1)
     { for(j=0;j<4;j++)
       { rectangle(drblock.x+j*20,drblock.y,drblock.x+j*20+20,drblock.y+20);/*画方块格子*/
  floodfill(drblock.x+j*20+10,drblock.y+10,drblock.color);/*蔓延填充方块*/
  grid[i0][j0+j]+=I_SHAPE1[0][j];/*将定义的形状与grid数组相加*/
       }                                /*这样有格子的相应grid数组元素就加1*/
     }
    if(drblock.shape==2)
     { for(i=0;i<4;i++)
       { rectangle(drblock.x,drblock.y+20*i,drblock.x+20,drblock.y+20*i+20);
  floodfill(drblock.x+10,drblock.y+20*i+10,drblock.color);
  grid[i0+i][j0]+=I_SHAPE2[i][0];
       }
     }break;
  case('O'):for(i=0;i<2;i++)
     for(j=0;j<2;j++)
      {rectangle(drblock.x+i*20,drblock.y+j*20,drblock.x+i*20+20,drblock.y+j*20+20);
       floodfill(drblock.x+i*20+10,drblock.y+j*20+10,drblock.color);
      grid[i0+i][j0+j]+=O_SHAPE[i][j];
      }
     break;
  case('T'): switch(drblock.shape)
      {case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=T_SHAPE1[i][j] ;
         if(T_SHAPE1[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break ;
       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=T_SHAPE2[i][j] ;
         if(T_SHAPE2[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }  break ;
       case(3):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=T_SHAPE3[i][j] ;
         if(T_SHAPE3[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }break ;
       case(4): for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=T_SHAPE4[i][j] ;
         if(T_SHAPE4[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
         } break ;
     } break;
  case('L'):  switch(drblock.shape)
      {case(1):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=L_SHAPE1[i][j] ;
         if(L_SHAPE1[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break ;
       case(2):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=L_SHAPE2[i][j] ;
         if(L_SHAPE2[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }  break ;
       case(3):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=L_SHAPE3[i][j] ;
         if(L_SHAPE3[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }break ;
       case(4): for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=L_SHAPE4[i][j] ;
         if(L_SHAPE4[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
         }      break ;
     }
        break;
  case('J'): switch(drblock.shape)
      {case(1):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=J_SHAPE1[i][j] ;
         if(J_SHAPE1[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break ;
       case(2):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=J_SHAPE2[i][j] ;
         if(J_SHAPE2[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }  break ;
       case(3):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=J_SHAPE3[i][j] ;
         if(J_SHAPE3[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break;
      case(4): for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=J_SHAPE4[i][j] ;
         if(J_SHAPE4[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
         } break ;
     } break;
  case('Z'):switch(drblock.shape)
     { case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=Z_SHAPE1[i][j] ;
         if(Z_SHAPE1[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break ;
       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=Z_SHAPE2[i][j] ;
         if(Z_SHAPE2[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }  break ;
      } break;
  case('N'):switch(drblock.shape)
     { case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {grid[i0+i][j0+j]+=N_SHAPE1[i][j] ;
         if(N_SHAPE1[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        } break ;
       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {grid[i0+i][j0+j]+=N_SHAPE2[i][j] ;
         if(N_SHAPE2[i][j]==1)
   {rectangle(drblock.x+j*20,drblock.y+i*20,drblock.x+j*20+20,drblock.y+i*20+20);
    floodfill(drblock.x+j*20+10,drblock.y+i*20+10,drblock.color);
   }
        }  break ;
      } break;
 }
}
/*清楚原来的方块，用原来容器的方格填充
传递参数为当前的block实例变量*/
void clear_block(struct block cblock)
{ int i,j,i0,j0;
j0=(cblock.x-200)/20;/*把方块的左上方的坐标x,y换算成相应数组grid[i][j]的下标i0,j0*/
i0=(cblock.y-40)/20;
setfillstyle(1,LIGHTBLUE);/*设置填充色为原容器格子的颜色*/
setcolor(WHITE);/*恢复原来的前景色*/
  switch(cblock.type)
 {case('I'):if(cblock.shape==1)
     { for(j=0;j<4;j++)
       {rectangle(cblock.x+j*20,cblock.y,cblock.x+j*20+20,cblock.y+20);/*画原容器的格子*/
  floodfill(cblock.x+j*20+10,cblock.y+10,WHITE);/*蔓延填充*/
  grid[i0][j0+j]=0;/*清零，即该格已经没有方块*/
       }
     }
    if(cblock.shape==2)
     { for(i=0;i<4;i++)
       { rectangle(cblock.x,cblock.y+20*i,cblock.x+20,cblock.y+20*i+20);
  floodfill(cblock.x+10,cblock.y+20*i+10,WHITE);
  grid[i0+i][j0]=0;
       }
     }break;
  case('O'):for(i=0;i<2;i++)
     for(j=0;j<2;j++)
      {rectangle(cblock.x+i*20,cblock.y+j*20,cblock.x+i*20+20,cblock.y+j*20+20);
       floodfill(cblock.x+i*20+10,cblock.y+j*20+10,WHITE);
      grid[i0+i][j0+j]=0;
      }
     break;
  case('T'): switch(cblock.shape)
      {case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
       { if(T_SHAPE1[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
         grid[i0+i][j0+j]=0 ; }
        } break ;

       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        { if(T_SHAPE2[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0 ;
   }
        }  break ;
       case(3):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        { if(T_SHAPE3[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        }break ;
       case(4): for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        { if(T_SHAPE4[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
         grid[i0+i][j0+j]=0; }
         } break ;
     } break;
 case('L'):  switch(cblock.shape)
      {case(1):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {if(L_SHAPE1[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        } break ;
       case(2):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {if(L_SHAPE2[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
     grid[i0+i][j0+j]=0;
   }
        }  break ;
       case(3):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {if(L_SHAPE3[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
     grid[i0+i][j0+j]=0;
   }
        }break ;
       case(4): for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        {if(L_SHAPE4[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
     grid[i0+i][j0+j]=0;
   }
         } break ;
     }
        break;
  case('J'): switch(cblock.shape)
      {case(1):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        { if(J_SHAPE1[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
     grid[i0+i][j0+j]=0;
   }
        } break ;
       case(2):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        { if(J_SHAPE2[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
   floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        }  break ;
       case(3):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {if(J_SHAPE3[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        } break;
      case(4): for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        { if(J_SHAPE4[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
         } break ;
     } break;
  case('Z'):switch(cblock.shape)
     { case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        { if(Z_SHAPE1[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        } break ;
       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {if(Z_SHAPE2[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        }  break ;
      } break;
  case('N'):switch(cblock.shape)
     { case(1):for(i=0;i<2;i++)
        for(j=0;j<3;j++)
        { if(N_SHAPE1[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        } break ;
       case(2):for(i=0;i<3;i++)
        for(j=0;j<2;j++)
        {  if(N_SHAPE2[i][j]==1)
   {rectangle(cblock.x+j*20,cblock.y+i*20,cblock.x+j*20+20,cblock.y+i*20+20);
    floodfill(cblock.x+j*20+10,cblock.y+i*20+10,WHITE);
    grid[i0+i][j0+j]=0;
   }
        }  break ;
      } break;
 }
}
/*判断方块是否到容器顶,也是游戏结束标志，如到顶则返回1，否则返回0*/
int check_top(struct block tblock)
{ if(tblock.y==40)  return 1;
   else return 0;
}
/*判断方块是否到容器底或下方已有别的方块，有则返回1，否则返回0*/
int check_bottom(struct block nblock)
{ int j,i0,j0;
 j0=(nblock.x-200)/20;
 i0=(nblock.y-40)/20;
  switch(nblock.type)
 {case('I'): if(nblock.shape==1)
        {if(nblock.y==420)  return 1;/*已经到达容器底部*/
  for(j=0;j<4;j++)
  if(grid[i0+1][j0+j]) return 1;/*I型方块下面一格已有静止方块*/
        }
        if(nblock.shape==2)
        {if(nblock.y==360)  return 1;
  if(grid[i0+4][j0]) return 1;
        }
        break;
  case('O'): if(nblock.y==400) return 1;
      for(j=0;j<2;j++)
      if (grid[i0+2][j0+j]) return 1;
      break;
  case('T'):switch(nblock.shape)
      {case(1):if(nblock.y==400)  return 1;
        if(grid[i0+2][j0+1]||grid[i0+1][j0]||grid[i0+1][j0+2])
    return 1;
        break;
       case(2):if(nblock.y==380) return 1;
        if(grid[i0+3][j0+1]||grid[i0+2][j0]) return 1; break;
       case(3):if(nblock.y==400) return 1;
        for(j=0;j<3;j++)
        if(grid[i0+2][j0+j]) return 1;  break;
       case(4):if(nblock.y==380) return 1;
        if(grid[i0+3][j0]||grid[i0+2][j0+1]) return 1;break;
      } break;
  case('L'): switch(nblock.shape)
      {case(1):if (nblock.y>=380) return 1;
        if (grid[i0+3][j0]||grid[i0+3][j0+1])
     return 1;      break;
       case(2):if(nblock.y>=400) return 1;
        if(grid[i0+2][j0]||grid[i0+1][j0+1]||grid[i0+1][j0+2])
        return 1; break;
       case(3):if (nblock.y>=380) return 1;
        if (grid[i0+3][j0+1]||grid[i0+1][j0])
     return 1;      break;
       case(4):if (nblock.y>=400) return 1;
    for(j=0;j<3;j++)
     if(grid[i0+2][j0+j])
     return 1;      break;
      }
      break;
  case('J'):switch(nblock.shape)
      {case(1):if (nblock.y>=380) return 1;
        if (grid[i0+3][j0]||grid[i0+3][j0+1])
     return 1;      break;
       case(2):if (nblock.y>=400) return 1;
     for(j=0;j<3;j++)
     if(grid[i0+2][j0+j])
     return 1;   break;
       case(3):if (nblock.y>=380) return 1;
        if (grid[i0+3][j0]||grid[i0+1][j0+1])
     return 1;      break;

       case(4):if (nblock.y>=400) return 1;
        if (grid[i0+2][j0+2]||grid[i0+1][j0]||grid[i0+1][j0+1])
     return 1;      break;
      }     break;
  case('Z'):if (nblock.shape==1)
       { if(nblock.y==400) return 1;
  if(grid[i0+1][j0]||grid[i0+2][j0+1]||grid[i0+2][j0+2])
      return 1;    }
     if (nblock.shape==2)
       { if(nblock.y==380) return 1;
  if(grid[i0+3][j0]||grid[i0+2][j0+1])
      return 1;    } break;
  case('N'):if(nblock.shape==1)
        { if(nblock.y==400) return 1;
  if(grid[i0+1][j0+2]||grid[i0+2][j0+1]||grid[i0+2][j0])
      return 1;
        }
      if(nblock.shape==2)
        { if(nblock.y==380) return 1;
   if(grid[i0+2][j0]||grid[i0+3][j0+1])
      return 1;
        }
        break;

 }
return 0;
}
/*在屏幕右上方显示下一个方块的信息*/
void show_next(struct block nextblock)
{int i,j,g[4][4];
setfillstyle(1,LIGHTBLUE);
setcolor(WHITE);
for(i=0;i<4;i++)
 for(j=0;j<4;j++)
{ rectangle(480+i*20,40+j*20,480+i*20+20,40+j*20+20);
 floodfill( 480+i*20+10,40+20*j+10,WHITE);
}
setfillstyle(9,nextblock.color);
setcolor(nextblock.color);
 switch (nextblock.type)
  {case('I'):   for(j=0;j<4;j++)
   {rectangle(480+j*20,60,480+j*20+20,60+20);
    floodfill(480+j*20+10,60+10,nextblock.color);
   }
  break;
   case('O'): for(i=0;i<2;i++)
       for(j=0;j<2;j++)
       { rectangle(500+20*i,60+20*j,500+20*i+20,60+20*j+20);
  floodfill(500+20*i+10,60+20*j+10,nextblock.color);
       }break ;
   case('T'):   for(i=0;i<2;i++)
  for(j=0;j<3;j++)
   {g[i][j]=T_SHAPE1[i][j];
    if(g[i][j]==1)
      { rectangle(480+j*20,60+i*20,480+j*20+20,60+i*20+20);
        floodfill(480+j*20+10,60+i*20+10,nextblock.color);
      }
   }
    break;
   case('L'):    for(i=0;i<3;i++)
   for(j=0;j<2;j++)
   {g[i][j]=L_SHAPE1[i][j];
    if(g[i][j]==1)
      { rectangle(500+j*20,40+i*20,500+j*20+20,40+i*20+20);
        floodfill(500+j*20+10,40+i*20+10,nextblock.color);
      }
   }break;

   case('J') :  for(i=0;i<3;i++)
   for(j=0;j<2;j++)
   {g[i][j]=J_SHAPE1[i][j];
    if(g[i][j]==1)
      { rectangle(500+j*20,40+i*20,500+j*20+20,40+i*20+20);
        floodfill(500+j*20+10,40+i*20+10,nextblock.color);
      }
   }break;
   case('Z'):      for(i=0;i<2;i++)
   for(j=0;j<3;j++)
   {g[i][j]=Z_SHAPE1[i][j];
    if(g[i][j]==1)
      { rectangle(500+j*20,60+i*20,500+j*20+20,60+i*20+20);
        floodfill(500+j*20+10,60+i*20+10,nextblock.color);
      }
   }break;

   case('N'):  for(i=0;i<2;i++)
   for(j=0;j<3;j++)
   {g[i][j]=N_SHAPE1[i][j];
    if(g[i][j]==1)
      { rectangle(500+j*20,60+i*20,500+j*20+20,60+i*20+20);
        floodfill(500+j*20+10,60+i*20+10,nextblock.color);
      }
   }break;
 }
}
/*test the  grid array's value*/
void test()
{int i,j;
gotoxy(1,1);
for (i=0;i<20;i++)
{for (j=0;j<10;j++)
printf ("%2d",grid[i][j]);
printf ("/n");
}
}

/*initial the graphic driver*/
int ini_graph(void)
{
   /* request auto detection */
   int gdriver = DETECT, gmode, errorcode;
   int left, top, right, bottom;

   /* initialize graphics and local variables */
   initgraph(&gdriver, &gmode, "");

   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)  /* an error occurred */
   {
      printf("Graphics error: %s/n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1); /* terminate with an error code */
   }

   return 0;

}
/*show the game information  on right*/
void help(int xs,int ys){
 setcolor(15);
 rectangle(xs-3,ys-3,xs+200,ys+150);
 line (xs-3,ys+26,xs+200,ys+26);
 line (xs-3,ys+72,xs+200,ys+72);
 line(xs+39,ys+26,xs+39,ys+72);
 setcolor(12);
 outtextxy(xs+60,ys+8,"Welcome!!");
 setcolor(14);
 outtextxy(xs,ys+45,"HELP:");
 outtextxy(xs+55,ys+30,"->-Left ;<--Right");
 outtextxy(xs+55,ys+45,"^-Change");
 outtextxy(xs+55,ys+60,"ESC-Exit;R-Restar");
 outtextxy(xs,ys+75,"Russia Diamonds ");
 outtextxy(xs,ys+90,"CopyRight By FANZ.com");
 outtextxy(xs,ys+105,"Date:15/12/2001");
 outtextxy(xs,ys+120,"E-mail:Fanz@263.net");
}
/*show score and level*/
void showscore(){
 int cur[8];
cur[0]=420;
cur[1]=360;
cur[2]=cur[0] ;
cur[3]=cur[1]+50;
cur[4]=cur[2]+203;
cur[5]=cur[3];
cur[6]=cur[4];
cur[7]=cur[5]-50;
 setcolor(LIGHTBLUE);
  setfillstyle(7,LIGHTBLUE);

fillpoly(4,cur);
setcolor(13);
 outtextxy(480,380,"Score:");
 outtextxy(480,390,"Level:");
}
/*显示并刷新分数和关数*/
void printscore()
{ char sscore[6];
 char slevel[2];
 settextstyle(0,0,0);
 level=score/100+1;
 if (level>=5) level=1;
 interval=550-level*50;
   showscore();
 setcolor(RED);
 sprintf(sscore,"%d",score);
 sprintf(slevel,"%d",level);
 outtextxy (540,390,slevel);
 outtextxy (540,380,sscore);
 }
/*在屏幕右上方显示下一个方块的信息*/
void restart()
{ int key;
   delay(1000);
   setfillstyle(1,10);
   settextstyle(0,0,6);
   setcolor(3);
   outtextxy(102,152,"GAME OVER");
   setcolor(3);
   outtextxy(99,149,"GAME OVER");
   setcolor(10);
   outtextxy(96,146,"GAME OVER");
   delay(1000);
   setcolor(0);
   settextstyle(0,0,2);
   outtextxy(222,242,"R__Again!");
   outtextxy(232,282,"ESC__Exit!");
   setcolor(10);
   outtextxy(220,240,"R__Again!");
   outtextxy(230,280,"ESC__Exit!");
   while(1)
   { key=bioskey(0);
     if (key==RESTART)
      {initial();return;}
     if(key==ESC)
      {closegraph();exit(1);}
   }
}

fanz2000
关注
C语言编写的俄罗斯方块（附源码）
11-06
API：Windows API 工具：VC++6.0 （源码都有注释的，供大家学习，写的不好的地方请不吝赐教） 今年刚毕业的，自从学习C语言以来，一直有一个小小的愿望——“自己动手写一个俄罗斯方块”，今天终于实现了，查了很多资料，包括DOS下的编程、SDL、OPENGL等等，最后还是确定用Windows API来做，刚好要学习Windwos编程 游戏说明：左右键控制方向，下键加速，上键变形，空格暂停
c语言编写的俄罗斯方块小游戏
08-16
该俄罗斯方块小游戏是由c语言编写而成。只要在能运行c程序的编译器上就能运行。希望大家喜欢
俄罗斯方块（C语言实现）
热门推荐
2021dragon的博客
08-14 17万+
文章目录游戏说明游戏效果展示游戏代码游戏代码详解游戏框架构建隐藏光标光标跳转初始化界面初始化方块信息颜色设置画出方块空格覆盖合法性判断游戏主体逻辑函数判断得分与结束主函数 游戏说明 俄罗斯方块相信大家都知道，这里就不再介绍什么游戏背景了，我这里对本代码实现的俄罗斯方块作一些说明： 按方向键的左右键可实现方块的左右移动。 按方向键的下键可实现方块的加速下落。 按空格键可实现方块的顺时针旋转。 按Esc键可退出游戏。 按S键可暂停游戏，暂停游戏后按任意键继续游戏。 按R键可重新开始游戏。 除此之外，本游戏还
c语言实现俄罗斯方块
最新发布
cuitlse的博客
08-11 766
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语言编写的 俄罗斯方块小游戏（tetris game）
编码人生——朝阳_tony
06-27 4795
摘要： 还记得当前我们玩过的俄罗斯方块吗 ，在linux系统下编译安装试试,O(∩_∩)O~
C语言——俄罗斯方块
sinat_43009982的博客
11-02 853
最近朋友找到一个用c写的俄罗斯方块代码，试玩了一下，非常有趣。 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;time.h&amp;amp;gt; #include&amp;amp;lt;windows.h&amp;amp;gt; #include&amp;amp;lt;c
c语言Turbo C下写的俄罗斯方块
09-21
c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯方块 c语言Turbo C下写的俄罗斯...
C语言实现俄罗斯方块
12-25
本文实例为大家分享了C语言俄罗斯方块的具体代码，供大家参考，具体内容如下 本代码运行环境是Windows下的VS2013 首先创建tetris.cpp 然后依次创建view.h以及view.cpp、model.h以及model.cpp。 代码如下： view.h ...
c语言俄罗斯方块完整源码
09-21
c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言...
C语言写俄罗斯方块.rar
05-29
俄罗斯方块的界面通常由一个矩形网格构成，我们可以用二维字符数组来模拟这个网格。每个单元格可以是空格（表示无方块）或特定字符（表示方块）。C语言中的标准输入输出库（stdio.h）提供printf函数用于屏幕输出，...
俄罗斯方块（C语言版） 俄罗斯方块
01-24
【俄罗斯方块（C语言版） 俄罗斯方块】是一个基于C语言实现的经典游戏项目，它将编程技术与游戏设计巧妙结合，展示了C语言在创建交互式程序方面的潜力。在这个项目中，开发者利用C语言的基本结构，如循环、条件语句...
c语言编写的俄罗斯方块
06-01
这是一个好东东!往往往往外我 我 我 我
用C编的俄罗斯方块
02-23
用C编的俄罗斯方块
用c语言编写的具有人性化界面的俄罗斯方块
03-03
功能：具有人性化界面的俄罗斯方块。具有基本的操作功能。 知识点： 1.面向对象即构造合适的数据结构。俄罗斯方块的7种形状四个方向的数据结构。 int Block_Type_Array[7][5]= //所有俄罗斯方块类型的对应的整形码值 { 0xF000,0x4444,0xF000,0x4444,0xFF0000, //I 字型 0x0660,0x0660,0x0660,0x0660,0x0000FF, //田 字型 0x0e40,0x4c40,0x4e00,0x4640,0xFFFF00, //T 字型 0x4460,0x0e80,0xc440,0x2e00,0x00FFFF, //L 字型 0x44c0,0x8e00,0x6440,0x0e20,0xFF00FF, //反L 字型 0x0c60,0x4c80,0xc600,0x2640,0x00FF00, //Z 字型 0x06c0,0x8c40,0x6c00,0x4620,0x99FF33 //反z 字型 }; 2位操作（c的运算符：&，|,^） 3数组与指针（把二维数组作为函数的形参，则需要传进它的地址，即int (*p)[length]） 4获取按键的消息（getch()从控制台无回显地取一个字符，kbhit()判断是否有按键消息） 三、工程介绍 代码量大小为1100行左右，简洁的代码风格。每个函数都有功能介绍，每个全局变量和重要语句都有注释。
俄罗斯方块（C语言实现，用到了C语言的图形库）
11-12
C语言实现的俄罗斯方块游戏，运用到了C的图形库绘制了方块，里面有详细的代码及其部分的文档（绝对原创）
俄罗斯方块C语言版
02-22
俄罗斯方块 C语言版 可以成功运行哦！！！
C语言---------俄罗斯方块（源代码）
qq_44926123的博客
06-27 2万+
#include<stdio.h> #include<windows.h>//字体颜色，窗口 #include<conio.h> #include<stdlib.h> #include<time.h> #include <mmsystem.h> #pragma comment(lib,“winmm.lib”) #define ...
C语言自己写俄罗斯方块（完整版）
weixin_34362875的博客
07-06 636
还记得大笨兔以前在博客发的几篇关于如何使用C语言写俄罗斯方块游戏的文章吗？ C语言自己写俄罗斯方块（一） C语言自己写俄罗斯方块（二） C语言自己写俄罗斯方块（三） C语言自己写俄罗斯方块（四） 当时大笨兔已经将基本的逻辑写完了，但还有两个功能没有加进去：游戏结束和游戏暂停。 所以这次大笨兔抽空就将这两个功能加进去了。上一张图: 打开源代码自己吓了一跳，没有...
C语言图形编程--俄罗斯方块制作(一)详解
菜鸟的自留地-mooyang
12-29 16万+
效果图   用C语言实现俄罗斯方块，需要先解决下面几个问题： 1、如何用C语言绘制图形界面 EasyX图形库(http://www.easyx.cn)即TC的图形库在VC下的移植。   包含库#include 先初始化图形窗口 initgraph(WINDOW_WIDTH, WINDOW_HIGH) ;WINDOW_WIDTH为窗口的宽带，WINDOW_HIGH为窗口的高度。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值