俄罗斯方块

 

/**/ /* 2002-11-13
 *俄罗斯方块
 *Made by GGG

 */
#include  < stdio.h >
# include  < stdlib.h >
#include  < dos.h >
#include  < graphics.h >

#define  TIMER 0x1c


#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

#define  MAX_BOX 19            /*总共有19种各形态的方块*/
#define  BSIZE 16            /*方块的边长是16个象素*/
#define  Sys_x 160            /*显示方块界面的左上角x座标*/
#define  Sys_y 25                /*显示方块界面的左上角y座标*/
#define  Horizontal_boxs 15        /*水平的方向以方块为单位的长度*/
#define  Vertical_boxs 25        /*垂直的方向以方块为单位的长度,也就说长是30个方块*/
#define  Begin_boxs_x 15/2        /*产生第一个方块时应该出现的起始位置 这里指定是在第5格出现*/


#define  FgColor 2        /*前景颜色,如文字*/
#define  BgColor 0        /*背景颜色*/

#define  LeftWin_x Sys_x+Horizontal_boxs*BSIZE+50        /*左边状态栏的x座标*/


#define  false 0
#define  true 1
/**/ /*移动的方向*/
#define  MoveLeft 1
#define  MoveRight 2
#define  MoveDown 3
#define  MoveRoll 4
#define  MoveDown_direct 5
/**/ /*
 *以后坐标的每个像素点看作是BSIZE*BSIZE正方形的方块
 */
int  current_box_numb;         /**/ /*保存当前方块编号*/
/**/ /*int Table_board[Vertical_boxs][Horizontal_boxs];    /*保存游戏当前状态的数组 */
int  Curbox_x = Sys_x + Begin_boxs_x * BSIZE,Curbox_y = Sys_y; /**/ /*x,y是保存方块的当前坐标的*/
int  flag_newbox = false ;     /**/ /*是否要产生新方块的标记0*/
int  speed = 0 ;             /**/ /*下落速度*/
int  score = 0 ;              /**/ /*总分*/
int  speed_step = 15 ;         /**/ /*每等级所需要分数*/
void  interrupt ( * oldtimer)( void ); /**/ /* function pointer variable */

struct  BOARD             /**/ /*游戏底板结构,表示每个点所具有的属性*/
... {
    int var;            /**//*当前状态 只有0和1*/
    int color;                /**//*颜色*/
} Table_board[Vertical_boxs][Horizontal_boxs];

/**/ /*方块结构*/
struct  SHAPE
... {
    char box[2];            /**//*一个字节等于8位,每4位来表示一个方块的一行*/
    int color;                /**//*颜色*/
    int next;                /**//*下个方块的编号*/
    int prev;                /**//*上个方块的编号*/
} ;

/**/ /*为游戏底板分配内存*/


/**/ /*初始化方块内容*/
struct  SHAPE shapes[MAX_BOX] =
... {
/**//*
 *   口     口口口   口口      口
 *   口     口         口  口口口
 *   口口              口        
 */

    ...{0x88,    0xc0,    CYAN,    1,    3},
    ...{0xe8,    0x0,    CYAN,    2,    0},
    ...{0xc4,    0x40,    CYAN,    3,    1},
    ...{0x2e,    0x0,    CYAN,    0,    2},
/**//*
 *   口        口口 口口口
 *   口 口     口       口
 * 口口 口口口 口    
 */
    ...{0x44,    0xc0,    MAGENTA,    5,    7},
    ...{0x8e,    0x0,    MAGENTA,    6,    4},
    ...{0xc8,    0x80,    MAGENTA,    7,    5},
    ...{0xe2,    0x0,    MAGENTA,    4,    6},

/**//*
 *   口
 *   口口
 *     口
 */
    ...{0x8c,    0x40,    YELLOW,    9,    9},
    ...{0x6c,    0x0,    YELLOW,    8,    8},

/**//*
 *   口
 * 口口
 * 口
 */
    ...{0x4c,    0x80,    BROWN,    11,    11},
    ...{0xc6,    0x0,    BROWN,    10,    10},

/**//*
 *   口
 * 口口口
 */
    ...{0x4e,    0x0,    WHITE,    13,    15},
    ...{0x8c,    0x80,    WHITE,    14,    12},
    ...{0xe4,    0x0,    WHITE,    15,    13},
    ...{0x4c,    0x40,    WHITE,    12,    14},

/**//* 口
 * 口
 * 口
 * 口
 */
    ...{0x88,    0x88,    RED,    17,    17},
    ...{0xf0,    0x0,    RED,    16,    16},

/**//*
 * 口口
 * 口口
 */

    ...{0xcc,    0x0,    BLUE,    18,    18}

} ;


