stm32f103与2.4寸TFT可触液晶屏实现的五子棋AI人机对战(人工智能博弈树)

一、移植文件

PS：此工程基于STM32精英板！
将 chess.c 、 chess.h两个文件添加到过程文件夹下

1.1chess.c

#include "delay.h"	 	 
#include "lcd.h"        
#include "text.h" 
#include "touch.h"	
#include "chess.h"
#include "timer.h"


char param;				//游戏模式
char player = p1;	//默认黑棋先手

char chess[N][N];	//棋盘地图
int a[N],b[N];   //记录每一步棋子的座标位置

int chess_num = 0;		//总棋子数

char p1_time = time;	//黑棋剩余时间
char p2_time = time;	//白棋剩余时间

extern u16 POINT_COLOR;	//画笔颜色


void start1()//开始游戏
{
	Oninit();	
	draw_checkboard();//画棋盘	
	//show_param(param);

	while (1)
	{
		chesscomputer();
	}
}



void mymsg(int fun)//游戏结束弹出选择窗口
{
	LCD_Fill(Grid_wid,Grid_wid*3,Grid_wid*14,Grid_wid*9,LGRAY);//填充单色  实心矩形
	BACK_COLOR=LGRAY;
	POINT_COLOR=BLACK;
	if(fun == p1)
		Show_Str(Grid_wid*4,Grid_wid*4,200,24,"黑棋获胜!",24,0);
	else if(fun == p2)
		Show_Str(Grid_wid*4,Grid_wid*4,200,24,"白棋获胜!",24,0);	
	else if(fun == 3)
		Show_Str(Grid_wid*4,Grid_wid*4,200,24,"平局!",24,0);

	Show_Str(Grid_wid*2,Grid_wid*7,100,16,"重新开始",16,0);	
	Show_Str(Grid_wid*9,Grid_wid*7,100,16,"退出游戏",16,0);	
	
	POINT_COLOR=WHITE;
	LCD_DrawRectangle(Grid_wid*2-3, Grid_wid*7-3, Grid_wid*6+3, Grid_wid*8+3);  
	LCD_DrawRectangle(Grid_wid*9-3, Grid_wid*7-3, Grid_wid*13+3, Grid_wid*8+3); 
	POINT_COLOR=BLACK;
	BACK_COLOR=BROWN;
}
void Oninit()//初始化参数
{
	int i,j;
	player = p1;	//默认黑棋先手
	for (i = 0; i < N;i++)//棋盘清零
	{
		a[i]= Nochess;
		b[i]= Nochess;
		for (j = 0; j < N; j++)
		{
			chess[i][j] = Nochess;
		}
	}
	chess_num = 0;			//总棋子数清零
	p1_time = time;	//黑棋剩余时间
	p2_time = time;	//白棋剩余时间
}

void selete()//选择游戏模式
{
	draw_interface();//显示初始游戏菜单
	int xtemp,ytemp;
	while (1)
	{		
		tp_dev.scan(0);//扫描
		if (tp_dev.sta&TP_PRES_DOWN)//有按键被按下
		{
			delay_ms(10);//必要的延时,否则老认为有按键按下. 
			xtemp = tp_dev.x[0];
			ytemp = tp_dev.y[0];		
			if(xtemp>=112&&xtemp<=208&&ytemp>=114&&ytemp<=146)
			{
				param=player_player;
				LCD_DrawRectangle(112, 114, 208, 146);  
				delay_ms(500);
				return;
			}			
			else if(xtemp>=112&&xtemp<=208&&ytemp>=164&&ytemp<=196)
			{
				param=player_AI;
				LCD_DrawRectangle(112, 164, 208, 196);
				delay_ms(500);
				return;
			}
		}
		else 
			delay_ms(10); 
	}
}

