基于c语言的象棋游戏-附带人机算法

最新推荐文章于 2024-05-13 16:48:47 发布
最新推荐文章于 2024-05-13 16:48:47 发布
阅读量4.3k 收藏 47
点赞数 9
文章标签： c语言 游戏 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59564114/article/details/122686501
版权

2.1 设计流程

进入象棋游戏后，输出开始界面（直接调用图片如图2.1所示）根据玩家的选择（鼠标点击的位置）进入不同模式，双人模式中，根据鼠标点击移动棋子，人机模式中玩家移动之后，电脑自动选择路径并移动棋子。

                                                    图2.1 开始界面展示 

输出开始界面，向玩家提供双人模式/人机模式选择。

2.3.1 棋牌展示

 输出棋盘背景，包含方格线、“楚河”、“汉界”等如图2.2。

                                                  图 2.2 棋盘背景

2.3.2 棋子展示

    按照象棋棋子的摆法，在指定坐标出画出棋子。

2.3.3 各棋子子移动

俥，马，象，士，炮，将，兵分别写移动规则[3]（根据起始坐标和目的坐标判断是否可以移动）。

2.3.4 判断胜负

棋盘信息没改变一次就扫描一次棋盘，如果一方的将被覆盖（被对方所吃），则输出另一方获胜。游戏结束。

2.4 人机模块

2.4.1玩家移动

同双人模式的玩家移动一样，利用鼠标信息进行判断和移动。

2.4.2 虚拟棋盘

建立虚拟棋盘，棋盘信息与实际棋盘一致、并随着实际棋盘信息同步改变。

2.4.3 遍历当前虚拟棋盘

遍历棋盘，找到每一颗黑方的棋子，查询该棋子是否下一步可能被玩家吃掉，如果是则加权，并找到每一种可行的路径。

2.4.4 模拟行棋

利用虚拟棋盘按照找到的路径去进行模拟棋子移动，查询在移动的时候是否能吃掉红方棋子，如果是则加权。

2.4.5 遍历模拟之后的棋盘

在虚拟棋盘棋子移动的之后，遍历棋盘，判断当前状态下，当红方行棋时，自己可能被吃掉那些棋子，并做加权。

2.4.6 选择每颗棋子的最优路径

通过三次加权后，得分最高的路径作为该棋子的最优路径。

2.4.7 恢复虚拟棋盘

选择完一颗黑方棋子的最优路径后，使虚拟棋盘恢复，继续选择下一个棋子的最优路径。

2.4.8 最终移动选择

通过比较每颗棋子的加权分，得到最优棋子和该棋子的最优路径。在实际棋盘上移动该棋子。

2.4.9 判断胜负

棋盘信息没改变一次就扫描一次棋盘，如果一方的将被覆盖，则输出另一方获胜。游戏结束。

代码运行流程：

 完整代码：

#include<stdio.h>
#include<graphics.h>
#include<math.h>
void execute(int a, int b, int c, int d);
bool jiang(int a, int b, int  c, int d);
bool pao(int a, int b, int c, int d);
bool ma(int a, int b, int c, int d);
bool AIifdown(int a, int b,int c,int d);
bool bing(int a, int b, int c, int d);
float ALLifdown();
float  ALifdowntow();
float  AIpower(int a, int b);
void llll();
void AIControl();//获取鼠标点击信息并完响应
IMAGE img;
#define distance  35
#define   longth  65
#define   high   61
struct AIcoord {
	int beginx;
	int beginy;
	int endx;
	int endy;
	float power;
};
struct AIcoord AIblack[20];//将：100；俥：8；炮：6；马：4；象：3；兵：3，仕：2；
struct movecoordinate
{
	long x;
	long y;
};
struct  Chesscoordinate//棋子综合信息
{
	int x;
	int y;
	DWORD type;  //颜色
	bool river;//是否过河
	int id;
};

