int Check_is_zd(int x,int y) 
{ /*检查前方是否是一个子弹，用于子弹与子弹的碰撞*/ 
    int tx,ty,i; 
    int num=0; 
    for(i=0;i<9;i++) 
    { 
        tx=x+i/3-1; 
        ty=y+(i+3)%3-1; 
    if(Gm_Array[tx][ty]) 
        ++num; 
    } 
    if(num>2) 
        return 0; 
    return 1; 
}void Mul_zd(void) 
{ /*处理子弹事件链表中的每一个子弹*/ 
    Zd_Link p=Zd_List; 
int flag_ok=1; 
int x,y,type,drct,xd,yd; 
int f_tp; 
while(p) 
{ /*从事件链表中依次取出子弹*/ 
    flag_ok=1; 
    x=p->x; 
    y=p->y; 
    type=p->type; 
    drct=p->drct; 
    xd=x+ct_dx[drct-1]; 
    yd=y+ct_dy[drct-1]; 
    if(xd<0||xd>M_Max-1||yd<0||yd>N_Max-1) 
        flag_ok=0,f_tp=9;/*如果子弹到达了游戏的边界。。*/ 
    else if(Gm_Array[xd][yd]) { /*检查子弹运行前方的情况*/ 
        f_tp=Gm_Array[xd][yd]; 
        if(Check_is_zd(xd,yd)) f_tp=8; flag_ok=0; } 
    if(flag_ok) { /*如果子弹前方没有东西则子弹继续飞行*/ 
        Gm_Array[xd][yd]=type; Draw_Node(xd,yd,type); 
        if(p->is_fst) p->is_fst=0; /*如果坦克是第一次打出子弹.....*/ 
        else { Gm_Array[x][y]=Dt_Zero; Draw_Node(x,y,Dt_Zero); 
        } 
        p->x=xd; 
        p->y=yd; 
    } 
    else { 
        if(type==Dt_Me&&f_tp==Dt_Em) 
            Kill_Em(xd,yd); /*自己的子弹打到敌人则处理杀敌事件*/ 
        else if(type==Dt_Em&&f_tp==Dt_Me) 
            Game_Over(); /*敌人的子弹打到自己处理“游戏结束”事件*/ 
        if(!p->is_fst) 
        { /*处理子弹与子弹相遇的情况*/ 
            Gm_Array[x][y]=Dt_Zero; 
            Draw_Node(x,y,Dt_Zero); 
        if(f_tp==8) 
        { 
            Gm_Array[xd][yd]=Dt_Zero; 
            Draw_Node(xd,yd,Dt_Zero); /*销毁子弹*/ 
        Delete_Zdlink(xd,yd); 
        } 
        } 
        Delete_Zdlink(x,y); 
} 
    p=p->next; 
} 
}

void Control_Tank(Tk_Link p,Tk_Direct direct) 
{ 
    static char Rot_lb[4][4]={9,0,-1,1,0,9,1,-1,1,-1,9,0,-1,1,0,9}; 
    /*旋度表：9表示向前，0表示向后转，-1表示左转，1表示右转*/ 
    char rot=Rot_lb[p->drct-1][direct-1]; 
    /*查旋度表，根据坦克当前的方向和想要操作的方向确定坦克的行进状态*/ 
    if(rot==9) 
    { /*处理坦克前进*/ 
        if(Front_Ok(p,direct)) 
        { /*如果前方没有障碍前进*/ 
            Move_Tank(p->x,p->y,direct); 
            p->x+=ct_dx[direct-1]; 
            p->y+=ct_dy[direct-1]; 
    } 
    } 
    else if(Check_f_again(p)) 
    { /*如果满足旋转的条件，则旋转处理*/ 
        Rot_Tank(p->x,p->y,rot); 
        p->drct=rot_d[p->drct-1][rot+1]; /*刷新方向*/ 
} 
}

void Init_Tklink(void) 
{ /*初始化坦克事件链表*/ 
    Tk_List=(Tk_Link)malloc(sizeof(Tk_Node)); 
    Tk_List->x=10; 
    Tk_List->y=15; /*默认情况下链表中只有自己（在链表的第一个结点上）*/ 
    Tk_List->type=Dt_Me; 
    Tk_List->drct=Tk_Up; 
    Tk_List->next=NULL; 
}