void start()//开始游戏
{
	int x1, y1;
	Oninit();	
	draw_checkboard();//画棋盘	
	show_param(param);
	show_time();

	while (1)
	{
		TIM_Cmd(TIM3, ENABLE);  //使能TIMx
		tp_dev.scan(0);//扫描
		if (tp_dev.sta&TP_PRES_DOWN)//有按键被按下
		{
			delay_ms(10);//必要的延时,否则老认为有按键按下 
			//按下悔棋按钮 改变外框颜色
			if(tp_dev.x[0]>=Grid_wid*(N + 1)-2&&tp_dev.x[0]<=Grid_wid*(N + 3)+2&&tp_dev.y[0]>=Grid_wid*(N/2 + 1)&&tp_dev.y[0]<=Grid_wid*(N/2 + 2)+6)
			{
				LCD_DrawRectangle(Grid_wid*(N + 1)-2, Grid_wid*(N/2 + 1), Grid_wid*(N + 3)+2, Grid_wid*(N/2 + 2)+6);
				retract_chess();//悔棋
				delay_ms(500);
				POINT_COLOR=WHITE;
				LCD_DrawRectangle(Grid_wid*(N + 1)-2, Grid_wid*(N/2 + 1), Grid_wid*(N + 3)+2, Grid_wid*(N/2 + 2)+6);
				POINT_COLOR=BLACK;
			}	
						
			x1 = mod_xy(tp_dev.x[0]);
			y1 = mod_xy(tp_dev.y[0]);			
			if (param == player_player)
			{
					TIM_Cmd(TIM3, DISABLE);  //关闭使能TIMx外设
					delay_ms(100);
					Chess_piece(x1, y1);
			}
			else if (param == player_AI)
			{
					if (Chess_piece(x1, y1))
					{
						TIM_Cmd(TIM3, DISABLE);  //关闭使能TIMx外设
						delay_ms(500);
						chesscomputer();
					}	
			}		
		}
		
		if(p1_time == 0||p2_time == 0)//到时间了则对方获胜
		{
				p1_time=time;
				p2_time=time;
				Restart(1,p1+p2-player);
		}
	}
}

void Restart(int par,int player)//重新开始游戏
{
	if (par == 1)
		mymsg(player);			
	else
		mymsg(3);		

	int xtemp,ytemp;
	while (1)
	{		
		p1_time = time;	//黑棋剩余时间
		p2_time = time;	//白棋剩余时间
		tp_dev.scan(0);//扫描
		if (tp_dev.sta&TP_PRES_DOWN)//有按键被按下
		{
			delay_ms(10);//必要的延时,否则老认为有按键按下. 
			xtemp = tp_dev.x[0];
			ytemp = tp_dev.y[0];		

			if(xtemp>=Grid_wid*2-3&&xtemp<=Grid_wid*6+3&&ytemp>=Grid_wid*7-3&&ytemp<=Grid_wid*8+3)
			{
				LCD_DrawRectangle(Grid_wid*2-3, Grid_wid*7-3, Grid_wid*6+3, Grid_wid*8+3); 
				delay_ms(300); 				
				start();
			}			
			else if(xtemp>=Grid_wid*9-3&&xtemp<=Grid_wid*13+3&&ytemp>=Grid_wid*7-3&&ytemp<=Grid_wid*8+3)
			{
				LCD_DrawRectangle(Grid_wid*9-3, Grid_wid*7-3, Grid_wid*13+3, Grid_wid*8+3); 
				delay_ms(300); 			
				//软件复位
				__disable_fault_irq();
				NVIC_SystemReset();
			}
		}
		else 
			delay_ms(10); 
	}
}


