刚写的,需要用NEO图形库,在图形区有.

/*==============================================================================
SK-CHINA 2006-2007 COLOR LINE BY S.K
==============================================================================*/
/*==============================================================================
预处理部分
==============================================================================*/

#define NEO_temp_dir_unused
#define BOARD_COLOR 7

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "neo.h"

/*==============================================================================
全局变量部分
==============================================================================*/

char chesscolor[9][9]={0}; /* 定义棋盘棋子颜色 */
char chessboard[9][9]; /* 定义棋盘空位 */
long grade=0; /* 分数 */

/*==============================================================================
函数部分
==============================================================================*/
/*==============================================================================
检查棋盘是否已满 满返回1,不满返回0.
==============================================================================*/

int boardfull(void) {
int i,t; /* 临时计数 */
for(i=0;i<9;i++)
for(t=0;t<9;t++) if(chessboard[i][t]==1) return 0;
return 1;
}

/*==============================================================================
随机生成棋子.
==============================================================================*/

void buildchess(void) {
int x,y;
do {
x=rand()%9;
y=rand()%9;
}while(chesscolor[y][x]!=0);
chesscolor[y][x]=rand()%7+1;
chessboard[y][x]=0;
delchess(y,x);
}

/*==============================================================================
绘制棋盘.
==============================================================================*/

void drawboard(void) {
int i,t; /* 临时计数 */
for(i=20;i<420;i+=40) hline(20,i,380,BOARD_COLOR);
for(i=20;i<420;i+=40) vline(i,20,380,BOARD_COLOR);
for(i=0;i<9;i++)
for(t=0;t<9;t++)
circlefill(t*40+40,i*40+40,18,chesscolor[i][t]);
}

/*==============================================================================
判断位于第x行,y列的棋子是否能移动到第to_x行,to_y列,可以返回1,否则返回0.
==============================================================================*/

int canmove(int x,int y,int to_x,int to_y) {
if(x==to_x && y==to_y) return 1;
chessboard[x][y]=0;
if(chessboard[x+1][y] && x<8)
if(canmove(x+1,y,to_x,to_y)) {
chessboard[x][y]=1;
return 1;
}
if(chessboard[x-1][y] && x>0)
if(canmove(x-1,y,to_x,to_y)) {
chessboard[x][y]=1;
return 1;
}
if(chessboard[x][y+1] && y<8)
if(canmove(x,y+1,to_x,to_y)) {
chessboard[x][y]=1;
return 1;
}
if(chessboard[x][y-1] && y>0)
if(canmove(x,y-1,to_x,to_y)) {
chessboard[x][y]=1;
return 1;
}

chessboard[x][y]=1;
return 0;
}

/*==============================================================================
判断新增棋子后是否可以消去棋子,可以则消去并返回1,否则返回0.
==============================================================================*/

int delchess(int x,int y) {
int i,j; /* 临时计数 */
int sum=0;
/* 消除竖行 */
for(i=x;i<9;i++) {
if(chesscolor[x][y]!=chesscolor[i][y]) break;
sum++;
}
for(i=x;i>-1;i--) {
if(chesscolor[x][y]!=chesscolor[i][y]) break;
sum++;
}
if(sum>5) {
for(i=x+1;i<9;i++) {
if(chesscolor[x][y]!=chesscolor[i][y]) break;
chesscolor[i][y]=0;
chessboard[i][y]=1;
}
for(i=x-1;i>-1;i--) {
if(chesscolor[x][y]!=chesscolor[i][y]) break;
chesscolor[i][y]=0;
chessboard[i][y]=1;
}
chesscolor[x][y]=0;
chessboard[x][y]=1;
return 1;
}
sum=0;
/* 消除横行 */
for(i=y;i<9;i++) {
if(chesscolor[x][y]!=chesscolor[x][i]) break;
sum++;
}
for(i=y;i>-1;i--) {
if(chesscolor[x][y]!=chesscolor[x][i]) break;
sum++;
}
if(sum>5) {
for(i=y+1;i<9;i++) {
if(chesscolor[x][y]!=chesscolor[x][i]) break;
chesscolor[x][i]=0;
chessboard[x][i]=1;
}
for(i=y-1;i>-1;i--) {
if(chesscolor[x][y]!=chesscolor[x][i]) break;
chesscolor[x][i]=0;
chessboard[x][i]=1;
}
chesscolor[x][y]=0;
chessboard[x][y]=1;
return 1;
}
sum=0;
/* 消除斜行( \ ) */
for(i=x,j=y;(i<9)&&(j<9);i++,j++) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
sum++;
}
for(i=x,j=y;(i>-1)&&(j>-1);i--,j--) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
sum++;
}
if(sum>5) {
for(i=x+1,j=y+1;(i<9)&&(j<9);i++,j++) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
chesscolor[i][j]=0;
chessboard[i][j]=1;
}
for(i=x-1,j=y-1;(i>-1)&&(j>-1);i--,j--) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
chesscolor[i][j]=0;
chessboard[i][j]=1;
}
chesscolor[x][y]=0;
chessboard[x][y]=1;
return 1;
}
sum=0;
/* 消除斜行( / ) */
for(i=x,j=y;(i<9)&&(j>-1);i++,j--) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
sum++;
}
for(i=x,j=y;(i>-1)&&(j<9);i--,j++) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
sum++;
}
if(sum>5) {
for(i=x+1,j=y-1;(i<9)&&(j>-1);i++,j--) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
chesscolor[i][j]=0;
chessboard[i][j]=1;
}
for(i=x-1,j=y+1;(i>-1)&&(j<9);i--,j++) {
if(chesscolor[x][y]!=chesscolor[i][j]) break;
chesscolor[i][j]=0;
chessboard[i][j]=1;
}
chesscolor[x][y]=0;
chessboard[x][y]=1;
return 1;
}
return 0;
}