void Init_Zdlink(void) 
{ /*初始化子弹链表（为空）*/ 
    Zd_List=NULL; 
}

void Insert_Tklink(int x,int y,Dt_Type type,Tk_Direct drct) 
{ /*在坦克事件链表上插入一个新的坦克*/ 
    Tk_Link p=Tk_List,s; 
    s=(Tk_Link)malloc(sizeof(Tk_Node)); 
    s->x=x; 
    s->y=y; 
    s->type=type; 
    s->drct=drct; 
    s->next=NULL; 
while(p&&p->next) 
p=p->next; 
p->next=s; 
}

void Insert_Zdlink(int x,int y,Dt_Type type,Tk_Direct drct) 
{ 
    Zd_Link p=Zd_List,s; /*在子弹链表上插入一个新的子弹*/ 
s=(Zd_Link)malloc(sizeof(Zd_Node)); 
s->x=x; 
s->y=y; 
s->type=type; 
s->drct=drct; 
s->next=NULL; 
s->is_fst=1; 
while(p&&p->next) 
p=p->next; 
if(p) p->next=s; 
else Zd_List=s; 
}

int Delete_Zdlink(int x,int y) 
{ /*在子弹链表上删除数据为（x,y）的子弹*/ 
    Zd_Link p=Zd_List,q; 
while(p&&(p->x!=x||p->y!=y)) 
{ q=p; 
p=p->next; 
}

if(p) 
{ 
    if(p==Zd_List) 
        Zd_List=Zd_List->next; 
else 
q->next=p->next;

free(p); 
return 1; 
} 
else return 0; 
}

int Delete_Tklink(int x,int y) 
{ /*删除一个坦克*/ 
    Tk_Link p=Tk_List,q;

while(p&&(p->x!=x||p->y!=y)) 
{ 
    q=p; 
p=p->next; 
} 
if(p) 
{ 
    if(p==Tk_List) 
        Tk_List=Tk_List->next; 
    else q->next=p->next; 
    free(p); 
    return 1; 
} 
else 
return 0; 
}

void Delete_Allt(void) 
{ /*删除所有的坦克*/ 
    Tk_Link p=Tk_List; 
    while(p) 
    { Tk_List=Tk_List->next; 
    free(p); 
    p=Tk_List; 
    } 
}

void Delete_Allz(void) 
{ /*删除所有的子弹*/ 
    Zd_Link p=Zd_List; 
    while(p) 
    { 
        Zd_List=Zd_List->next; 
    free(p); 
    p=Zd_List; 
} 
} 
void Init(void) 
{ /*对游戏中的所有数据和数据结构进行初始化*/ 
    int i,j; 
    for(i=0;i<M_Max;i++) /*对游戏矩阵初始化*/ 
        for(j=0;j<N_Max;j++) 
            Gm_Array[i][j]=Dt_Zero; 
            cs_tks=4; 
            kill_tks=0; 
            Me_Deads=0; 
            Init_Zdlink(); 
            Init_Tklink(); 
        Draw_Tankone(10,15,Tk_Up,1); 
        /*在边框的四个角出产生4个坦克*/ 
        Insert_Tklink(1,1,Dt_Em,Tk_Down); 
        Draw_Tankone(1,1,Tk_Down,0); 
        Insert_Tklink(1,28,Dt_Em,Tk_Down); 
        Draw_Tankone(1,28,Tk_Down,0); 
        Insert_Tklink(19,1,Dt_Em,Tk_Up); 
        Draw_Tankone(19,1,Tk_Up,0); 
        Insert_Tklink(19,28,Dt_Em,Tk_Up); 
        Draw_Tankone(19,28,Tk_Up,0); 
}