void draw_checkboard()//绘制棋盘
{
	BACK_COLOR=BROWN;
	LCD_Clear(BROWN);//设置背景色
	int i;
	for (i = 0; i < N;i++)//画地图
	{
		lcd_draw_bline(m_wid + i*Grid_wid, m_wid, m_wid + i*Grid_wid, m_wid + Grid_wid * (N - 1),1,BLACK);
		lcd_draw_bline(m_wid, m_wid + i*Grid_wid, m_wid + Grid_wid * (N - 1), m_wid + i*Grid_wid,1,BLACK);
	}
	//3 3    3 11   7 7    11 3    11 11  五个点的位置
	gui_fill_circle(m_wid+3*Grid_wid, m_wid+3*Grid_wid, 3, BLACK);
	gui_fill_circle(m_wid+3*Grid_wid, m_wid+11*Grid_wid, 3, BLACK);
	gui_fill_circle(m_wid+7*Grid_wid, m_wid+7*Grid_wid, 3, BLACK);
	gui_fill_circle(m_wid+11*Grid_wid, m_wid+3*Grid_wid, 3, BLACK);
	gui_fill_circle(m_wid+11*Grid_wid, m_wid+11*Grid_wid, 3, BLACK);
}



void draw_interface()//绘制初始游戏选择界面
{
	BACK_COLOR=LIGHTGREEN;
  LCD_Clear(LIGHTGREEN);
	
	int x1=72;
	POINT_COLOR=YELLOW;
	Show_Str(x1,48,200,24,"五",24,0);
	POINT_COLOR=WHITE;
	Show_Str(x1+24*3,48,200,24,"子",24,0);
	POINT_COLOR=BROWN;
  Show_Str(x1+24*6,48,200,24,"棋",24,0);
	POINT_COLOR=WHITE;
  LCD_DrawRectangle(112, 114, 208, 146);
  LCD_DrawRectangle(112, 164, 208, 196);
	POINT_COLOR=BLACK;
	Show_Str(128,122,200,16,"人人对战",16,0);	
	Show_Str(128,172,200,16,"人机对战",16,0);
	BACK_COLOR=BROWN;
}


void remove_chess(int x1,int y1)//擦除棋子
{
	gui_fill_circle(m_wid+x1*Grid_wid, 	m_wid+y1*Grid_wid, Chess_R, BROWN);
	lcd_draw_bline(m_wid+x1*Grid_wid-Chess_R, m_wid+y1*Grid_wid,m_wid+x1*Grid_wid+Chess_R, m_wid+y1*Grid_wid,1,BLACK);
	lcd_draw_bline(m_wid+x1*Grid_wid, m_wid+y1*Grid_wid-Chess_R,m_wid+x1*Grid_wid, m_wid+y1*Grid_wid+Chess_R,1,BLACK);

	if(x1==0)		
		lcd_draw_bline(m_wid, m_wid+y1*Grid_wid,m_wid+Chess_R, m_wid+y1*Grid_wid,1,BLACK);
	if(y1==0)
		lcd_draw_bline(m_wid+x1*Grid_wid, m_wid,m_wid+x1*Grid_wid, m_wid+Chess_R,1,BLACK);
	if(x1==N-1)
		lcd_draw_bline(m_wid+x1*Grid_wid+2, m_wid+y1*Grid_wid,m_wid+x1*Grid_wid+Chess_R, m_wid+y1*Grid_wid,1,BACK_COLOR);	
	if(y1==N-1)
		lcd_draw_bline(m_wid+x1*Grid_wid, m_wid+y1*Grid_wid+1,m_wid+x1*Grid_wid, m_wid+y1*Grid_wid+Chess_R,1,BACK_COLOR);


	//如果是五个特殊点	 五个点的位置:3 3    3 11   7 7    11 3    11 11  
	if(
			(x1==3&&y1==3) 	||
			(x1==3&&y1==11) ||
			(x1==7&&y1==7) 	||
			(x1==11&&y1==3) ||
			(x1==11&&y1==11) 
		)
	{
		gui_fill_circle(m_wid+x1*Grid_wid, m_wid+y1*Grid_wid, 3, BLACK);
	}
}




void retract_chess()//悔棋
{ 
	if(chess_num>=2)
	{
		int x1,y1;
		
		x1 = a[chess_num-1];
		y1 = b[chess_num-1];
		chess[x1][y1] = Nochess;
		remove_chess(x1,y1);
		chess_num--;
		
		x1 = a[chess_num-1];
		y1 = b[chess_num-1];
		chess[x1][y1] = Nochess;
		remove_chess(x1,y1);
		chess_num--;
		
		p1_time = time;	//黑棋剩余时间
		p2_time = time;	//白棋剩余时间
		
	}
}