enum pieces
{
	SPACE = -1,
	車, 馬, 象, 士, 将, 炮, 卒,
	车, 马, 相, 仕, 帥, 砲, 兵,
	BEGIN, END,

};
enum pieces redchess[] = { 車,馬,象,士,将,炮,卒, };
enum pieces blackchess[] = { 车,马,相,仕,帥,砲,兵, };
enum pieces state = BEGIN;
struct move {  //鼠标选中的棋子
	int beginx;
	int beginy;
	int endx;
	int endy;
	int state;
}moving = { -1,-1,-1,-1,BEGIN };
const char* chessname[] = { "車","馬","象","士","将","炮","卒","车","马","相","仕","帥","砲","兵", };
struct Chesscoordinate  map[9][10];//坐标
struct Chesscoordinate  AImap[9][10];//坐标
movecoordinate begin = { -1,-1 }, end = { -1,-1 };
int  xx(int a)//数组下标转换成坐标
{
	a = distance + longth * a;
	return a;
}
int  yy(int a)
{
	a = distance + high * a;
	return a;
}
void AIfollowchess()
{
	for (int i = 0; i <= 8; i++)
	{
		for (int j = 0; j <= 9; j++)
		{
			AImap[i][j].id = map[i][j].id;
			AImap[i][j].river = map[i][j].river;
			AImap[i][j].type = map[i][j].type;
			AImap[i][j].x = map[i][j].x;
			AImap[i][j].y = map[i][j].y;
		}
	}
}
void begining()
{
	loadimage(&img, "C:/Users/ASUS/Desktop/shess/66.jpg");
	initgraph(img.getwidth(), img.getheight(), 1);
	putimage(0, 0, &img);//输出开始界面；

}
void  qiban()
{
	loadimage(&img, "C:/Users/ASUS/Desktop/shess/5.jpg");
	initgraph(img.getwidth(), img.getheight(), 1);
	putimage(0, 0, &img);//输出棋盘
}
void  coord()//棋子信息赋值
{
	loadimage(&img, "C:/Users/ASUS/Desktop/shess/5.jpg");
	putimage(0, 0, &img);//输出棋盘

	for (int i = 0; i <= 8; i++)
	{

		for (int j = 0; j <= 9; j++)//遍历二维数组
		{
			enum pieces chessid = SPACE;//先把全部位置的id赋值为SAPCE
			DWORD  chesstype;//定义颜色中间变量
			if (j <= 4)
			{
				chesstype = BLACK;//黑方
				if (j == 0)
				{
					if (i <= 4)
					{
						chessid = blackchess[i];//
					}
					else
					{
						chessid = blackchess[8 - i];
					}

				}
				if (j == 2 && (i == 1 || i == 7))
				{
					chessid = blackchess[5];

				}

				if (j == 3 && (i == 0 || i == 2 || i == 4 || i == 4 || i == 6 || i == 8))
				{
					chessid = blackchess[6];
				}

			}
			else
			{
				chesstype = RED;//红方
				if (j == 6 && (i == 0 || i == 2 || i == 4 || i == 6 || i == 8))
				{
					chessid = redchess[6];
				}
				if (j == 7 && (i == 1 || i == 7))
				{
					chessid = redchess[5];

				}

				if (j == 9)
				{

					if (i <= 4)
					{
						chessid = redchess[i];
					}
					else
					{
						chessid = redchess[8 - i];
					}
				}

			}//依次赋值
			map[i][j].id = chessid;
			map[i][j].river = false;
			map[i][j].type = chesstype;
			map[i][j].x = distance + longth * i;
			map[i][j].y = distance + high * j;
			AIfollowchess();


		}
	}
	for (int i = 0; i <= 8; i++)
	{
		for (int j = 0; j <= 9; j++)
		{
			if (map[i][j].id == SPACE)
			{
				map[i][j].type = YELLOW;
			}
		}
	}

}
void getbackground() //画棋子
{
	int x_start, y_start;
	x_start = distance;
	y_start = distance;



	settextstyle(30, 0, "黑体");//棋子大小颜色
	setbkmode(0);
	for (int i = 0; i <= 8; i++)
	{

		for (int j = 0; j <= 9; j++)
		{

			if (map[i][j].id != SPACE)//在棋盘上输出
			{
				setfillcolor(RGB(253, 216, 161));
				//	setlinestyle(BLACK);
				settextcolor(map[i][j].type);
				fillcircle(map[i][j].x, map[i][j].y, 24);
				fillcircle(map[i][j].x, map[i][j].y, 18);
				outtextxy(map[i][j].x - 13, map[i][j].y - 13, chessname[map[i][j].id]);

			}
		}
	}

}
void movechess(int a, int b, int c, int d)//移动棋子，改变其坐标
{

	map[c][d].id = map[a][b].id;
	map[c][d].river = map[a][b].river;
	map[c][d].type = map[a][b].type;
	map[c][d].x = xx(c);
	map[c][d].y = yy(d);
	map[a][b].id = SPACE;
	map[a][b].type = YELLOW;
	AIfollowchess();

}
void AImovechess(int a, int b, int c, int d)//移动棋子，改变其坐标
{

	AImap[c][d].id = map[a][b].id;
	AImap[c][d].river = map[a][b].river;
	AImap[c][d].type = map[a][b].type;
	AImap[c][d].x = c;
		AImap[c][d].y = d;
	AImap[a][b].id = SPACE;
	AImap[a][b].type = YELLOW;

}
void MouseControl()//获取鼠标点击信息并完响应
{
	//getbackground();
	if (MouseHit())
	{

		float beginrow, beginrol, endrow, endrol;//第一次按下时的坐标
		int intbeginrow, intbeginrol, intendrow, intendrol;//第二次按下时的坐标
		MOUSEMSG msg = GetMouseMsg();
		if (msg.uMsg == WM_LBUTTONDOWN)
		{
			//获取鼠标点击的数组的下标
		//	printf("(%d,%d)", msg.x, msg.y);
			beginrow = (float)(msg.x - distance) / longth;
			beginrol = (float)(msg.y - distance) / high;
			intbeginrow = round(beginrow);
			intbeginrol = round(beginrol);
			if (moving.state == BEGIN)
			{
				moving.state = END;
				moving.beginx = intbeginrow;
				moving.beginy = intbeginrol;
				//	printf("(%d,%d)  \n", moving.beginx, moving.beginy);
			}
			else if (moving.state == END)
			{



				moving.state = BEGIN;
				moving.endx = intbeginrow;
				moving.endy = intbeginrol;
				
				execute(moving.beginx, moving.beginy, moving.endx, moving.endy);
			
				
			}


		}

	}



}
int  MouseControlone()//获取鼠标点击信息并完响应
{
	if (MouseHit())
	{

		MOUSEMSG msg = GetMouseMsg();
		if (msg.uMsg == WM_LBUTTONDOWN)
		{
			//printf("(%d,%d)", msg.x, msg.y);
			//获取鼠标点击的数组的下标
			if (msg.y > 550 && msg.y < 617)
			{
				if (msg.x > 160 && msg.x < 280)
				{
					return 1;
				}
				else if (msg.x > 302 && msg.x < 414)
				{
					return 2;
				}
				else
				{
					return  3;
				}
			}
			else
			{
				return 4;
			}
		}

	}
	else
	{
		return 0;
	}
	
}
void  AIControl()//获取鼠标点击信息并完响应
{
	//getbackground();
	if (MouseHit())
	{

		float beginrow, beginrol, endrow, endrol;//第一次按下时的坐标
		int intbeginrow, intbeginrol, intendrow, intendrol;//第二次按下时的坐标
		MOUSEMSG msg = GetMouseMsg();
		if (msg.uMsg == WM_LBUTTONDOWN)
		{
			//获取鼠标点击的数组的下标
		//	printf("(%d,%d)", msg.x, msg.y);
			beginrow = (float)(msg.x - distance) / longth;
			beginrol = (float)(msg.y - distance) / high;
			intbeginrow = round(beginrow);
			intbeginrol = round(beginrol);
			if (moving.state == BEGIN)
			{
				moving.state = END;
				moving.beginx = intbeginrow;
				moving.beginy = intbeginrol;

				//	printf("(%d,%d)  \n", moving.beginx, moving.beginy);
			}
			else if (moving.state == END)
			{

				moving.state = BEGIN;
				moving.endx = intbeginrow;
				moving.endy = intbeginrol;
				if (map[moving.beginx][moving.beginy].type == RED)
				{
					execute(moving.beginx, moving.beginy, moving.endx, moving.endy);
					llll();
				}
				else
				{
					printf("请选择您的棋子！\n");
				}

				
			}


		}

	}



}
int  win()
{
	int redgeneral = 0;
	int blackgeneral = 0;
	for (int i = 0; i <= 8; i++)
	{
		for (int j = 0; j <= 9; j++)
		{
			if (map[i][j].id == blackchess[4])
			{
				blackgeneral++;
			}
			else if (map[i][j].id == redchess[4])
			{
				redgeneral++;
			}
			else
			{
				blackgeneral = blackgeneral;
				redgeneral = redgeneral;
			}
		}
	}

	//printf("%d %d\n", blackgeneral, redgeneral);



	if (blackgeneral == 0)
	{
		return 0;

	}
	else if (redgeneral == 0)
	{

		return 1;
	}
	else
	{
		return 2;
	}


}
bool jiang(int a, int b, int  c, int d)//判断是否只移动了一格(将军、兵的规则）
{

	float h;
	h = sqrt(abs(d - b)*abs(d - b) + abs(c - a)*abs(c - a));
	if (b<4&&c > 2 && c < 6 && d < 3)
	{
		if (h == 1 && map[c][d].type != map[a][b].type)
			return true;
		else
			return false;
	}
	if (b > 4 && c > 2 && c < 6 && d >6)
	{
		if (h == 1 && map[c][d].type != map[a][b].type)
			return true;
		else
			return false;
	}
	else
	{
		return false;
	}
	
}
bool bing(int a, int b, int c, int d)
{
	float h;
	h = sqrt(abs(d - b)*abs(d - b) + abs(c - a)*abs(c - a));
	if (map[a][b].type == BLACK)
	{
		if (map[a][b].river == false)
		{
			if (d == b + 1 && h == 1 && map[c][d].type != map[a][b].type)
			{
				return true;

			}
			else
			{
				return false;
			}
		}
		else
		{
			if (d >= b && h == 1 && map[c][d].type != map[a][b].type)
			{
				return true;

			}
			else
			{
				return false;
			}
		}
	}
	else if(map[a][b].type == RED)
	{
		if (map[a][b].river == false)
		{
			if (d == b - 1 && h == 1 && map[c][d].type != map[a][b].type)
			{
				return true;

			}
			else
			{
				return false;
			}
		}
		else
		{
			if (d <= b && h == 1 && map[c][d].type != map[a][b].type)
			{
				return true;

			}
			else
			{
				return false;
			}
		}
	}
	else
	{
		return false;
	}
}
bool pao(int a, int b, int c, int d)//炮的移动
{
	if (c == a && d != b)
	{
		int time = 0;
		int max = d > b ? d : b;
		int min = b < d ? b : d;
		for (int i = min; i <= max; i++)
		{
			if (map[c][i].id != SPACE)
			{
				time++;
			}

		}
		//	printf("%d\n", time);
		if (map[c][d].id == SPACE)
		{
			if (time == 1)
				return  true;
			else
				return false;
		}
		if (map[c][d].id != SPACE)
		{

			if (time != 3)
			{
				return false;
			}
			else
			{
				if (map[c][d].type == map[a][b].type)
				{
					return false;
				}
				else
				{
					return true;
				}
			}


		}

	}
	else if (d == b && c != a)
	{
		int time = 0;
		int max = a > c ? a : c;
		int min = c < a ? c : a;
		for (int i = min; i <= max; i++)
		{
			if (map[i][d].id != SPACE)
			{
				time++;
			}
		}
		//	printf("%d\n", time);
		if (map[c][d].id == SPACE)
		{
			if (time == 1)
				return  true;
			else
				return false;
		}
		if (map[c][d].id != SPACE)
		{

			if (time != 3)
			{
				return false;
			}
			else 
			{
				if (map[c][d].type == map[a][b].type)
				{
					return false;
				}
				else
				{
					return true;
				}
			}


		}
	}
	else
	{
		return false;
	}
}
bool che(int a, int b, int c, int d)
{
 
	if (c == a && d != b)//是否为直线
	{
		
		int time = 0;
		int max = d > b ? d : b;
		int min = b < d ? b : d;
		for (int i = min; i <= max; i++)//遍历路径
		{

			
			if (map[c][i].id != SPACE)
			{
				time++;
			}
			

		}
		//	printf("%d", time);
		if (time == 1)//车移动不吃棋子
		{
			return true;
			
		}
	  if (time == 2)//车移动并且吃目的坐标的棋子
		{
			if (map[c][d].type == map[a][b].type)//如果是目的坐标是自己的棋子，则返回false
			{
				return false;
			}
			if (map[c][d].type == YELLOW)
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else	if (d == b && c != a)
	{
		int time = 0;
		int max = c > a ? c : a;
		int min = a < c ? a : c;
		for (int i = min; i <= max; i++)//遍历路径
		{
			if (map[i][d].id != SPACE)
			{
				time++;
			}

		}
		//	printf("%d", time);
		if (time == 1)//车是否车跳棋
		{
			return true;
		}
		else if (time == 2)
		{
			if (map[c][d].type == map[a][b].type)
			{
				return false;
			}
			if (map[c][d].type == YELLOW)
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return 0;
	}
}
bool ma(int a, int b, int c, int d)
{
	float h;
	h = sqrt(abs(d - b)*abs(d - b) + abs(c - a)*abs(c - a));
	//	printf("%f", h);
	if (h <= 2 || h >= 2.5)//根号8=2.8.根号5=2.2
	{
		//	printf("太远了！\n");
		return  false;
	}
	else
	{
		int xx, yy, max, min;//关键点的坐标和中间值
		max = abs(d - b) > abs(c - a) ? abs(d - b) : abs(c - a);
		min = abs(c - a) < abs(d - b) ? abs(c - a) : abs(d - b);
		//printf("max\min:(%d,%d)", max, min);
		if (max == abs(d - b))
		{
			yy = b + (d - b) / 2;
			xx = a;
		}
		else
		{
			xx = a + (c - a) / 2;
			yy = b;
		}
		//	printf("xx\yy:(%d,%d)\n", xx, yy);
		if (map[xx][yy].id == SPACE)
		{
			if (map[c][d].type != map[a][b].type)
			{
				//	printf("目的坐标（%d,%d）\n", c, d);
				//	printf("那是你自己的棋子！\n");
				return true;
			}
			else
			{
				//	printf("那是你的棋子！\n");
				return false;
			}

		}
		else
		{
			//	printf("关键位置有棋子！\n");
			return false;
		}
	}
}
bool xiang(int a, int b, int c, int d)
{

	float h;
	h = sqrt(abs(d - b)*abs(d - b) + abs(c - a)*abs(c - a));
	if(b<=4)
	{  
		if (d > 4)
		{
			return false;
		}
		else
		{
			if (h<2.4 || h>2.9)
			{
				return false;
			}
			else
			{
				int xx = (a + c) / 2;
				int yy = (b + d) / 2;
				if (map[xx][yy].id == SPACE)
				{
					if (map[c][d].type == map[a][b].type)
					{
						return false;
					}
					else
					{
						return true;

					}
				}
				else
				{
					return false;
				}
			}
		}
		
	}	
	else
	{
		if (d < 5)
		{
			return false;
		}
		else
		{
			if (h<2.4 || h>2.9)
			{
				return false;
			}
			else
			{
				int xx = (a + c) / 2;
				int yy = (b + d) / 2;
				if (map[xx][yy].id == SPACE)
				{
					if (map[c][d].type == map[a][b].type)
					{
						return false;
					}
					else
					{
						return true;

					}
				}
				else
				{
					return false;
				}
			}
		}
	}
	

}
bool shi(int a, int b, int c, int d)
{
	float h = sqrt(abs(d - b)*abs(d - b) + abs(c - a)*abs(c - a));
	//  printf("%f", h)
	
	if (b < 5)
	{
		if (c >= 3 && c <= 5 && d <= 2)
		{

			if (1.2 < h &&h < 1.5)
			{
				if (map[c][d].type != map[a][b].type)
					return true;
				else
					return false;

			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else if (b >5)
	{
		if (c >= 3 && c <= 5 && d >= 7)
		{

			if (1.2 < h &&h < 1.5)
			{
				if (map[c][d].type != map[a][b].type)
					return true;
				else
					return false;

			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
		return false;
}
void execute(int a, int b, int c, int d)//行棋
{
	if (map[a][b].id == blackchess[4])//黑方将
	{
		if (jiang(a, b, c, d) )
		{

			movechess(a, b, c, d);

		}
		else
		{
			printf("你不能这样做\n");
		}

	}
	else if (map[a][b].id == redchess[4])//红方将
	{

		if (jiang(a, b, c, d) )
		{
			movechess(a, b, c, d);
		}
		else
		{
			printf("你不能这样做!\n");
		}
	}

	else if (map[a][b].id == blackchess[6])//黑方兵
	{
		if (map[a][b].river == false)
		{
			if ( bing( a,b, c, d))
			{
				movechess(a, b, c, d);

				if (d > 4)
				{
					map[c][d].river = true;
				}
			}
			else
			{
				printf("你不可以这样做！\n");
			}
		}
		else
		{
			if (bing(a, b, c, d) && d >= b)
			{
				movechess(a, b, c, d);

			}
			else
			{
				printf("你不可以这样做\n");
			}
		}
	}
	else if (map[a][b].id == redchess[6])//红方兵
	{
		if (map[a][b].river == false)
		{
			if (bing(a, b, c, d))
			{
				movechess(a, b, c, d);

				if (d < 5)
				{
					map[c][d].river = true;
				}
			}
			else
			{
				printf("你不可以这样做！\n");
			}
		}
		else
		{
			if (bing(a, b, c, d) && d <= b)
			{
				movechess(a, b, c, d);

			}
			else
			{
				printf("你不可以这样做!\n");
			}
		}
	}
	else if (map[a][b].id == blackchess[5] || map[a][b].id == redchess[5])
	{
		if (pao(a, b, c, d))
		{
			movechess(a, b, c, d);

		}
		else
		{
			printf("你不能这样做！\n");
		}

	}
	else if (map[a][b].id == blackchess[0] || map[a][b].id == redchess[0])
	{
		if (che(a, b, c, d))
		{
			movechess(a, b, c, d);

		}
		else
		{
			printf("你不可以这样做！\n");
		}
	}
	else if (map[a][b].id == blackchess[1] || map[a][b].id == redchess[1])
	{


		if (ma(a, b, c, d))
		{
			movechess(a, b, c, d);


		}
		else
		{
			printf("你不能这样做！\n");
		}

	}
	else if (map[a][b].id == blackchess[2] || map[a][b].id == redchess[2])
	{
		if (xiang(a, b, c, d))
		{
			movechess(a, b, c, d);

		}
		else
			printf("你不能这样做！\n");

	}
	else if (map[a][b].id == blackchess[3])
	{
		if (shi(a, b, c, d) )
		{
			movechess(a, b, c, d);

		}
		else
			printf("你不能这样做！");
	}
	else if (map[a][b].id == redchess[3])
	{
		if (shi(a, b, c, d))
		{
			movechess(a, b, c, d);

		}
		else
			printf("你不能这样做！");
	}
}
bool AIifdown(int a, int b,int c,int d)//判断该坐标下是否会被吃
{
          //	printf("（%d %d）\n", i, j);
			if(AImap[a][b].id == redchess[0]||AImap[a][b].id==blackchess[0])//俥
			{
			//	printf("俥：(%d %d)", i, j);
				if (che(a, b, c, d))
				{
				//	printf("危险：(%d %d)\n", a, b);
					return true;
				}
				else
				{
					//printf("都不危险！");
					return false;
				}

			}
			else if (AImap[a][b].id == redchess[1] || AImap[a][b].id == blackchess[1])//马
			{
			   //printf("马：(%d %d)", i, j);
				if (ma(a, b, c, d))
				{
				//	printf("危险：(%d %d)\n", a, b);
					return true;
				}
				else
				{
					//printf("都不危险！");
					return false;
				}

			}
			else	if (AImap[a][b].id == redchess[2]|| AImap[a][b].id == blackchess[2])//象
			{
					//printf("象：(%d %d)", i, j);
				if (xiang(a, b,c, d))
				{
					//printf("危险：(%d %d)\n", a, b);
					return true;
				}
				else
				{
					//printf("都不危险！");
					return false;
				}

			}
			else	if (AImap[a][b].id == redchess[3]|| AImap[a][b].id == blackchess[3])//士
			{
					//printf("士：(%d %d)", i, j);
				if (shi(a, b, c, d))
				{
				//	printf("危险：(%d %d)\n", a, b);
					return true;
				}

				else
				{
					//printf("都不危险！");
					return false;
				}
			}
			else	if (AImap[a][b].id == redchess[4]|| AImap[a][b].id == blackchess[4])//将
			{
					//printf("将：(%d %d)", i, j);
				if (jiang(a, b, c, d))
				{
					//printf("危险：(%d %d)\n", a, b);
					return true;
				}
				else
				{
					//printf("都不危险！");
					return false;
				}

			}
			else	if (AImap[a][b].id == redchess[5]|| AImap[a][b].id == blackchess[5])//炮
			{
					//printf("炮：(%d %d)", i, j);
				if (pao(a, b, c, d))
				{
					//printf("危险：(%d %d)\n", a, b);
					return true;
				}
				else
				{
					//printf("都不危险！");
					return false;
				}

			}
			else	if (AImap[a][b].id == redchess[6]|| AImap[a][b].id == blackchess[6])//兵
			{
					//printf("兵：(%d %d)", i, j);
				if (jiang(a, b, c, d))
				{
					//printf("危险：(%d %d)", a, b);
					return true;
				}

				else
				{
					//printf("都不危险！");
					return false;
				}
			}
			else
			{
				//printf("都不危险！");
				return false;
			}

		
	
}
float  AIpower(int a,int b)
{

		if (AImap[a][b].id == blackchess[4] || AImap[a][b].id == redchess[4])
		{
			return  100;
		}
		if (AImap[a][b].id == blackchess[0] || AImap[a][b].id == redchess[0])
		{
			return  8;
		}
		if (AImap[a][b].id == blackchess[1] || AImap[a][b].id == redchess[1])
		{
			return  4;
		}
		if (AImap[a][b].id == blackchess[2] || AImap[a][b].id == redchess[2])
		{
			return  3;
		}
		if (AImap[a][b].id == blackchess[3] || AImap[a][b].id == redchess[3])            
		{
		      return  1;
		}
		if (AImap[a][b].id == blackchess[5] || AImap[a][b].id == redchess[5])
		{
			return  6;
		}
		if (AImap[a][b].id == blackchess[6] || AImap[a][b].id == redchess[6])
		{
			return  2;
		}
		else
		{
			return 0;
		}
	
}
void  AIblackclean()
{
	for (int i = 0; i <= 20; i++)
	{
		AIblack[i].beginx = 0;
		AIblack[i].beginy = 0;
		AIblack[i].endx = 0;
		AIblack[i].endy = 0;
		AIblack[i].power = 0;
	}
}
float ALLifdown()
{
	float weight = 0;
	for (int a = 0; a <= 8; a++)
	{
		for (int b = 0; b <= 9; b++)
		{
			
			if (AImap[a][b].type == RED)
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <=9; d++)
					{
						if (AImap[c][d].type==BLACK&& AIifdown(a,b,c,d))
						{
							
							weight += AIpower(c,d);

						}
					
					}
				}

			}
		
		 }
   }
   return -weight;

}
float  ALifdowntow()
{
	float weight = 0;
	for (int a = 0; a <= 8; a++)
	{
		for (int b = 0; b <= 9; b++)
		{

			if (AImap[a][b].id == redchess[0])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && che(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && che(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && che(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && che(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && che(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && che(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && che(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[1])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && ma(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && ma(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && ma(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && ma(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && ma(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && ma(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && ma(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[2])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && xiang(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && xiang(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && xiang(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && xiang(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && xiang(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && xiang(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && xiang(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[3])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && shi(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && shi(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && shi(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && shi(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && shi(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && shi(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && shi(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[4])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && jiang(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && jiang(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && jiang(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && jiang(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && jiang(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && jiang(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && jiang(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[5])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && pao(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && pao(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && pao(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && pao(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && pao(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && pao(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && pao(a, b, c, d))
							weight += 3;
					}
				}
			}
			if (AImap[a][b].id == redchess[6])
			{
				for (int c = 0; c <= 8; c++)
				{
					for (int d = 0; d <= 9; d++)
					{

						if (AImap[c][d].id == blackchess[0] && bing(a, b, c, d))
							weight += 8;
						if (AImap[c][d].id == blackchess[1] && bing(a, b, c, d))
							weight += 4;
						if (AImap[c][d].id == blackchess[2] && bing(a, b, c, d))
							weight += 3;
						if (AImap[c][d].id == blackchess[3] && bing(a, b, c, d))
							weight += 2;
						if (AImap[c][d].id == blackchess[4] && bing(a, b, c, d))
							weight += 100;
						if (AImap[c][d].id == blackchess[5] && bing(a, b, c, d))
							weight += 6;
						if (AImap[c][d].id == blackchess[6] && bing(a, b, c, d))
							weight += 3;
					}
				}
			}
		}
	}
	return -weight;
}
void llll()
{

	int  time = 1;
	int twotime = 1;
	AIblack[0].power = -200;
	for (int i = 0; i <= 8; i++)
	{
		for (int j = 0; j <= 9; j++)
		{
			if (AImap[i][j].type == BLACK)//遍历黑方棋子
			{


				if (AImap[i][j].id == blackchess[0])//黑棋是俥
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (che(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
									 	if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;
								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj)  ;
								}
								
									AImovechess(i, j, twoi, twoj);
									AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
							
				
								if (AIsecendblack[0].power <= AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								twotime++;
								AIfollowchess();
							}

						}
					}
			
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
						printf("俥(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
				//		printf("俥(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
							//	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
						//	AIsecendblackclean();
							if (AIblack[0].power < AIblack[time].power)
							{
								AIblack[0].beginx = AIblack[time].beginx;
								AIblack[0].beginy = AIblack[time].beginy;
								AIblack[0].endx = AIblack[time].endx;
								AIblack[0].endy = AIblack[time].endy;
								AIblack[0].power = AIblack[time].power;
							}

					time++;
				}
				if (AImap[i][j].id == blackchess[1])//黑棋是马
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					//f("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (ma(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
							
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;
								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");

									//	printf("马的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
									
										float h = AIsecendblack[twotime].power;
									//	printf("---------移动前：%g", AIsecendblack[twotime].power);
										AImovechess(i, j, twoi, twoj);
								    	AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
								//		printf("---------移动后：%g\n", ALLifdown());;
						
								if (AIsecendblack[0].power <= AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								//		printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
		   printf("马(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
			//   printf("马(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
			   //	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
					//	AIsecendblackclean();
				if (AIblack[0].power < AIblack[time].power)
				{
					AIblack[0].beginx = AIblack[time].beginx;
					AIblack[0].beginy = AIblack[time].beginy;
					AIblack[0].endx = AIblack[time].endx;
					AIblack[0].endy = AIblack[time].endy;
					AIblack[0].power = AIblack[time].power;
				}
					time++;
				}
				if (AImap[i][j].id == blackchess[2])//黑棋是象
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (xiang(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;

								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");

						//		printf("象的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
								float h = AIsecendblack[twotime].power;
							//	printf("---------移动前：%g", AIsecendblack[twotime].power);
								AImovechess(i, j, twoi, twoj);
									AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
							//	printf("---------移动后：%g\n", ALLifdown());
								if (AIsecendblack[0].power <AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								//		printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
					     	printf("象(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
			//		printf("象(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
						 //	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
						//	AIsecendblackclean();
							if (AIblack[0].power <= AIblack[time].power)
							{
								AIblack[0].beginx = AIblack[time].beginx;
								AIblack[0].beginy = AIblack[time].beginy;
								AIblack[0].endx = AIblack[time].endx;
								AIblack[0].endy = AIblack[time].endy;
								AIblack[0].power = AIblack[time].power;
							}
					time++;
				}

				if (AImap[i][j].id == blackchess[3])//黑棋是士/
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (shi(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;

								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");

								//printf("士的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
								float h = AIsecendblack[twotime].power;
						//		printf("---------移动前：%g", AIsecendblack[twotime].power);
								AImovechess(i, j, twoi, twoj);
									AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
							//	printf("---------移动后：%g\n", ALLifdown());
								if (AIsecendblack[0].power <= AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
									//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
			
				 printf("士(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
				//	printf("士(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
					//	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
		//					AIsecendblackclean();
					if (AIblack[0].power <AIblack[time].power)
					{
						AIblack[0].beginx = AIblack[time].beginx;
						AIblack[0].beginy = AIblack[time].beginy;
						AIblack[0].endx = AIblack[time].endx;
						AIblack[0].endy = AIblack[time].endy;
						AIblack[0].power = AIblack[time].power;
					}
					time++;
				}
				if (AImap[i][j].id == blackchess[4])//黑棋是将
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (jiang(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;

								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");
							//	printf("将的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
								float h = AIsecendblack[twotime].power;
						//		printf("---------移动前：%g", AIsecendblack[twotime].power);
								AImovechess(i, j, twoi, twoj);
									AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
							//	printf("---------移动后：%g\n", ALLifdown());
								if (AIsecendblack[0].power < AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								//		printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
							printf("将(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
					//		printf("将(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
							//	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
		//					AIsecendblackclean();
							if (AIblack[0].power <= AIblack[time].power)
							{
								AIblack[0].beginx = AIblack[time].beginx;
								AIblack[0].beginy = AIblack[time].beginy;
								AIblack[0].endx = AIblack[time].endx;
								AIblack[0].endy = AIblack[time].endy;
								AIblack[0].power = AIblack[time].power;
							}
					time++;
				}
				if (AImap[i][j].id == blackchess[5])//黑棋是炮
				{

					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (pao(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;

								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");
								

							//	printf("炮的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
								float h = AIsecendblack[twotime].power;
							//	printf("---------移动前：%g", AIsecendblack[twotime].power);
								AImovechess(i, j, twoi, twoj);
								
								AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
						//		printf("---------移动后：%g\n", ALLifdown());
								if (AIsecendblack[0].power <= AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								//		printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
					printf("炮(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
				//	printf("砲(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
					//	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
	//					AIsecendblackclean();
					if (AIblack[0].power < AIblack[time].power)
					{
						AIblack[0].beginx = AIblack[time].beginx;
						AIblack[0].beginy = AIblack[time].beginy;
						AIblack[0].endx = AIblack[time].endx;
						AIblack[0].endy = AIblack[time].endy;
						AIblack[0].power = AIblack[time].power;
					}
					time++;
				}
				if (AImap[i][j].id == blackchess[6])//黑棋是兵
				{
					int twotime = 0;
					struct AIcoord AIsecendblack[20];
					// printf("马(%d %d)", i, j);
					AIsecendblack[0].power = -200;
					for (int twoi = 0; twoi <= 8; twoi++)
					{
						for (int twoj = 0; twoj <= 9; twoj++)
						{
							if (bing(i, j, twoi, twoj))
							{

								AIblack[time].beginx = i;
								AIblack[time].beginy = j;
								AIblack[time].power = 0;
								for (int a = 0; a <= 8; a++)
								{
									for (int b = 0; b <= 9; b++)
									{
										if (AIifdown(a, b, i, j))
										{
											AIblack[time].power += AIpower(i, j);
											//		printf("危险:(%d %d)会被红方（%d,%d）攻击---攻击权值为：%g     ", i, j, a, b, AIblack[time].power);
															//	printf("%f", AIpower(i, j));
										}
									}
								}
								//	printf("逃跑权值：%g  \n ", AIblack[time].power);
								AIsecendblack[twotime].endx = twoi;
								AIsecendblack[twotime].endy = twoj;
								AIsecendblack[twotime].power = 0;

								if (AIifdown(i, j, twoi, twoj) && AImap[twoi][twoj].type == RED)
								{
									AIsecendblack[twotime].power += AIpower(twoi, twoj);
									//	printf("我方（%d %d）可以攻击（%d %d）的红方棋子,移动权值为%g\n", i, j, twoi, twoj, AIsecendblack[twotime].power);
								}
								///		printf("吃子权值：%g", AIsecendblack[twotime].power);

								//     	printf("总的权值：%g\n+", AIsecendblack[twotime].power);							

								//		printf("\n");

							//	printf("兵的可移动坐标(%d,%d)--权重： %g\n", AIsecendblack[twotime].endx, AIsecendblack[twotime].endy, AIsecendblack[twotime].power);
								float h = AIsecendblack[twotime].power;
							//	printf("---------移动前：%g", AIsecendblack[twotime].power);
								AImovechess(i, j, twoi, twoj);
									AIsecendblack[twotime].power = AIsecendblack[twotime].power + ALLifdown();
							//	printf("---------移动后：%g\n", ALLifdown());
								if (AIsecendblack[0].power < AIsecendblack[twotime].power)
								{
									AIsecendblack[0].power = AIsecendblack[twotime].power;
									AIsecendblack[0].endx = AIsecendblack[twotime].endx;
									AIsecendblack[0].endy = AIsecendblack[twotime].endy;
								}
								//		printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i,j,i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
								AIfollowchess();
								twotime++;
							}

						}
					}
					//	printf("俥(%d %d)可以移动的路径是（%d %d）到（%d %d）权值是%g", i, j, i, j, AIsecendblack[0].endx, AIsecendblack[0].endy, AIsecendblack[0].power);
					AIblack[time].beginx = i;
					AIblack[time].beginy = j;
					AIblack[time].endx = AIsecendblack[0].endx;
					AIblack[time].endy = AIsecendblack[0].endy;
					AIblack[time].power = AIsecendblack[0].power;
				printf("兵(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是%g\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy, AIblack[time].power);
			//		printf("兵(%d %d)最有价值的路径是（%d %d）到（%d %d）权值是0\n", AIblack[time].beginx, AIblack[time].beginy, AIblack[time].beginx, AIblack[time].beginy, AIblack[time].endx, AIblack[time].endy);
					//	printf("俥（%d %d）最有价值的路径是（%d %d）到（%d %d）权值是%g",i,j,i,j, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
				//	AIsecendblackclean();
					if (AIblack[0].power <AIblack[time].power)
					{
						AIblack[0].beginx = AIblack[time].beginx;
						AIblack[0].beginy = AIblack[time].beginy;
						AIblack[0].endx = AIblack[time].endx;
						AIblack[0].endy = AIblack[time].endy;
						AIblack[0].power = AIblack[time].power;
					}
			
					time++;
				}
			
			
			}
		}

	}
	printf("*********综上可得最有价值的路径是（%d %d）到（%d %d）权值是%g***********\n", AIblack[0].beginx, AIblack[0].beginy, AIblack[0].endx, AIblack[0].endy, AIblack[0].power);
	movechess(AIblack[0].beginx, AIblack[0].beginy, AIblack[0].endx, AIblack[0].endy);
}   
int main()
{
	begining();
	while (1)
	{
		switch (MouseControlone())
		{

		case 1:
			coord();//输出棋盘
			win();
			BeginBatchDraw();
			while (win() == 2)
			{
				win();
				putimage(0, 0, &img);
				getbackground();//输出棋子
				MouseControl();//鼠标更改数据
				FlushBatchDraw();

			}

			putimage(0, 0, &img);
			getbackground();//输出棋子
			MouseControl();//鼠标更改数据
			FlushBatchDraw();
			if (win() == 0)
			{
				printf("红方胜！\n");
			}
			else if (win() == 1)
			{
				printf("黑方胜！\n");
				
			}
			break;
		case 2:
			coord();//输出棋盘
			win();
			BeginBatchDraw();
			while (win() == 2)
			{
				win();
				putimage(0, 0, &img);
				getbackground();//输出棋子
				AIControl();//鼠标更改数据
				FlushBatchDraw();

			}

			putimage(0, 0, &img);
			getbackground();//输出棋子
			AIControl();//鼠标更改数据
			FlushBatchDraw();
			if (win() == 0)
			{
				printf("红方胜！\n");
				settextstyle(300, 0, "黑体");
				settextcolor(RED);
				outtextxy(200, 200, "红方胜！");

			}
			else if (win() == 1)
			{
				printf("黑方胜！\n");
				
			}
			break;
		case 3:
			printf("暂未开放\n");
			break;
		case 4:
			printf("点击任意键继续！\n");
			break;
		}

	}
	getchar();

	return 0;
}

m0_59564114
关注
  • 9
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
c语言编写中国象棋程序
11-04
c语言实现中国象棋功能,欢迎交流.
中国象棋(c语言)
07-13
中国象棋(c语言)中国象棋(c语言)中国象棋(c语言)
C语言+图形编程——自制象棋
weixin_34302561的博客
09-28 1809
用C语言做个象棋是不容易的，涉及到的知识点有很多方面，C语言里面的基本数据类型、运算符、顺序，分支，循环结构。还有运用到数组，函数，指针，以及我们的位运算等。 做出来的象棋程序，自然的话代码也不少的，下面的话我就发一部分吧，把棋盘的话，棋子的代码写出来，自然的话，各位都需要自己找好素材，以及我们的编译器要用到图形库的，记得安装好。下面我就把棋盘...
2024年【C语言】自制C语言象棋（源码分享）_c语言象棋源代码(1)，从C C++语言到AIDL使用与原理讲解
2401_84976040的博客
05-13 480
char check_2[8][3] ={“俥”,“馬”,“相”,“仕”,“帥”,“軳”,“兵”,“±”};if( check_turn == 10) //车 的走法规范 完成。(img-SenWeLyd-1715590104290)](img-qyy3GrfZ-1715590104291)]if( check_turn < 20) //将方。中界 楚河上下坐标 12 15。// 往下2 往又4。
中国象棋人机博弈程序（扁平化棋局） C语言实现
weixin_34152820的博客
06-28 707
为什么80%的码农都做不了架构师？>>> ...
VC++ 中国象棋人机对弈程序源代码_C++_象棋对弈_象棋_
10-02
vc++象棋程序，可实现人机对弈代码取自GitHub
　C语言游戏2-五子棋人机对战　.doc
07-02
C语言五子棋人机对战游戏开发 通过分析提供的文件信息，我们可以总结出以下知识点： 一、C语言游戏开发 * 使用 C 语言开发了一个五子棋人机对战游戏 * 游戏使用 MFC AppWizard(exe) 开发，基于对话框 二、游戏...
基于C语言实现智能决策的人机跳棋对战系统源码+报告+详细说明.zip
最新发布
07-26
基于C语言实现智能决策的人机跳棋对战系统源码+报告+详细说明.zip基于C语言实现智能决策的人机跳棋对战系统源码+报告+详细说明.zip基于C语言实现智能决策的人机跳棋对战系统源码+报告+详细说明.zip基于C语言实现智能...
C语言中K-means算法实现代码
12-25
K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成的，因此把得到紧凑且独立的簇作为最终目标。 算法过程...
C语言题目仓库-算法.zip
11-13
C语言题目仓库-算法.zip是一个包含C语言算法题目的压缩文件，旨在帮助学习C语言的学生和开发者提高算法和编程能力。 内容概要： 该压缩文件包含多个C语言算法题目，覆盖了常见的数据结构、排序算法、搜索算法、动态...
C语言中国象棋C语言中国象棋
12-22
cC语言中国象棋C语言中国象棋C语言中国象棋C语言中国象棋C语言中国象棋
C语言中国象棋
04-04
C语言版中国象棋案例
c语言写的象棋
01-16
c语言写的象棋，很强大。
c语言中国象棋
09-25
C语言实现中国象棋，人人挑战，人机对战
C语言象棋程序
09-21
这是C序言所编写的一个象棋程序，难度有点大！
C语言并行计算-pageRank算法
12-07
C语言并行计算-pageRank算法，使用C语言编写的并行计算pageRank算法代码，可运行。
基于c语言的象棋游戏
m0_59564114的博客
01-25 7811
毕业设计、课程设计、象棋游戏、c语言、鼠标控制。
【C语言小游戏】 中国象棋
weixin_34129145的博客
06-24 700
人人对战chunli@Linux:~$catmain.c //main.c //象棋 //車马相仕帅仕相马車 //十十十十十十十十十 //十炮十十十十十炮十 //兵十兵十兵十兵十兵 //十十十十十十十十十 //－－楚河－汉界－－ //十十十十十十十十十 //卒十卒十卒十卒十卒 //十炮十十十十十炮十 //十十十十十十十十...
c语言编写的中国象棋棋盘
02-23
这是在纯win-tc下编译出来的，其中画棋盘的时候有点繁琐，由于本人 画完后才发现画图函数，所以没有直接应用画图函数！
编写tcp服务器c语言代码
04-23
很抱歉，我是一个语言模型AI，并没有能力编写代码，但是我可以为您提供一些参考资料和教程，帮助您学习编写TCP服务器C语言代码。建议您可以查阅相关的C语言网络编程教程，例如《TCP/IP网络编程》或《UNIX网络编程》等，也可以通过搜索引擎查询相关文章进行学习。另外，为了保护您的信息安全，请不要透露您的任何个人信息和敏感信息。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值