/*==============================================================================
移动棋子.
==============================================================================*/

void movechess(void) {
int mousex,mousey;
int mousetox,mousetoy;
while(1) {
while(get_click_info()!=8) ;
mousex=get_mouse_x();
mousey=get_mouse_y();
if(mousex<=20 || mousex>=380) continue;
if(mousey<=20 || mousey>=380) continue;
mousex=(mousex-20)/40;
mousey=(mousey-20)/40;
if(chessboard[mousey][mousex]==1) continue;

while(get_click_info()!=8) ;
mousetox=get_mouse_x();
mousetoy=get_mouse_y();
if(mousetox<=20 || mousetox>=380) continue;
if(mousetoy<=20 || mousetoy>=380) continue;
mousetox=(mousetox-20)/40;
mousetoy=(mousetoy-20)/40;
if(chessboard[mousetoy][mousetox]==0) continue;

if(canmove(mousey,mousex,mousetoy,mousetox)) {
chessboard[mousetoy][mousetox]=0;
chessboard[mousey][mousex]=1;
chesscolor[mousetoy][mousetox]=chesscolor[mousey][mousex];
chesscolor[mousey][mousex]=0;
if(delchess(mousetoy,mousetox)) grade+=10;
} else continue;
break;
}
}

/*==============================================================================
主函数.
==============================================================================*/

int main(void) {
int i; /* 临时计数 */
int n=3;
neo_init(); /* 初始化NEO库 */
set_video_mode(640,480,8,0,0); /* 640X480X64K模式 */
install_keyboard(); /* 加载高级键盘 */
_install_timer(); /* 加载时钟 */
change_timer(200); /* 改变(时钟频率)鼠标刷新频率为200次/秒 */
install_mouse(); /* 加载高级鼠标 */
srand(100); /* 初始化随机函数 */

memset(chessboard,1,sizeof(chessboard));

for(i=0;i<n;i++) buildchess();
while(!boardfull()) {
scare_mouse();
drawboard(); /* 绘制棋盘 */
rectfill(0,0,640,16,0);
neo_printf(0,0,"当前分数:%ld",grade);
unscare_mouse();
movechess();
for(i=0;i<n;i++) if(!boardfull()) buildchess();
}
scare_mouse();
drawboard(); /* 绘制棋盘 */
neo_printf(0,390,"游戏结束Game over.");
_getch();
return 0;
}

我在网上找的 俄罗斯方块
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#include <graphics.h>
#include <stdlib.h>

#ifdef __cplusplus
#define __CPPARGS ...
#else
#define __CPPARGS
#endif
/*
以下来作一些解释： 最小方块是：单个的一个方块。
当前方块是：目前正在移动的由四个小方块组成的方块。
下一个方块是：下一个将要成为当前方块的由四个小方块组成的方块。
*/
#define MINBOXSIZE 20 /* 最小方块的尺寸 */
#define BGCOLOR 6 /* 背景着色 */
#define MINBOXCOLOR 4 /* 最小方块的颜色*/
#define GX 200
#define GY 10
#define SJNUM 10000 /* 每当玩家打到一万分等级加一级*/