void show_param(int n)//显示游戏模式
{
	POINT_COLOR=WHITE;
	if(n==player_AI)
	{
		Show_Str(Grid_wid*N,Grid_wid*(N/2 - 2),			 200,16,"人机对战",16,0);		
	}
	else if(n==player_player)
	{
		Show_Str(Grid_wid*N,Grid_wid*(N/2 - 2),			 200,16,"人人对战",16,0);		
	}
	POINT_COLOR=BLACK;
	Show_Str(Grid_wid*(N + 1),Grid_wid*(N/2 + 1)+3,			 200,16,"悔棋",16,0);		
	POINT_COLOR=WHITE;
  LCD_DrawRectangle(Grid_wid*(N + 1)-2, Grid_wid*(N/2 + 1), Grid_wid*(N + 3)+2, Grid_wid*(N/2 + 2)+6);
	POINT_COLOR=BLACK;
}

void show_time(void)//显示剩余时间
{
	gui_fill_circle(Grid_wid*N+Chess_R, 	Grid_wid*2+Chess_R, Chess_R, BLACK);
	Show_Str			 (Grid_wid*(N+1),				Grid_wid*2,					200,16,		"剩余:",16,0);		
	LCD_ShowNum		 (Grid_wid*(N+3)+m_wid,	Grid_wid*2,					p1_time-1,2,16);//显示一个数字
	Show_Str			 (Grid_wid*(N+5)-m_wid,	Grid_wid*2,					200,16,		"s",16,0);		
	
	gui_fill_circle(Grid_wid*N+Chess_R, 	Grid_wid*12+Chess_R, Chess_R, WHITE);
	Show_Str			 (Grid_wid*(N+1),				Grid_wid*12,				200,16,		"剩余:",16,0);	
	LCD_ShowNum		 (Grid_wid*(N+3)+m_wid,	Grid_wid*12,				p2_time-1,2,16);//显示一个数字	
	Show_Str			 (Grid_wid*(N+5)-m_wid,	Grid_wid*12,				200,16,		"s",16,0);
}


int mod_xy(int xy)//座标修正
{
	int res = (int)((double)(xy-m_wid) / Grid_wid + 0.5);
	if (res < N && res >= 0)
	{
		return res;
	}
	else
	{
		return -1;
	}
}



int judge(int x, int y)//判断此位置是否可以落子
{
	return chess[x][y] ? 0 : 1;
}


int judge_win(int x, int y)//判断游戏输赢
{
	int i, j, k;
	const int step[4][2] = { { 1, 0 }, { 0, 1 }, { 1, 1 }, { 1, -1 } };
	for (i = 0; i < 4; ++i)
	{
		const int d[2] = { -1, 1 };
		int count = 1;
		for (j = 0; j < 2; ++j)
		for (k = 1; k <= 4; ++k)
		{
			int row = x + k*d[j] * step[i][0];
			int col = y + k*d[j] * step[i][1];
			if (row >= 1 && row <= N &&
				col >= 1 && col <= N &&
				chess[x][y] == chess[row][col])
				count += 1;
			else
				break;
		}
		if (count >= 5)
			return 1;
	}
	if (chess_num == N*N)
	{
		delay_ms(1000);
		Restart(2,player);		
	}

	return 0;
}



