俄罗斯方块

原创 2006年05月20日 02:23:00

 

/* 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();
}

JAVA俄罗斯方块程序 勉强能看懂,但是我写不出来,555

代码贴出如下: package com.zzk.cn; import java.awt.*; import java.awt.event.*; import javax.swing.*; impo...

史上短小精悍的JavaScript编写的俄罗斯方块游戏

史上短小精悍的JavaScript编写的俄罗斯方块游戏 俄罗斯方块

【C语言】俄罗斯方块的源代码

GitHub:【C语言】实现俄罗斯方块源代码Head.h#ifndef _HEAD_H_ #define _HEAD_H_#include #include #include #include #in...

俄罗斯方块中方块的旋转变形

本文针对用js编写俄罗斯方块的时候,方块的旋转变形算法,以逆时针旋转为例,下图为旋转的说明图 第一次用visio画图,画的很不好,坐标(x,y)绕(x0,y0)逆时针旋转90度后的坐标为(x0+y...

Android版俄罗斯方块的实现

学习Android的基本开发也有一段时间了,但是因为没有经常使用Android渐渐的也就忘记了。Android编程学的不深,仅仅是为了对付逆向,但是有时还是会感到力不从心的。毕竟不是一个计算机专业毕业...

使用javascript制作俄罗斯方块游戏(2)

上一篇文章我们已经确立了具体的思路,这次就来构建代码吧!当然首先是页面,我们这样构建 俄罗斯方块 .piece_I{width: 23px; heig...

【C语言】实现俄罗斯方块

学习了C语言,写一个俄罗斯方块,代码绝对可以运行 大神勿笑,只适合初学者 本人也是菜鸟1、考虑怎么存储俄罗斯方块俄罗斯方块的形状一共有19种类型,如果拿数组来表示的话,可能会比较会浪费空间(网...

俄罗斯方块代码——c++实现

用codeblock实现不了,缺少库函数,windows的kpi。555 现在还么解决办法,不过代码挺好的,贴吧大神多。 2017-5-2#include #include #include#de...

简单的俄罗斯方块代码(Java)

package MyGame; /** * Created by zu on 2015/3/30. */ /* 整个游戏界面分为两部分,左边显示信息,右边是游戏区,是两个JPanel,它们的父窗...

新手向!超详细!Java俄罗斯方块程序面向对象编程全记录

零、写在开始之前 新人,Java学习中,文章中遗漏错误之处,欢迎斧正 个人博客,完全原创 转载请注明出处。 项目全代码地址:GitHub 一、从面向对象的开始,将对象抽象成类面对...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:俄罗斯方块
举报原因:
原因补充:

(最多只允许输入30个字)