unsigned  int  TimerCounter = 0 ;

void  interrupt newtimer( void )
... {
    (*oldtimer)();
    TimerCounter++;
}

void  SetTimer( void  interrupt( * IntProc)( void ))
... {
    oldtimer=getvect(TIMER);
    disable();
    setvect(TIMER,IntProc);
    enable();
}
void  KillTimer()
... {
    disable();
    setvect(TIMER,oldtimer);
    enable();
}
/**/ /*显示分数*/
void  ShowScore( int  score)
... {
    int x,y;
    char score_str[5];/**//*保存游戏得分*/
    setfillstyle(SOLID_FILL,BgColor);
    x=LeftWin_x;
    y=100;
    bar(x-BSIZE,y,x+BSIZE*3,y+BSIZE*3);
/**//*    itoa(score,score_str,10);*/
    sprintf(score_str,"%3d",score);
    outtextxy(x,y,"SCORE");
    outtextxy(x,y+10,score_str);
}

/**/ /*显示速度*/
void  ShowSpeed( int  speed)
... {
    int x,y;
    char speed_str[5];/**//*保存游戏得分*/
    setfillstyle(SOLID_FILL,BgColor);
    x=LeftWin_x;
    y=200;
    bar(x-BSIZE,y,x+BSIZE*3,y+BSIZE*3);
    sprintf(speed_str,"%3d",speed+1);
    outtextxy(x,y,"speed");
    outtextxy(x,y+10,speed_str);
}


/**/ /*
 *********初始化界面*******
 *参数说明:
 *        x,y为左上角坐标
 *        m,n对应于Vertical_boxs,Horizontal_boxs
 *        表示横肉纵方向的长度(以方块为单位)
 *BSIZE Sys_x Sys_y
 */    
void  initialize( int  x, int  y, int  m, int  n)
... {

    int i,j,oldx;
    oldx=x;
    for(j=0;j<n;j++)
    ...{
        for(i=0;i<m;i++)
        ...{
            /**//*if(i==0 || i==(m-1) || j==(n-1))    Table_board[j][i]=1;
            else    */    
            Table_board[j][i].var=0;
            Table_board[j][i].color=BgColor;
            line(x,y,x+BSIZE,y);
            line(x,y,x,y+BSIZE);
            line(x,y+BSIZE,x+BSIZE,y+BSIZE);
            line(x+BSIZE,y,x+BSIZE,y+BSIZE);
            x+=BSIZE;
        }
        y+=BSIZE;
        x=oldx;
    }
    Curbox_x=x;
    Curbox_y=y;/**//*x,y是保存方块的当前坐标的*/
    flag_newbox=false;    /**//*是否要产生新方块的标记0*/
    speed=0;            /**//*下落速度*/
    score=0;             /**//*总分*/
    ShowScore(score);
    ShowSpeed(speed);
/**//*
    for(j=0;j<=n;j++)
    {
        for(i=0;i<=m;i++)
        {
            if(i==0 || i==m || j==n)    Table_board[j][i]=1;            /*最左右边设成1
            else                Table_board[j][i]=0;
        }

    }

Table_board[10][10]=1;
Table_board[5][5]=1;

for(j=0;j<n;j++)
    {
        for(i=0;i<m;i++)
        {
            printf("%d",Table_board[j][i]);
        }
        printf(" ");
    }
*/    
}
/**/ /*   删除一行满的情况
 *   这里的y为具体哪一行为满
 */

