module_act.c

经典的俄罗斯方块程序

#include<stdlib.h>
#include<gtk/gtk.h>
#include"main.h"
#include"clean_line.h"
#include"module_act.h"

static  Modules _module;
static  Modules __module;

pmodule const module=&_module;
pmodule const premodule=&__module;

static gint blockTable[7][4][8]=
{
    {
        {0,1,1,1,2,1,3,1},
        {1,0,1,1,1,2,1,3},
        {0,1,1,1,2,1,3,1},
        {1,0,1,1,1,2,1,3}
    },
    {
        {0,0,0,1,1,0,1,1},
        {0,0,0,1,1,0,1,1},
        {0,0,0,1,1,0,1,1},
        {0,0,0,1,1,0,1,1}
    },
    {
        {1,0,1,1,0,1,2,1},
        {1,0,1,1,2,1,1,2},
        {0,1,1,1,2,1,1,2},
        {1,0,0,1,1,1,1,2}
    },
	{
        {0,0,0,1,1,1,2,1},
        {1,0,2,0,1,1,1,2},
        {0,1,1,1,2,1,2,2},
        {1,0,1,1,1,2,0,2}
    },
	{
        {2,0,0,1,1,1,2,1},
        {1,0,1,1,1,2,2,2},
        {0,1,1,1,2,1,0,2},
        {0,0,1,0,1,1,1,2}
    },
    {
        {1,0,2,0,0,1,1,1},
        {1,0,1,1,2,1,2,2},
        {1,1,2,1,1,2,0,2},
        {0,0,0,1,1,1,1,2}
    },
    {
        {0,0,1,0,1,1,2,1},
        {2,0,1,1,2,1,1,2},
        {0,1,1,1,1,2,2,2},
        {1,0,0,1,1,1,0,2}
    }
};

static gboolean
block_in_mod(gint x,
             gint y,
             pmodule mod)
{
    gint i;
    
    for(i=0;i<8;i+=2){
        if(mod->block[i]==x&&mod->block[i+1]==y)
            return TRUE;
    }
    
    return FALSE;
}

static gboolean
operability_test(pmodule mod,pmodule ori)
{
    gint i,j;
    gint x,y;

    for(i=0;i<8;i+=2){
        x=mod->block[i];
        y=mod->block[i+1];
        if(x<0||x>=COLUMN1){
            return FALSE;
        }
        if(y<0||y>=ROW1){
            return FALSE;
        }
        if(0!=board1[x][y]&&!block_in_mod(x,y,ori)){
            return FALSE;
        }
    }
    
    return TRUE;
}

static gboolean
erase_mod(pmodule mod)
{
    gint i;

    for(i=0;i<8;i+=2){
        board1[mod->block[i]][mod->block[i+1]]=0;
    }
    
    return TRUE;
}

static gboolean
rotateable_test(pmodule mod,pmodule ori)
{
    gint i,j;
    gint x,y;

    for(i=0;i<8;i+=2){
        x=ori->block[i];
        y=ori->block[i+1];
        if(0!=board1[x][y+1]&&!block_in_mod(x,y+1,ori)){
            return FALSE;
        }
    }
                
    if(!operability_test(mod,ori)){
        return FALSE;
    }
    
    return TRUE;
}

gboolean
module_rotate(pmodule mod)
{
    gint    i;
    gint    state;
    Modules tempmod;

    tempmod=*mod;
    state=mod->state;
    state=(state+1)%4;
    tempmod.state=state;
    
    for(i=0;i<8;i+=2){
        tempmod.block[i]=tempmod.xshift+blockTable[tempmod.color-1][state][i];
        tempmod.block[i+1]=tempmod.yshift+blockTable[tempmod.color-1][state][i+1];
    }
    
    if(rotateable_test(&tempmod,mod)){
        erase_mod(mod);
        *mod=tempmod;
        return TRUE;
    }
    
    return FALSE;
}

gboolean
new_module(pmodule mod,
           gint color)
{
    gint    i;
    gint    rot;

    rot=rand()%4;

    if(NULL==mod){
        g_print(_("error in new_module()\n"));
        return FALSE;
    }

    mod->color=color;
    mod->state=rot;
    mod->xshift=4;
    mod->yshift=0;
    
    for(i=0;i<8;i+=2){
        mod->block[i]  =mod->xshift+blockTable[color-1][rot][i];
        mod->block[i+1]=mod->yshift+blockTable[color-1][rot][i+1];
    }
    
    return TRUE;
}

gboolean
module_fall(pmodule mod)
{
    gint i;
    
    for(i=0;i<8;i+=2){
        if(0!=board1[mod->block[i]][mod->block[i+1]+1])
            if(!block_in_mod(mod->block[i],
                             mod->block[i+1]+1,
                             mod))
            {
                return FALSE;
            }
        if(mod->block[i+1]>=ROW1-1){
            return FALSE;
        }
    }
    erase_mod(mod);
    mod->yshift++;
    for(i=0;i<8;i+=2){
        mod->block[i+1]++;
    }
        
    return TRUE;
}

gboolean
module_direct_down(GtkWidget* widget,
                   pmodule mod)
{
    while(module_fall(mod))
        ;
    clean_board(widget,
                mod->block[7],
                mod->block[1]);
    
    return TRUE;
}


gboolean
draw_mod_board1(pmodule mod)
{
    gint i;
     
    for(i=0;i<8;i+=2){
        board1[mod->block[i]][mod->block[i+1]]=mod->color;
    }
    
    return TRUE;
}

gboolean
draw_mod_board2(pmodule mod)
{
    gint i,j;

    if(NULL==mod) return FALSE;
    for(i=0;i<COLUMN2;i++){
        for(j=0;j<ROW2;j++){
            board2[i][j]=0;
        }
    }
    for(i=0;i<8;i+=2){
        board2[mod->block[i]-3][mod->block[i+1]+1]=mod->color;
    }
    
    return TRUE;
}

gboolean
module_left(pmodule mod)
{
    gint i,j;
    Modules tempmod;

    tempmod=*mod;
    
    for(i=0;i<8;i+=2){
        mod->block[i]--;
    }
    if(operability_test(mod,&tempmod)){
        erase_mod(&tempmod);
        mod->xshift--;
        return TRUE;
    }else{
        *mod=tempmod;
        return FALSE;
    }
        
    return TRUE;
}

gboolean
module_right(pmodule mod)
{
    gint i;
    Modules tempmod;

    tempmod=*mod;
    for(i=0;i<8;i+=2){
        mod->block[i]++;
    }
    if(operability_test(mod,&tempmod)){
        erase_mod(&tempmod);
        mod->xshift++;
        return TRUE;
    }else{
        *mod=tempmod;
        return FALSE;
    }
    
    return TRUE;
}