int Chess_piece(int x1, int y1)//落子
{
	if(x1 == -1||y1 == -1)
	{
		return 0;
	}
	if (judge(x1, y1))
	{
		if (player == p1)
			gui_fill_circle(m_wid+x1*Grid_wid, 	m_wid+y1*Grid_wid, Chess_R, BLACK);
		else
			gui_fill_circle(m_wid+x1*Grid_wid, 	m_wid+y1*Grid_wid, Chess_R, WHITE);
		chess[x1][y1] = player;
		//按顺序存储每一个棋子的座标位置
		a[chess_num] = x1;
		b[chess_num] = y1;		
		chess_num++;
		if (judge_win(x1, y1))
		{
			delay_ms(1000);
			Restart(1,player); 
		}
		changeplayer();
		p1_time=time;
		LCD_ShowNum			 (Grid_wid*(N+3)+m_wid,Grid_wid*2,				p1_time-1,2,16);  						//显示一个数字
		p2_time=time;
		LCD_ShowNum			 (Grid_wid*(N+3)+m_wid,Grid_wid*12,				p2_time-1,2,16);  						//显示一个数字
		return 1;
	}
	return 0;
}


void changeplayer()//玩家交换
{
	player = p1 + p2 - player;
}


int scorejudge(int row,int col)//评分系统使用的判断是否可以落子函数
{
	if ((row >= 0 && row < N) && (col >= 0 && col < N))
	{
		return 1;
	} 
	else
	{
		return 0;
	}
}