int  DelFullRow( int  y)
... {
    /**//*该行游戏板往下移一行*/
    int n,top=0;                /**//*top保存的是当前最高点,出现一行全空就表示为最点了,移动是到最高点结束*/
    register m,totoal;
    for(n=y;n>=0;n--)/**//*从当前行往上看*/
    ...{
        totoal=0;
        for(m=0;m<Horizontal_boxs;m++)
        ...{
            if(!Table_board[n][m].var)totoal++;                /**//*没占有方格+1*/
            if(Table_board[n][m].var!=Table_board[n-1][m].var)    /**//*上行不等于下行就把上行传给下行 xor关系*/
            ...{
                Table_board[n][m].var=Table_board[n-1][m].var;
                Table_board[n][m].color=Table_board[n-1][m].color;
            }
        }
        if(totoal==Horizontal_boxs)                        /**//*发现上面有连续的空行提前结束*/
        ...{
            top=n;
            break;
        }
    }
    return(top);                /**//*返回最高点*/
}
/**/ /*找到一行满的情况*/
void  setFullRow( int  t_boardy)
... {
    int n,full_numb=0,top=0;            /**//*top保存的是当前方块的最高点*/
    register m;
/**//*
t_boardy 口       5
         口       6
   口口口口口口   7
n  口口口口口口   8
 */
    for(n=t_boardy+3;n>=t_boardy;n--)
    ...{
        if(n<0 || n>=Vertical_boxs )...{continue;}    /**//*超过低线了*/
        for(m=0;m<Horizontal_boxs;m++)            /**//*水平的方向*/
        ...{
            if(!Table_board[n+full_numb][m].var)break;        /**//*发现有一个是空就跳过该行*/
        }
        if(m==Horizontal_boxs)                    /**//*找到满行了*/
        ...{
            if(n==t_boardy+3)                    /**//*第一次献给了n,最高的*/
                top=DelFullRow(n+full_numb);        /**//*清除游戏板里的该行,并下移数据*/
            else
                DelFullRow(n+full_numb);
            full_numb++;                        /**//*统计找到的行数*/
/**//*            printf(" %d ",m);*/
        }
    }
    if(full_numb)
    ...{
        int oldx,x=Sys_x,y=BSIZE*top+Sys_y;
        oldx=x;
        score=score+full_numb;                /**//*加分数*/
        /**//*这里相当于重显调色板*/
        for(n=top;n<t_boardy+4;n++)
        ...{
            if(n>=Vertical_boxs)continue;    /**//*超过低线了*/
            for(m=0;m<Horizontal_boxs;m++)    /**//*水平的方向*/
            ...{
                if(Table_board[n][m].var)
                    setfillstyle(SOLID_FILL,Table_board[n][m].color);/**//*Table_board[n][m].color*/
                else
                    setfillstyle(SOLID_FILL,BgColor);

                bar(x,y,x+BSIZE,y+BSIZE);
                line(x,y,x+BSIZE,y);
                line(x,y,x,y+BSIZE);
                line(x,y+BSIZE,x+BSIZE,y+BSIZE);
                line(x+BSIZE,y,x+BSIZE,y+BSIZE);
                x+=BSIZE;
            }
            y+=BSIZE;
            x=oldx;
        }
        ShowScore(score);
        if(speed!=score/speed_step)
        ...{
            speed=score/speed_step;
            ShowSpeed(speed);
        }

    }
}


/**/ /* 返回下个方块号
 * 
 */
int  MkNextBox( int  box_numb)
... {

    int mask=128,t_boardx,t_boardy,n,m;
    t_boardx=(Curbox_x-Sys_x)/BSIZE;
    t_boardy=(Curbox_y-Sys_y)/BSIZE;
    for(n=0;n<4;n++)
    ...{
        for(m=0;m<4;m++)
        ...{
            if( ((shapes[current_box_numb].box[n/2]) & mask) )/**//*设置游戏板*/
            ...{
/**//*                bar(Curbox_x+m*BSIZE,y+n*BSIZE,Curbox_x+m*BSIZE+BSIZE,y+n*BSIZE+BSIZE);*/
                Table_board[t_boardy+n][t_boardx+m].var=1;/**//*这里设制游戏板*/
                Table_board[t_boardy+n][t_boardx+m].color=shapes[current_box_numb].color;/**//*这里设制游戏板*/
            }
            mask=mask/(2);
            if(mask==0)mask=128;
        }
    }
    setFullRow(t_boardy);
    Curbox_x=Sys_x+Begin_boxs_x*BSIZE,Curbox_y=Sys_y;/**//*再次初始化座标*/
    if(box_numb==-1)box_numb=rand()%MAX_BOX;
    current_box_numb=box_numb;
    flag_newbox=false;
    return(rand()%MAX_BOX);
}

/**/ /* 检查游戏板里和当前方块是否重叠
 * 
 */