/* 按键码*/
#define VK_LEFT 0x4b00
#define VK_RIGHT 0x4d00
#define VK_DOWN 0x5000
#define VK_UP 0x4800
#define VK_HOME 0x4700
#define VK_END 0x4f00
#define VK_SPACE 0x3920
#define VK_ESC 0x011b
#define VK_ENTER 0x1c0d

/* 定义俄罗斯方块的方向（我定义他为4种）*/
#define F_DONG 0
#define F_NAN 1
#define F_XI 2
#define F_BEI 3

#define NEXTCOL 20 /* 要出的下一个方块的纵坐标*/
#define NEXTROW 12 /* 要出的下一个方块的横从标*/
#define MAXROW 14 /* 游戏屏幕大小*/
#define MAXCOL 20
#define SCCOL 50 /*游戏屏幕大显示器上的相对位置*/
#define SCROW 30

#define X_Z 0 /* 定义方块的形壮（共八种）*/
#define X_REZ 1
#define X_7 2
#define X_RE7 3
#define X_I 4
#define X_REI 5
#define X_TIAN 6
#define X_T 7

int gril[22][16]; /* 游戏屏幕坐标*/
int col=1,row=7; /* 当前方块的横纵坐标*/
int boxfx=0,boxgs=0; /* 当前寺块的形壮和方向*/
int nextboxfx,nextboxgs,maxcol=22;/*下一个方块的形壮和方向*/
int num=0; /*游戏分*/
int dj=0,gamedj[10]={18,16,14,12,10,8,6,4,2,1};/* 游戏等级*/
struct all{
int x,y;
int fangxiang;
int gesu;
};
/* 以下我用了一个3维数组来纪录方块的最初形状和方向*/
int boxstr[8][4][4]={{
{0,0,0,0},
{0,0,0,0},
{0,1,1,0},
{0,0,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,1,1,0}},
{
{0,0,0,0},
{0,0,1,1},
{0,0,0,1},
{0,0,0,1}},
{
{0,0,0,0},
{0,0,1,1},
{0,0,1,0},
{0,0,1,0}},
{
{0,0,0,1},
{0,0,0,1},
{0,0,0,1},
{0,0,0,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,0,0},
{1,1,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,1},
{0,0,1,0}}
};

/* 随机得到当前方块和下一个方块的形状和方向*/
void boxrad(){
boxfx=nextboxfx;
boxgs=nextboxgs;
nextboxfx=random(4);
nextboxgs=random(8);
}
/*初始化图形模试*/
void init(int gdrive,int gmode){
int errorcode;
initgraph(&gdrive,&gmode,"e:\\progra~1\\tc");
errorcode=graphresult();
if(errorcode!=grOk){
printf("error of: %s",grapherrormsg(errorcode));
exit(1);
}
}