int chessscore(int x, int y, int worb)//棋盘权值函数
{
	int sumscore = 0;
	char u, d, l, r, lu, ld, ru, rd;//u上 d下 l左 r右 lu左上 ld左下 ru右上 rd右下
	int row, col, count1, count2, count3, count4;   //1横 2竖 3斜上 4斜下
	count1 = count2 = count3 = count4 = 1;
	l = r = u = d = lu = ld = ru = rd = 0;
	chess[x][y] = worb;      //模拟下棋

	//横向
	row = x, col = y + 1;
	while (chess[row][col] == worb && scorejudge(row,col))
	{
		count1++;
		col++;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		r++;
		col++;
	}
	row = x, col = y - 1;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count1++;
		col--;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		l++;
		col--;
	}


	//竖向
	row = x + 1, col = y;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count2++;
		row++;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		d++;
		row++;
	}
	row = x - 1, col = y;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count2++;
		row--;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		u++;
		row--;
	}

	//斜上
	row = x - 1, col = y + 1;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count3++;
		col++;
		row--;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		ru++;
		col++;
		row--;
	}
	row = x + 1, col = y - 1;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count3++;
		col--;
		row++;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		ld++;
		col--;
		row++;
	}
	

	//斜下
	row = x + 1, col = y + 1;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count4++;
		col++;
		row++;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		rd++;
		col++;
		row++;
	}
	row = x - 1, col = y - 1;
	while (chess[row][col] == worb && scorejudge(row, col))
	{
		count4++;
		col--;
		row--;
	}
	while (chess[row][col] == 0 && scorejudge(row, col))
	{
		lu++;
		col--;
		row--;
	}

	chess[x][y] = Nochess;

	if (count1 >= 5 || count2 >= 5 || count3 >= 5 || count4 >= 5)//成五
	{
		return sumscore = 5000000;
	}


	if ((count1 == 4 && count2 == 4 && l >= 1 && r >= 1 && u >= 1 && d >= 1) ||
		(count1 == 4 && count3 == 4 && l >= 1 && r >= 1 && ru >= 1 && ld >= 1) ||
		(count1 == 4 && count4 == 4 && l >= 1 && r >= 1 && rd >= 1 && lu >= 1) ||
		(count2 == 4 && count3 == 4 && u >= 1 && d >= 1 && ru >= 1 && ld >= 1) ||
		(count2 == 4 && count4 == 4 && u >= 1 && d >= 1 && lu >= 1 && rd >= 1) ||
		(count3 == 4 && count4 == 4 && ru >= 1 && ld >= 1 && lu >= 1 && rd >= 1))
		//双活四
	{
		return sumscore = 4000000;
	}


	if ((count1 == 4 && l >= 1 && r >= 1) || (count2 == 4 && u >= 1 && d >= 1) ||
		(count3 == 4 && ru >= 1 && ld >= 1) || (count4 == 4 && lu >= 1 && rd >= 1))
		//活四
	{
		return sumscore = 800000;
	}

	if ((count1 == 4 && ((l == 0 && r >= 1) || (l >= 1 && r == 0))) 
		|| (count2 == 4 && ((u == 0 && d >= 1) || (u >= 1 && d == 0))) 
		||(count3 == 4 && ((ld == 0 && ru >= 1) || (ld >= 1 && ru == 0))) 
		|| (count4 == 4 && ((lu == 0 && rd >= 1) || (lu >= 1 && rd == 0))))
	{
		sumscore = sumscore + 35000; //成四
	}

	if ((count1 == 3 && count2 == 3 && l >= 1 && r >= 1 && u >= 1 && d >= 1) ||
		(count1 == 3 && count3 == 3 && l >= 1 && r >= 1 && ru >= 1 && ld >= 1) ||
		(count1 == 3 && count4 == 3 && l >= 1 && r >= 1 && rd >= 1 && lu >= 1) ||
		(count2 == 3 && count3 == 3 && u >= 1 && d >= 1 && ru >= 1 && ld >= 1) ||
		(count2 == 3 && count4 == 3 && u >= 1 && d >= 1 && lu >= 1 && rd >= 1) ||
		(count3 == 3 && count4 == 3 && ru >= 1 && ld >= 1 && lu >= 1 && rd >= 1)) 
		//双活三
	{
		return sumscore + 400000;
	}


	if ((count1 == 3 && l >= 1 && r >= 1) || (count2 == 3 && u >= 1 && d >= 1) ||
		(count3 == 3 && ru >= 1 && ld >= 1) || (count4 == 3 && lu >= 1 && rd >= 1))
		//活三
	{
		sumscore = sumscore + 60000;
		return sumscore;
	} 


	if ((count1 == 2 && count2 == 2 && l >= 1 && r >= 1 && u >= 1 && d >= 1) ||
		(count1 == 2 && count3 == 2 && l >= 1 && r >= 1 && ru >= 1 && ld >= 1) ||
		(count1 == 2 && count4 == 2 && l >= 1 && r >= 1 && rd >= 1 && lu >= 1) ||
		(count2 == 2 && count3 == 2 && u >= 1 && d >= 1 && ru >= 1 && ld >= 1) ||
		(count2 == 2 && count4 == 2 && u >= 1 && d >= 1 && lu >= 1 && rd >= 1) ||
		(count3 == 2 && count4 == 2 && ru >= 1 && ld >= 1 && lu >= 1 && rd >= 1))
		//双活二
	{
		sumscore = sumscore + 20000;
	}

	if ((count1 == 2 && l >= 1 && r >= 1) || (count2 == 2 && u >= 1 && d >= 1) ||
		(count3 == 2 && ru >= 1 && ld >= 1) || (count4 == 2 && lu >= 1 && rd >= 1))
		//单活二
	{
		sumscore = sumscore + 10000;
	}
	if ((count1 == 3 && ((l == 0 && r >= 1) || (l >= 1 && r == 0)))
		|| (count2 == 3 && ((u == 0 && d >= 1) || (u >= 1 && d == 0)))
		|| (count3 == 3 && ((ld == 0 && ru >= 1) || (ld >= 1 && ru == 0)))
		|| (count4 == 3 && ((lu == 0 && rd >= 1) || (lu >= 1 && rd == 0))))
	{
		sumscore = sumscore + 5000; //成三
	}
	return sumscore;

}