void  EraseBox( int  x, int  y, int  box_numb)
... {
    int mask=128,t_boardx,t_boardy,n,m;
    setfillstyle(SOLID_FILL,BgColor);
    for(n=0;n<4;n++)
    ...{
        for(m=0;m<4;m++)    /**//*看最左边四个单元*/
        ...{
            if( ((shapes[box_numb].box[n/2]) & mask) )/**//*最左边有方块并且当前游戏板也有方块*/
            ...{
                bar(x+m*BSIZE,y+n*BSIZE,x+m*BSIZE+BSIZE,y+n*BSIZE+BSIZE);
                line(x+m*BSIZE,y+n*BSIZE,x+m*BSIZE+BSIZE,y+n*BSIZE);
                line(x+m*BSIZE,y+n*BSIZE,x+m*BSIZE,y+n*BSIZE+BSIZE);
                line(x+m*BSIZE,y+n*BSIZE+BSIZE,x+m*BSIZE+BSIZE,y+n*BSIZE+BSIZE);
                line(x+m*BSIZE+BSIZE,y+n*BSIZE,x+m*BSIZE+BSIZE,y+n*BSIZE+BSIZE);
            }
            mask=mask/(2);
            if(mask==0)mask=128;
        }
    }

}
/**/ /* 判断是否可以移动
 * x,y为当前方块位置
 * box_numb为方块号
 * direction 方向标志 
 *  返回true 和false
#define MoveLeft -1
#define MoveRight 1
#define MoveDown 0


 */
int  MoveAble( int  x, int  y, int  box_numb, int  direction)
... {
    int n,m,t_boardx,t_boardy;            /**//*t_boardx 当前方块最左边在游戏板的位置*/
    int mask;
    if(direction==MoveLeft)                /**//*如果向左移*/
    ...{
        mask=128;
        x-=BSIZE;
        t_boardx=(x-Sys_x)/BSIZE;
        t_boardy=(y-Sys_y)/BSIZE;
        for(n=0;n<4;n++)
        ...{
            for(m=0;m<4;m++)    /**//*看最左边四个单元*/
            ...{
                if((shapes[box_numb].box[n/2]) & mask)/**//*最左边有方块并且当前游戏板也有方块*/
                ...{
                    if((x+BSIZE*m)<Sys_x)return(false);/**//*碰到最左边了*/
                    else if(Table_board[t_boardy+n][t_boardx+m].var)
                    ...{
                        return(false);
                    }
                }
                mask=mask/(2);
                if(mask==0)mask=128;
            }
        }
        return(true);
    }
    else if(direction==MoveRight)        /**//*如果向右移*/
    ...{
        x+=BSIZE;
        t_boardx=(x-Sys_x)/BSIZE;
        t_boardy=(y-Sys_y)/BSIZE;
        mask=128;
        for(n=0;n<4;n++)
        ...{
            for(m=0;m<4;m++)    /**//*看最右边四个单元*/
            ...{
                if((shapes[box_numb].box[n/2]) & mask)/**//*最右边有方块并且当前游戏板也有方块*/
                ...{
                    if((x+BSIZE*m)>=(Sys_x+BSIZE*Horizontal_boxs) )return(false);/**//*碰到最右边了*/
                    else if( Table_board[t_boardy+n][t_boardx+m].var)
                    ...{
                        return(false);
                    }
                }
                mask=mask/(2);
                if(mask==0)mask=128;
            }
        }
        return(true);
    }
    else if(direction==MoveDown)        /**//*如果向下移*/
    ...{
        y+=BSIZE;
        t_boardx=(x-Sys_x)/BSIZE;
        t_boardy=(y-Sys_y)/BSIZE;
        mask=128;
        for(n=0;n<4;n++)
        ...{
            for(m=0;m<4;m++)    /**//*看最下边四个单元*/
            ...{
                if((shapes[box_numb].box[n/2]) & mask)/**//*最下边有方块并且当前游戏板也有方块*/
                ...{
                    if((y+BSIZE*n)>=(Sys_y+BSIZE*Vertical_boxs) ||  Table_board[t_boardy+n][t_boardx+m].var)
                    ...{
                        flag_newbox=true;
                        break;
                    }
                }
                mask=mask/(2);/**//*这样可以得到每隔八位的mask 0001 0000,16 和 0000 0001*/
                if(mask==0)mask=128;
            }
        }
        if(flag_newbox)
        ...{
            return(false);
        }
        else
            return(true);
    }
    else if(direction==MoveRoll)        /**//*转动*/
    ...{
        t_boardx=(x-Sys_x)/BSIZE;
        t_boardy=(y-Sys_y)/BSIZE;
        mask=128;
        for(n=0;n<4;n++)
        ...{
            for(m=0;m<4;m++)    /**//*看最下边四个单元*/
            ...{
                if((shapes[box_numb].box[n/2]) & mask)/**//*最下边有方块并且当前游戏板也有方块*/
                ...{
                    if((y+BSIZE*n)>=(Sys_y+BSIZE*Vertical_boxs) )return(false);/**//*碰到最下边了*/
                    if((x+BSIZE*n)>=(Sys_x+BSIZE*Horizontal_boxs) )return(false);/**//*碰到最左边了*/
                    if((x+BSIZE*m)>=(Sys_x+BSIZE*Horizontal_boxs) )return(false);/**//*碰到最右边了*/

                    else if( Table_board[t_boardy+n][t_boardx+m].var)
                    ...{
                        return(false);
                    }
                }
                mask=mask/(2);/**//*这样可以得到每隔八位的mask 0001 0000,16 和 0000 0001*/
                if(mask==0)mask=128;
            }
        }
        return(true);
    }
    else
    ...{
        return(false);
    }

}