/*在图形模式下的清屏*/
void cls()
{
setfillstyle(SOLID_FILL,0);
setcolor(0);
bar(0,0,640,480);
}
/*在图形模式下的高级清屏*/
void clscr(int a,int b,int c,int d,int color){
setfillstyle(SOLID_FILL,color);
setcolor(color);
bar(a,b,c,d);
}
/*最小方块的绘制*/
void minbox(int asc,int bsc,int color){
int a=0,b=0;
a=SCCOL+asc;
b=SCROW+bsc;
clscr(a+1,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE,color);
if(color!=BGCOLOR){
setcolor(15);
line(a+1,b+1,a-1+MINBOXSIZE,b+1);
line(a+1,b+1,a+1,b-1+MINBOXSIZE);
setcolor(0);
line(a-1+MINBOXSIZE,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
line(a+1,b-1+MINBOXSIZE,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
}
}
/*最小方块的高级绘制*/
void box(int a,int b,int color){
clscr(a+1,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE,color);
setcolor(15);
line(a+1,b+1,a-1+MINBOXSIZE,b+1);
line(a+1,b+1,a+1,b-1+MINBOXSIZE);
setcolor(0);
line(a-1+MINBOXSIZE,b+1,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
line(a+1,b-1+MINBOXSIZE,a-1+MINBOXSIZE,b-1+MINBOXSIZE);
}
/*游戏中出现的文字*/
void txt(int a,int b,char *txt,int font,int color){
setcolor(color);
settextstyle(0,0,font);
outtextxy(a,b,txt);
}
/*windows 绘制*/
void win(int a,int b,int c,int d,int bgcolor,char *text,int font,int textcolor){
clscr(a,b,c,d,7);
clscr(a+3,b+24,c-3,d-3,bgcolor);
clscr(a+3,b+3,c-3,b+20,9);
setcolor(15);
line(a,b,c,b);
line(a,b,a,d);
line(a+2,b+21,c-2,b+21);
line(c-2,b+2,c-2,b+21);
line(a+2,d-2,c-2,d-2);
line(c-2,b+23,c-2,d-2);
txt(a+5,b+8,text,font,textcolor);
setcolor(0);
line(a,d,c,d);
line(c,b,c,d);
line(a+3,b+2,c-3,b+2);
line(a+2,b+2,a+2,b+20);
line(a+2,b+24,a+2,d-2);
line(a+2,b+23,c-3,b+23);
}
/*把方块的方向旋转fx个90度(fx最大等于3)*/
void re90(int boxxy[4][4],int fx){
int i,j,k,zero;
int a[4][4];
for(k=0;k<fx;k++){
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxxy[3-j][i];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxxy[i][j]=a[i][j];
for(i=0;i<4;i++){
zero=1;
for(j=0;j<4;j++)
if(boxxy[j][3]!=0)
zero=0;
if(zero)
for(j=0;j<4;j++){
boxxy[j][3]=boxxy[j][2];boxxy[j][2]=boxxy[j][1];boxxy[j][1]=boxxy[j][0];boxxy[j][0]=0;
}
}
}
}
/* 当前方块的绘制*/
void funbox(int a,int b,int color){
int i,j;
int boxz[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxz[i][j]=boxstr[boxgs][i][j];
re90(boxz,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(boxz[i][j]==1)
minbox((j+row+a)*MINBOXSIZE,(i+col+b)*MINBOXSIZE,color);
}
/*下一个方块的绘制*/
void nextfunbox(int a,int b,int color){
int i,j;
int boxz[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
boxz[i][j]=boxstr[nextboxgs][i][j];
re90(boxz,nextboxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(boxz[i][j]==1)
minbox((j+a)*MINBOXSIZE,(i+b)*MINBOXSIZE,color);
}
/*时间中断定义*/
#define TIMER 0x1c
int TimerCounter=0;
void interrupt ( *oldhandler)(__CPPARGS);
void interrupt newhandler(__CPPARGS){
TimerCounter++;
oldhandler();
}
void SetTimer(void interrupt (*IntProc)(__CPPARGS)){
oldhandler=getvect(TIMER);
disable();
setvect(TIMER,IntProc);
enable();
}
/*由于游戏的规则，消掉都有最小方块的一行*/
void delcol(int a){
int i,j;
for(i=a;i>1;i--)
for(j=1;j<15;j++){
minbox(j*MINBOXSIZE,i*MINBOXSIZE,BGCOLOR);
gril[i][j]=gril[i-1][j];
if(gril[i][j]==1)
minbox(j*MINBOXSIZE,i*MINBOXSIZE,MINBOXCOLOR);
}
}
/*把数形数转换为字符串*/
char *numgochar(int x){
char k,*a="000000";
int i,j=10;
if(x==0)
return("0");
for(i=0;x>=1;i++){
a[i]='0'+ (x % 10);
x=x/10;
}
for(j=0;j<=i/2;j++){
k=a[j];
a[j]=a[i-j];
a[i-j]=k;
}
a[i+1]='\0';
return(a);
}
/*消掉所有都有最小方块的行*/
void delete(){
int i,j,zero,delgx=0;
char *nm;
for(i=1;i<21;i++){
zero=0;
for(j=1;j<15;j++)
if(gril[i][j]==0)
zero=1;
if(zero==0){
delcol(i);
delgx++;
}
}
num=num+delgx*delgx*10;
dj=num/10000;
nm=numgochar(num);
clscr(456,123,500,150,BGCOLOR);
txt(456,123,"Number:",1,15);
txt(456,143,nm,1,15);
}
/*时间中断结束*/
void KillTimer(){
disable();
setvect(TIMER,oldhandler);
enable();
}
/* 测试当前方块是否可以向下落*/
int downok(){
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i+1][row+j])
k=0;
return(k);
}
/* 测试当前方块是否可以向左行*/
int leftok(){
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i][row+j-1])
k=0;
return(k);
}
/* 测试当前方块是否可以向右行*/
int rightok(){
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j] && gril[col+i][row+j+1])
k=0;
return(k);
}
/* 测试当前方块是否可以变形*/
int upok(){
int i,j,k=1,a[4][4];
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx+1);
for(i=3;i>=0;i--)
for(j=3;j>=0;j--)
if(a[i][j] && gril[col+i][row+j])
k=0;
return(k);
}
/*当前方块落下之后，给屏幕坐标作标记*/
void setgril(){
int i,j,a[4][4];
funbox(0,0,MINBOXCOLOR);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
a[i][j]=boxstr[boxgs][i][j];
re90(a,boxfx);
for(i=0;i<4;i++)
for(j=0;j<4;j++)
if(a[i][j])
gril[col+i][row+j]=1;
col=1;row=7;
}
/*游戏结束*/
void gameover(){
int i,j;
for(i=19;i>=0;i--)
for(j=2;j<16;j++)
box(j*MINBOXSIZE+SCROW,i*MINBOXSIZE+SCCOL,MINBOXCOLOR);
txt(123,123,"Game Over",2,9);
}
/*按键的设置*/
void call_key(int keyx){
switch(keyx){
case VK_DOWN: { /*下方向键，横坐标加一。*/
if(downok()){
col++;
funbox(0,0,MINBOXCOLOR);}
else{
funbox(0,0,MINBOXCOLOR);
setgril();
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,MINBOXCOLOR);
delete();
}
break;
}
case VK_UP: { /*上方向键，方向形状旋转90度*/
if(upok())
boxfx++;
if(boxfx>3)
boxfx=0;
funbox(0,0,MINBOXCOLOR);
break;
}
case VK_LEFT:{ /*左方向键，纵坐标减一*/
if(leftok())
row--;
funbox(0,0,MINBOXCOLOR);
break;
}
case VK_RIGHT:{ /*右方向键，纵坐标加一*/
if(rightok())
row++;
funbox(0,0,MINBOXCOLOR);
break;
}
case VK_SPACE: /*空格键，直接落到最后可以落到的们置*/
while(downok())
col++;
funbox(0,0,MINBOXCOLOR);
setgril();
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,MINBOXCOLOR);
delete();
break;
default: break;
}
}