void Move_Tank(int x,int y,Tk_Direct type) 
{ /*按照要求的方向移动坦克*/ 
    static char mtdata[4][7]={
        {0,2,4,6,8,-2,0}, /*为了提高效率采用查表法进行处理*/ 
    {6,8,0,2,4,2,0}, /*7个数据表示所要检查或者处理的7个关键点*/ 
    {0,6,2,4,8,0,-2}, /*4表示方向：上，下，左，右*/ 
    {2,8,0,4,6,0,2}}; 
    int i,tx,ty; 
    int t_type=Gm_Array[x][y]; 
    for(i=0;i<5;i++) 
    { 
        tx=x+mtdata[type-1][i]/3-1; 
    ty=y+(mtdata[type-1][i]+3)%3-1; /*进行地址变换*/ 
    if(!(i/2)) 
    { 
        Draw_Node(tx,ty,Dt_Me); 
        Gm_Array[tx][ty]=t_type; 
    } 
    else 
    { 
        Draw_Node(tx,ty,Dt_Zero); 
        Gm_Array[tx][ty]=Dt_Zero; 
    } 
    } 
    tx=x+mtdata[type-1][5]; 
    ty=y+mtdata[type-1][6]; 
    Draw_Node(tx,ty,Dt_Me); 
    Gm_Array[tx][ty]=t_type; 
} 

void Draw_Node(int x,int y,Dt_Type type) 
{ /*在屏幕上画一个基础方块（由方块组成了坦克）*/ 
    int x_x=x*20+10; 
    int y_y=y*20+10; 
    if(type==Dt_Em) 
        setfillstyle(SOLID_FILL,RED); 
    else
    {
        if(type==Dt_Me)
            setfillstyle(SOLID_FILL,BLUE); 
        else
            setfillstyle(SOLID_FILL,BLACK);
    }
    bar(y_y+2,x_x+2,y_y+18,x_x+18); 
}

/*在屏幕上画一个坦克（当方向为no的时候表示擦除坦克）*/ 
void Draw_Tankone(int x,int y,Tk_Direct d,int who) 
{/*who 0:敌人,1:自己*/ 
    static Dt_Type dtdata[5][9]={
    {0,0,0,0,0,0,0,0,0}, /*全0表示不画坦克（擦除坦克）*/ 
    {0,1,0,1,1,1,1,0,1}, /*一个向上的坦克模型*/ 
    {1,0,1,1,1,1,0,1,0}, /*一个向下的坦克*/ 
    {0,1,1,1,1,0,0,1,1}, /*一个向左的坦克*/ 
    {1,1,0,0,1,1,1,1,0}}; /*一个向右的坦克*/ 
    /*例如一个向上的坦克：0，1，0，1，1，1，1，0，1表示 0 1 0 1 1 1 1 0 1 */ 
    int i=0,tx,ty; 
    for(i=0;i<9;i++) 
    { 
        tx=x+i/3-1; 
        ty=y+(i+3)%3-1; /*进行地址变换*/ 
        Draw_Node(tx,ty,dtdata[d][i]); 
        if(dtdata[d][i]) 
            Gm_Array[tx][ty]=who+1; /*修改游戏矩阵*/ 
        else 
            Gm_Array[tx][ty]=Dt_Zero; 
} 
}

void Rot_Tank(int x,int y,int LR) { /*在屏幕上旋转一个坦克*/ 
static char tk[8]={2,1,0,3,6,7,8,5}; /*坦克边缘数据（因为旋转一个坦克只需要旋转它边缘部分*/ 
static char tk_l[8]={8,5,2,1,0,3,6,7}; /*向左旋转的检查位置数据（需要对照tk表）*/ 
static char tk_r[8]={0,3,6,7,8,5,2,1}; /*向右旋转的检查位置数据*/ 
static char tk_bk[8]={6,7,8,5,2,1,0,3}; /*向后*/ 
Dt_Type tk_tp[8]; 
int i=0,tx,ty; 
Dt_Type disp; 
for(i=0;i<8;i++) 
{ 
if(LR==-1) 
tx=x+tk_l[i]/3-1, ty=y+(tk_l[i]+3)%3-1; /*如果是左旋，则查tk_l表进行地址变换*/ 
else if(LR==0) 
tx=x+tk_bk[i]/3-1, ty=y+(tk_bk[i]+3)%3-1; 
else if(LR==1) 
tx=x+tk_r[i]/3-1, ty=y+(tk_r[i]+3)%3-1; 
tk_tp[i]=Gm_Array[tx][ty]; 
tx=x+tk[i]/3-1; 
ty=y+(tk[i]+3)%3-1; 
Draw_Node(tx,ty,tk_tp[i]); 
} 
for(i=0;i<8;i++) 
{ /*旋转完了，改变游戏矩阵*/ 
    tx=x+tk[i]/3-1; 
    ty=y+(tk[i]+3)%3-1; 
    Gm_Array[tx][ty]=tk_tp[i]; 
} 
}