/**/ /*
显示指定的方块
*/
void  show_box( int  x, int  y, int  box_numb, int  color)
... {
    int i,ii,ls_x=x;
    if(box_numb<0 || box_numb>=MAX_BOX)/**//*指定的方块不存在*/
        box_numb=MAX_BOX/2;
    setfillstyle(SOLID_FILL,color);
/**//********************************* 
 *   移位来判断第哪一位是1
 *   方块是每1行用半个字节来表示
 *   128d=1000 0000b
 */
    for(ii=0;ii<2;ii++)    
    ...{
        int mask=128;
        for(i=0;i<8;i++)
        ...{
            if(i%4==0 && i!=0)                /**//*表示转到方块的下一行了*/
            ...{
                y+=BSIZE;
                x=ls_x;
            }
            /**//*if((shapes[box_numb].box[ii]>>(8-1-i))&1==1)/*左移后得到的是最高位*/
            if((shapes[box_numb].box[ii])&mask)
            ...{
                bar(x,y,x+BSIZE,y+BSIZE);
                line(x,y,x+BSIZE,y);
                line(x,y,x,y+BSIZE);
                line(x,y+BSIZE,x+BSIZE,y+BSIZE);
                line(x+BSIZE,y,x+BSIZE,y+BSIZE);
            }
            x+=BSIZE;
            mask/=2;
        }
        y+=BSIZE;
        x=ls_x;
    }
}

void  show_all_box()
... {
    int i,ii,n;
    for(n=0;n<MAX_BOX;n++)/**//*循环所有的方块*/
    ...{
        clrscr();
        printf("number: %d ",n);

        for(ii=0;ii<2;ii++)    
        ...{
            for(i=0;i<8;i++)
            ...{
                if(i%4==0 && i!=0)
                    printf(" ");
                if((shapes[n].box[ii]>>(8-1-i))&1==1)
                ...{
                    printf("%s","#");
                }
                else
                ...{
                    printf("%s","O");
                }
            }
            printf(" ");
        }
        getch();
    }
    printf("  that's all!");
    getch();
}

/**/ /*返回下个方块号*/
int  get_next_box( int  box_numb)
... {
    box_numb++;
    if(box_numb<0 || box_numb>=MAX_BOX)/**//*指定的方块不存在*/
        return 0;
    else
        return box_numb;
}

/**/ /*返回上个方块号*/
int  get_prev_box( int  box_numb)
... {
    box_numb--;
    if(box_numb<0 || box_numb>=MAX_BOX)/**//*指定的方块不存在*/
        return 0;
    else
        return box_numb;
}