void chesscomputer()//机器落子
{
int i, j, cscore, cscorel, pscore, pscorel, row1, col1, row2, col2;
	cscore = pscore = 0; row1 = row2 = col1 = col2 = -1;
	
	//寻找最优落子位置
	if (chess_num <= 1)
	{
		row1 = 7;
		col1 = 7;
		do
		{
			row1++;
			col1++;
		} while (!judge(row1, col1));
		Chess_piece(row1, col1);
	}
	else
	{
		for (i = 0; i < N; i++)
		{
			for (j = 0; j < N; j++)
			{
				if (judge(i, j))
				{
					cscorel = chessscore(i, j, p1);
					if (cscorel > cscore)
					{
						cscore = cscorel;
						row1 = i;
						col1 = j;
					}
					pscorel = chessscore(i, j, p2);
					if (pscorel > pscore)
					{
						pscore = pscorel;
						row2 = i;
						col2 = j;
					}
				}
			}
		}
		if (row1 == -1 && col1 == -1 && row2 == -1 && col2 == -1)//没找到最优解 平局
		{
				Restart(2,player);
		}
		else
		{
			if (chess_num == 3)
			{
				Chess_piece(row2, col2);
			}
			else
			{
				if (cscore > pscore)
				{
					Chess_piece(row1, col1);							
				}
				else
				{
					Chess_piece(row2, col2);
				}
			}
		}
	}
}

1.2chess.h

#ifndef __CHESS_H__
#define __CHESS_H__


#define Grid_wid 	16 						//网格宽度
#define m_wid 		(Grid_wid/2)  //修正宽度
#define Chess_R  	(Grid_wid/2)  //棋子半径

#define p1 				1							//玩家1
#define p2 				2							//玩家2
#define Nochess 	0							//空棋

#define N  				15						//棋盘格数

#define player_player	3					//人人模式
#define player_AI			4					//人机模式

#define time 16									//每方下棋剩余时间

void start1();										//机器与机器对战，测试用
void mymsg(int fun);							//游戏结束弹出选择窗口
void Oninit(void);								//初始化参数
void selete(void);								//选择游戏模式
void start(void);									//开始游戏
void Restart(int par,int player); //重新开始游戏
void draw_checkboard(void);				//绘制棋盘
void draw_interface(void);				//绘制初始游戏选择界面
void remove_chess(int x1,int y1); //擦除棋子
void retract_chess(void);					//悔棋
void show_param(int n);						//显示游戏模式
void show_time(void);							//显示剩余时间
int mod_xy(int xy);								//座标修正
int judge(int x, int y);					//判断此位置是否可以落子
int judge_win(int x, int y);			//判断游戏输赢
int Chess_piece(int x, int y);		//落子
void changeplayer(void);					//玩家交换
int scorejudge(int row,int col);	//评分系统使用的判断是否可以落子函数
int chessscore(int x, int y, int worb);//棋盘权值函数
void chesscomputer(void);					//机器落子


#endif

二、运行游戏

2.1 修改main.c添加Restart函数并调用start函数

#include "stm32f10x.h"
#include "sys.h"
#include "delay.h"
#include "usart.h" 
#include "led.h" 		 	 
#include "lcd.h"  
#include "key.h"      
#include "malloc.h"
#include "sdio_sdcard.h"  
#include "w25qxx.h"    
#include "ff.h"  
#include "exfuns.h"   
#include "text.h" 
#include "atk_ncr.h"
#include "touch.h"	
#include "chess.h"
#include "timer.h"


int main(void)
{
	delay_init();	    	 //延时函数初始化	  
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
	uart_init(115200);	 	//串口初始化为115200
	LED_Init();		  			//初始化与LED连接的硬件接口
	KEY_Init();					//初始化按键
	LCD_Init();			   		//初始化LCD     
	W25QXX_Init();				//初始化W25Q128
	tp_dev.init();				//初始化触摸屏
	my_mem_init(SRAMIN);		//初始化内部内存池
	exfuns_init();				//为fatfs相关变量申请内存  
	f_mount(fs[0], "0:", 1); 		//挂载SD卡 
	f_mount(fs[1], "1:", 1); 		//挂载FLASH.
	alientek_ncr_init();		//初始化手写识别     
	while (font_init()) 			//检查字库
	{
		LCD_ShowString(30, 50, 200, 16, 16, "Font Error!");
		delay_ms(200);
		LCD_Fill(30, 50, 240, 66, WHITE);//清除显示	     
	}
	TIM3_Int_Init(9999,7199);//计时器 1s	
	TP_Init();
	//TP_Adjust();
	//start1();//开始游戏
	selete();//游戏模式选择
	start();//开始游戏
}