C language to achieve color Linez game

Preprocessing section
==============================================================================*/

#define Neo_temp_dir_unused
#define BOARD_COLOR 7

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

/*==============================================================================
Global Variables Section
==============================================================================*/

Char chesscolor[9][9]={0}; /* Define the color of the board pieces * *
Char chessboard[9][9]; /* Define Board Vacancy * *
Long grade=0; /* Score * *

/*==============================================================================
function section
==============================================================================*/
/*==============================================================================
Check whether the board has returned 1 full, dissatisfaction returned 0.
==============================================================================*/

int Boardfull (void) {
int i,t; /* Temporary Count * *
for (i=0;i<9;i++)
for (t=0;t<9;t++) if (chessboard[i][t]==1) return 0;
return 1;
}

/*==============================================================================
Randomly generated pieces.
==============================================================================*/

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);
}

/*==============================================================================
Draw the entire chessboard (including the pieces).
==============================================================================*/

void Drawboard (void) {
int i,t; /* Temporary Count * *
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,12,chesscolor[i][t]);
}

/*==============================================================================
Determines whether a piece of the Y column can be moved to line to_x in line x, to_y column, which returns 1 or 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;
}

/*==============================================================================
Determine whether the new pieces can be deleted after the pawn, you can eliminate and return 1, or return 0.
==============================================================================*/

int delchess (int x,int y) {
int i,j; /* Temporary Count * *
int sum=0;
/* Eliminate Vertical * *
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;
* * Eliminate rampage * *
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;
/* Eliminate oblique line (\) * *
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;
/* Eliminate oblique line (/) * *
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;
}

/*==============================================================================
Move a piece.
==============================================================================*/

void movechess (void) {
int Mousex,mousey;
int Mousetox,mousetoy;
while (1) {
Scare_mouse ();
Drawboard (); /* Draw the chessboard * *
Rectfill (0,0,640,16,0);
neo_printf (0,0, "Current score:%ld", grade);
Unscare_mouse ();
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;
Rect (mousex*40+20,mousey*40+20,mousex*40+60,mousey*40+60,4);
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;
Continue
}
else continue;
Break
}
}

/*==============================================================================
The main function.
==============================================================================*/

int main (void) {
int i; /* Temporary Count * *
int n=3;
Neo_init (); /* Initialize NEO Library * *
Set_video_mode (640,480,8,0,0); /* 640x480x64k Mode * *
Install_keyboard (); /* Load Advanced keyboard * *
_install_timer (); /* Load clock/*
Change_timer (500); /* Change (clock frequency) mouse refresh rate is 500 times/sec * *
Install_mouse (); /* Load Advanced mouse * *
Srand (100); /* Initialize random function * *

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

for (i=0;i<n;i++) buildchess ();
while (!boardfull ()) {
Movechess ();
for (i=0;i<n;i++) if (!boardfull ()) buildchess ();
}
Scare_mouse ();
Drawboard (); /* Draw the chessboard * *
Rectfill (0,0,640,16,0);
neo_printf (0,0, "Game over, your final score:%ld, thank you for your use", grade);
_getch ();
return 0;
}