void  main()
... {
    int GameOver=0;
    int key,nextbox; 
    int Currentaction=0;/**//*状态标记,往下移和,当前动作*/
    int gd=VGA,gm=VGAHI,errorcode;

/**//*
    int gd=EGA,gm=DETECT,errorcode;
    installuserdriver("VESA256",0); 
    int gd=DETECT,gm,errorcode;
*/
    initgraph(&gd,&gm,"");
    errorcode = graphresult(); 
    if (errorcode != grOk)  
    ...{
        printf(" Graphics error: %s ", grapherrormsg(errorcode)); 
        printf("Press any key to halt!"); 
        getch(); 
        exit(1);            
    }
    setbkcolor(BgColor);
    setcolor(FgColor);
    randomize();
    SetTimer(newtimer);

    initialize(Sys_x,Sys_y,Horizontal_boxs,Vertical_boxs);/**//*初始化*/


    nextbox=MkNextBox(-1);
                line(LeftWin_x,Curbox_y+200,LeftWin_x+BSIZE*4,Curbox_y+200);
                line(LeftWin_x,Curbox_y+200,LeftWin_x,Curbox_y+200+BSIZE*4);
                line(LeftWin_x,Curbox_y+200+BSIZE*4,LeftWin_x+BSIZE*4,Curbox_y+200+BSIZE*4);
                line(LeftWin_x+BSIZE*4,Curbox_y+200,LeftWin_x+BSIZE*4,Curbox_y+200+BSIZE*4);

    show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
    show_box(LeftWin_x,Curbox_y+200,nextbox,shapes[nextbox].color);

    getch();
    while(1)
    ...{
/**//*        Currentaction=0;
        flag_newbox=false;
                /*检测是否有按键*/            
        if (bioskey(1))...{key=bioskey(0);        }
        else            ...{            key=0;        }

        switch(key)
        ...{
            case VK_LEFT:
                if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveLeft))
                ...{EraseBox(Curbox_x,Curbox_y,current_box_numb);Curbox_x-=BSIZE;Currentaction=MoveLeft;}
                break;
            case VK_RIGHT:
                if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveRight))
                ...{EraseBox(Curbox_x,Curbox_y,current_box_numb);Curbox_x+=BSIZE;Currentaction=MoveRight;}
                break;
            case VK_DOWN:/**//*加速*/
                if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))
                ...{EraseBox(Curbox_x,Curbox_y,current_box_numb);Curbox_y+=BSIZE;Currentaction=MoveDown;}
                else...{ flag_newbox=true;}
                break;/**//*MoveDown_direct*/
            case VK_SPACE:/**//*直接下落*/
                if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))
                ...{
                    EraseBox(Curbox_x,Curbox_y,current_box_numb);Curbox_y+=BSIZE;Currentaction=MoveDown_direct;
                }
                else ...{flag_newbox=true;}
                break;
            case 0x1e61:/**//*a转动方块*/
                if(MoveAble(Curbox_x,Curbox_y,shapes[current_box_numb].prev,MoveRoll))
                ...{
                    EraseBox(Curbox_x,Curbox_y,current_box_numb);current_box_numb=shapes[current_box_numb].prev;
                    Currentaction=MoveRoll;
                }
                break;
            case VK_UP:/**//*变换方块*/
                if(MoveAble(Curbox_x,Curbox_y,shapes[current_box_numb].next,MoveRoll))
                ...{
                    EraseBox(Curbox_x,Curbox_y,current_box_numb);current_box_numb=shapes[current_box_numb].next;
                    Currentaction=MoveRoll;
                }
                break;

            case VK_ESC:
                GameOver=1;
                break;
            default:
                break;
        }

        if(Currentaction && MoveDown_direct!=Currentaction)
        ...{/**//*表示当前有动作,移动或转动*/
            show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
        }
/**//*按了往下键，但不能下移,就产生新方块*/
        if(flag_newbox)
        ...{

            /**//*这时相当于方块到底部了,把其中出现点满一行的清去，置0*/
            EraseBox(LeftWin_x,Sys_y+200,nextbox);
            nextbox=MkNextBox(nextbox);
            show_box(LeftWin_x,Curbox_y+200,nextbox,shapes[nextbox].color);
            if(!MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))/**//*刚生一下就到东西,游戏结束*/
            ...{
                show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
                GameOver=1;
            }
            else
            ...{
                flag_newbox=false;
            }
            Currentaction=0;
        }
        else    /**//*自由下落*/
        ...{
            if(Currentaction==MoveDown_direct) /**//*直接下落*/
            ...{

                int ls_i;
                for(ls_i=Curbox_y;ls_i<Sys_y+Vertical_boxs*BSIZE;ls_i++)
                ...{
                    if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))
                    ...{
                        Curbox_y+=BSIZE;
                    }
                    else
                        break;
                }
                show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
                Currentaction=0;
                TimerCounter=0;
            }
            else if (Currentaction==MoveDown || TimerCounter> (20-speed*2))
            ...{
                if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))
                ...{
                    EraseBox(Curbox_x,Curbox_y,current_box_numb);Curbox_y+=BSIZE;
                    show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
                }
/**//*                if (Currentaction==MoveDown)*/
                TimerCounter=0;
            }
        }
        Currentaction=0;
        if(GameOver )/**//*|| flag_newbox==-1*/
        ...{
            printf("game over!");
            initialize(Sys_x,Sys_y,Horizontal_boxs,Vertical_boxs);
            getch();
            break;
        }
    }
    getch();
    KillTimer();
    closegraph();
}