/*时间中断开始*/
void timezd(void){
int key;
SetTimer(newhandler);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,MINBOXCOLOR);
for(;;){
if(bioskey(1)){
key=bioskey(0);
funbox(0,0,BGCOLOR);
if(key==VK_ESC)
break;
call_key(key);
}
if(TimerCounter>gamedj[dj]){
TimerCounter=0;
if(downok()){
funbox(0,0,BGCOLOR);
col++;
funbox(0,0,MINBOXCOLOR);
}
else {
if(col==1){
gameover();
getch();
break;
}
setgril();
funbox(0,0,MINBOXCOLOR);
col=1;row=7;
nextfunbox(NEXTCOL,NEXTROW,BGCOLOR);
boxrad();
nextfunbox(NEXTCOL,NEXTROW,MINBOXCOLOR);
delete();
}
}
}
}

/*主程序开始*/
void main(void){
int i,j,color=7;
char *nm;
init(VGA,VGAHI);
cls();
/*屏幕坐标初始化*/
for(i=0;i<=MAXCOL+1;i++)
for(j=0;j<=MAXROW+1;j++)
gril[i][j]=0;
for(i=0;i<=MAXCOL+1;i++) {
gril[i][0]=1;
gril[i][15]=1;
}
for(j=1;j<=MAXROW;j++){
gril[0][j]=1;
gril[21][j]=1;
}
clscr(0,0,640,480,15);
win(1,1,639,479,BGCOLOR,"Well Come Back My Game 1.0 (Lao Ma office)!",1,15);

setcolor(color);
for(i=0;i<=21;i++){
for(j=0;j<=15;j++) {
if(gril[i][j]==1)
box(j*MINBOXSIZE+SCCOL,i*MINBOXSIZE+SCROW,color);
}
}
nextboxgs=random(8);
nextboxfx=random(4);
nm=numgochar(num);
txt(456,123,"Number:",1,15);
txt(456,143,nm,1,15);
timezd();
KillTimer();
closegraph();
}

帮还是害