第一次发博客，用C++写一个下五子棋的小AI

最新推荐文章于 2024-02-12 22:17:02 发布
最新推荐文章于 2024-02-12 22:17:02 发布
阅读量525 收藏 1
点赞数
文章标签： C++ 新人
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37225313/article/details/83831398
版权

第一次发博客，用C++写一个下五子棋的小AI

刚学C++一两年，试着写了一个下五子棋的小AI，核心的代码放在了gamemode.h和gamemode.cpp里面。毕竟本人是新手，所以做的比较粗糙，还望各位包涵（嘿嘿）。
1、其实调用这个AI的方式很简单，就是将棋盘状态保存在int Pad[15][15]这个数组里面（0表示该出没有棋子，1表示该处有白棋，-1表示该处有黑棋），然后如果调用void CulResult()这个函数，它就会根据棋盘上现在的状态计算出下一步的下棋位置（不管白棋还是黑棋都一样），并将这个位置储存在ivalue、jvalue这两个变量里（ivalue、jvalue分别表示行和列的坐标值，取值是1-15）。
2、在棋盘上下子的时候，可以调用bool CheckAndSet(CPoint point,bool type)这个函数，point表示下棋的位置，type表示下棋的种类。 这个函数会将type与turn做比较，检查是否轮到正确的下棋方下棋，如果下棋方正确则下棋并且返回true，下期方错误则会返回false。这个CPoint是引用的一个头文件里的，如果你没有的话请自己加一个这个类，只需要两个整型变量x、y就行了。然后调用完bool CheckAndSet(CPoint point,bool type)之后如果下棋成功了，建议调用一下bool ChangeTurn()，改变现在下一步的下棋方。另一种在棋盘上下棋的方式就是直接改int pad[15][15]数组的值，我觉得为了方便调试就把它设置为public了。
3、每下完一步棋都可以调用int checkwin()来检查现在是否有一方获胜了，如果白子赢了返回1，黑子赢了返回-1。
4、在声明一个gamemode类型的变量时，构造函数里的bool参数是指定玩家棋子的种类。在定义完gamemode变量以后要设置一下turn的值，也就是谁最先下棋。

最后说一下，我觉得我这个黑子、白子的次序和玩家、电脑的次序弄的有点乱，可能并不合理，但是改起来又有点麻烦，如果大家有建议欢迎提出。我会在之后上传一个我写好的工程，在我的资源里，可以直接用vs2012打开运行。但是在运行的时候先全屏，不然棋盘显示不全，
gamemode.h:

#include "math.h"
#include "stdafx.h"

struct TRNA		//定义链表的结构体
{
	int type;
	int i;
	int j;
	TRNA *before;
	TRNA *next;
};

struct check
{
	int type;
	int value;
};

class gamemode		//定义五子棋的类
{
public:
	int pad[15][15];		//储存棋盘当前的状态
	bool turn;      //true表示轮到白子，false表示轮到黑子。
	bool player;    //player表示玩家的子类型，true表示白子，false表示黑子。
	int ivalue;		//储存每一轮计算机计算的最终结果在数组中的行值
	int jvalue;		//储存每一轮计算机计算的最终结果在数组中的列值
	float tend;		//算法的下棋倾向，0-1表示偏向防守，1-2表示偏向攻击,1表示均衡

public:
	gamemode(bool player);		//参数player是初始化玩家的棋子类型,ture表示白子，false表示黑子
	bool CheckAndSet(CPoint point,bool type);	//检查棋子并下子
	bool ChangeTurn();			//获取当前下棋方，并在获取后自动切换下棋方
	void CulResult();		//调用4*2次SingleCul，获取所有扫描结果并相加
	int checkwin();		//检查是否有一方获取了胜利,1表示玩家获胜，-1表示电脑获胜，0表示没有人获胜


private:
	int location[15][15];
	int longitude[15][15];		//存储纵向扫描白子优先度结果
	int latitude[15][15];		//存储横向扫描白子优先度结果
	int LtoR[15][15];		//存储左上到右下扫白子描优先度结果
	int RtoL[15][15];		//存储右上到左下扫白子描优先度结果
	int longitude2[15][15];		//存储纵向扫描黑子优先度结果
	int latitude2[15][15];		//存储横向扫描黑子优先度结果
	int LtoR2[15][15];		//存储左上到右下扫黑子描优先度结果
	int RtoL2[15][15];		//存储右上到左下扫黑子描优先度结果
	float result1[15][15];		//存储白子最终扫描结果
	float result2[15][15];		//存储黑子最终扫描结果

	void SingleCul(TRNA* linktable,int target[15][15]);		//输入扫描结果的链表以及存储的数组，进行单次的扫描
	void initialize();		//初始化存储扫描存储空间的函数
	TRNA* getlon();		//获取纵向扫描结果
	TRNA* getla();		//获取横向扫描结果
	TRNA* getLtoR();		//获取左上到右下扫描结果
	TRNA* getRtoL();		//获取右上到左下扫描结果

};

gamemode.cpp:

#include "stdafx.h"
#include "gamemode.h"

struct recorder
{
	int i,j,type;
};

void release(TRNA* target)		//释放链表
{
	target = target->next;
	for (; target->next != NULL; target = target->next)
	{
		delete target->before;
	}
	delete target;
}

/*
check _3a[3]={{0,10},{1,0},{0,10}};
check _5a[5]={{1,0},{0,30},{0,30},{1,0},{0,0}};
check _5b[5]={{1,0},{1,0},{0,60},{1,0},{1,0}};
check _5c[5]={{1,0},{1,0},{1,0},{0,60},{1,0}};
check _5d[5]={{0,0},{1,0},{0,30},{1,0},{0,0}};
check _6a[6]={{0,0},{0,15},{0,15},{1,0},{1,0},{-1,0}};
check _6b[6]={{0,30},{1,0},{0,30},{1,0},{0,0},{-1,0}};
check _6c[6]={{0,0},{0,30},{1,0},{1,0},{0,30},{0,0}};
check _6d[6]={{0,30},{0,30},{1,0},{1,0},{1,0},{-1,0}};
check _6e[6]={{0,30},{1,0},{1,0},{0,60},{1,0},{0,30}};
check _6f[6]={{0,30},{1,0},{1,0},{0,30},{1,0},{-1,0}};
check _6g[6]={{0,30},{1,0},{0,30},{1,0},{1,0},{-1,0}};
check _6h[6]={{0,60},{1,0},{1,0},{1,0},{1,0},{-1,0}};
check -6i[6]={{0,0},{0,30},{0,30},{1,0},{1,0},{0,0}};
check _7a[7]={{0,0},{0,30},{1,0},{1,0},{0,30},{0,30},{0,0}};
check _7b[7]={{0,0},{0,30},{1,0},{0,30},{1,0},{0,30},{0,0}};
check _7c[7]={{-1,0},{0,0},{1,0},{1,0},{0,30},{0,30},{0,0}};
check _7d[7]={{0,30},{0,60},{1,0},{1,0},{1,0},{0,60},{0,30}};
check _7e[7]={{0,30},{0,60},{1,0},{1,0},{1,0},{0,30},{-1,0}};
check _7f[7]={{-1,0},{0,30},{1,0},{1,0},{1,0},{0,30},{-1,0}};
*/

check _3group[3] = {{0,5},{1,0},{0,5}};
check _5group[5][5] = {{{1,0},{0,30},{0,30},{1,0},{0,0}}  ,{{1,0},{1,0},{0,100},{1,0},{1,0}}  ,{{1,0},{1,0},{1,0},{0,100},{1,0}} ,{{0,0},{1,0},{0,30},{1,0},{0,0}},{{0,100},{1,0},{1,0},{1,0},{1,0}}};
check _6group[10][6] = {{{0,0},{0,15},{0,15},{1,0},{1,0},{-1,0}} ,{{0,30},{1,0},{0,30},{1,0},{0,0},{-1,0}}  ,{{0,0},{0,30},{1,0},{1,0},{0,30},{0,0}}  ,{{0,37},{0,37},{1,0},{1,0},{1,0},{-1,0}},
{{0,37},{1,0},{1,0},{0,67},{1,0},{0,37}}  ,{{0,37},{1,0},{1,0},{0,37},{1,0},{-1,0}}  ,{{0,30},{1,0},{1,0},{0,30},{1,0},{-1,0}}  ,{{0,100},{1,0},{1,0},{1,0},{1,0},{-1,0} },{{0,0},{0,30},{0,30},{1,0},{1,0},{0,0}},
{{0,37},{0,67},{1,0},{1,0},{1,0},{0,37}}};
check _7group[6][7] = {{{0,0},{0,30},{1,0},{1,0},{0,30},{0,30},{0,0}} ,{{0,0},{0,30},{1,0},{0,30},{1,0},{0,30},{0,0}}  ,{{-1,0},{0,0},{1,0},{1,0},{0,30},{0,30},{0,0}}  ,
{{0,37},{0,67},{1,0},{1,0},{1,0},{0,67},{0,37}}  ,{{0,37},{0,67},{1,0},{1,0},{1,0},{0,37},{-1,0}} ,{{-1,0},{0,37},{1,0},{1,0},{1,0},{0,37},{-1,0}}};

check WinCon[5]={{1,0},{1,0},{1,0},{1,0},{1,0}};


gamemode::gamemode(bool play) :player(play)
{
	int i, j;
	tend=1;
	int a=0,b=0,max=0;
	for (i = 0; i<15; i++)
		for (j = 0; j<15; j++)
		{
			pad[i][j] = 0;
			longitude[i][j] = 0;
			latitude[i][j] = 0;
			LtoR[i][j] = 0;
			RtoL[i][j] = 0;
			result1[i][j] = 0;
			result1[i][j] = 0;
		}
	for(i=0;i<14;i++)
		for(j=0;j<14;j++)
		{
			a=i-7;
			b=j-7;
			a=a<0?-a:a;
			b=b<0?-b:b;
			max=a>b?a:b;
			location[i][j]=7-max;
		}
}


bool gamemode::CheckAndSet(CPoint point, bool type)
{
	int x, y;
	x=point.x;
	y=point.y;
	if (gamemode::pad[y - 1][x - 1] == 0)
	{
		if(type==player)
		{
			pad[y - 1][x - 1] = 1;
			return true;
		}
		else if(type!=player)
		{
			pad[y - 1][x - 1] = -1;
			return true;
		}
	}
	else
	{
		return false;
	}
}

bool gamemode::ChangeTurn()
{
	turn = !turn;
	return !turn;
}

void gamemode::initialize()
{
	int i, j;
	for (i = 0; i<15; i++)
		for (j = 0; j<15; j++)
		{
			longitude[i][j] = 0;
			latitude[i][j] = 0;
			LtoR[i][j] = 0;
			RtoL[i][j] = 0;
			longitude2[i][j] = 0;
			latitude2[i][j] = 0;
			LtoR2[i][j] = 0;
			RtoL2[i][j] = 0;
			result1[i][j] = 0;
			result2[i][j] = 0;
		}
}

TRNA* gamemode::getlon()
{
	int i, j;
	TRNA* start = new(TRNA);
	start->before = NULL;
	TRNA* p = start;
	for (j = 0; j<15; j++)
	{
		for (i = 0; i<15; i++)
		{
			p->type = pad[i][j];
			p->i = i;
			p->j = j;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	return start;
}

TRNA* gamemode::getla()
{
	int i, j;
	TRNA* start = new(TRNA);
	start->before = NULL;
	TRNA* p = start;
	for (i = 0; i<15; i++)
	{
		for (j = 0; j<15; j++)
		{
			p->type = pad[i][j];
			p->i = i;
			p->j = j;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	return start;
}

TRNA* gamemode::getLtoR()
{
	int i, j;
	TRNA* start = new(TRNA);
	start->before = NULL;
	TRNA* p = start;
	for (j = 0; j<11; j++)
	{
		int k = j;
		for (i = 0; k<15; i++, k++)
		{
			p->type = pad[i][k];
			p->i = i;
			p->j = k;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	for (i = 1; i<11; i++)
	{
		int k = i;
		for (j = 0; k<15; j++, k++)
		{
			p->type = pad[k][j];
			p->i = k;
			p->j = j;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	return start;
}

TRNA* gamemode::getRtoL()
{
	int i, j;
	TRNA* start = new(TRNA);
	start->before = NULL;
	TRNA* p = start;
	for (j = 14; j >= 4; j--)
	{
		int k = j;
		for (i = 0; k >= 0; i++, k--)
		{
			p->type = pad[i][k];
			p->i = i;
			p->j = k;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	for (i = 1; i<11; i++)
	{
		int k = i;
		for (j = 14; k<15; j--, k++)
		{
			p->type = pad[k][j];
			p->i = k;
			p->j = j;
			p->next = new(TRNA);
			p->next->before = p;
			p = p->next;
			p->next = NULL;
		}
		p->type = -2;
		p->next = new(TRNA);
		p->next->before = p;
		p = p->next;
		p->next = NULL;
	}
	return start;
}

void gamemode::SingleCul(TRNA* linktable, int target[15][15])
{
	TRNA *start, *end, *allend;
	int i, j;
	for (start = linktable, end = start->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<3; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == _3group[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
		{
			for (temp = start, i = 0; temp != end; temp = temp->next, i++)
			{
				if (_3group[i].value>target[temp->i][temp->j])
				{
					target[temp->i][temp->j] = _3group[i].value;
				}
			}
		}
	}
	for (i = 0; i<5; i++)
	{
		for (start = linktable, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<5; j++, temp = temp->next)
			{
				flag = false;
				if (temp->type == _5group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->next, j++)
				{
					if (_5group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _5group[i][j].value;
					}
				}
			}
		}
	}
	allend = end->before->before;
	for (i = 0; i<5; i++)
	{
		for (start = allend, end = start->before->before->before->before->before; end->before != NULL; start = start->before, end = end->before)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<5; j++, temp = temp->before)
			{
				flag = false;
				if (temp->type == _5group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->before, j++)
				{
					if (_5group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _5group[i][j].value;
					}
				}
			}
		}
	}
	for (i = 0; i<10; i++)
	{
		for (start = linktable, end = start->next->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<6; j++, temp = temp->next)
			{
				flag = false;
				if (temp->type == _6group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->next, j++)
				{
					if (_6group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _6group[i][j].value;
					}
				}
			}
		}
	}
	for (i = 0; i<10; i++)
	{
		for (start = allend, end = start->before->before->before->before->before; end->before != NULL; start = start->before, end = end->before)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<6; j++, temp = temp->before)
			{
				flag = false;
				if (temp->type == _6group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->before, j++)
				{
					if (_6group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _6group[i][j].value;
					}
				}
			}
		}
	}
	for (i = 0; i<6; i++)
	{
		for (start = linktable, end = start->next->next->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<7; j++, temp = temp->next)
			{
				flag = false;
				if (temp->type == _7group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->next, j++)
				{
					if (_7group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _7group[i][j].value;
					}
				}
			}
		}
	}
	for (i = 0; i<6; i++)
	{
		for (start = allend, end = start->before->before->before->before->before; end->before != NULL; start = start->before, end = end->before)
		{
			TRNA* temp;
			bool flag;
			for (j = 0, temp = start; j<7; j++, temp = temp->before)
			{
				flag = false;
				if (temp->type == _7group[i][j].type)
					flag = true;
				else
					break;
			}
			if (flag)
			{
				for (temp = start, j = 0; temp != end; temp = temp->before, j++)
				{
					if (_7group[i][j].value>target[temp->i][temp->j])
					{
						target[temp->i][temp->j] = _7group[i][j].value;
					}
				}
			}
		}
	}
}

void gamemode::CulResult()
{
	gamemode::initialize();
	TRNA* LO = gamemode::getlon();
	TRNA* LA = gamemode::getla();
	TRNA* LT = gamemode::getLtoR();
	TRNA* RT = gamemode::getRtoL();
	gamemode::SingleCul(LO, gamemode::longitude);
	gamemode::SingleCul(LA, gamemode::latitude);
	gamemode::SingleCul(LT, gamemode::LtoR);
	gamemode::SingleCul(RT, gamemode::RtoL);
	TRNA* temp;
	for (temp = LO; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = LA; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = LT; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = RT; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	gamemode::SingleCul(LO, gamemode::longitude2);
	gamemode::SingleCul(LA, gamemode::latitude2);
	gamemode::SingleCul(LT, gamemode::LtoR2);
	gamemode::SingleCul(RT, gamemode::RtoL2);
	int i, j;
	recorder Max={0,0,0};
	for (i = 0; i<15; i++)
	{
		for (j = 0; j<15; j++)
		{
			result1[i][j] = longitude[i][j] + latitude[i][j] + LtoR[i][j] + RtoL[i][j];
		}
	}
	for (i = 0; i<15; i++)
	{
		for (j = 0; j<15; j++)
		{
			result2[i][j] = longitude2[i][j] + latitude2[i][j] + LtoR2[i][j] + RtoL2[i][j];
		}
	}
	for (i = 0; i<15; i++)
	{
		for (j = 0; j<15; j++)
		{
			if (Max.type < (result1[i][j] + tend * result2[i][j] + location[i][j]))
			{
				Max.type = result1[i][j] + tend * result2[i][j] + location[i][j];
				Max.i = i;
				Max.j = j;
			}
		}
	}
	gamemode::ivalue = Max.i;
	gamemode::jvalue = Max.j;
	release(LA);
	release(LO);
	release(LT);
	release(RT);
}

int gamemode::checkwin()
{
	int i, j;
	gamemode::initialize();
	TRNA* LO = gamemode::getlon();
	TRNA* LA = gamemode::getla();
	TRNA* LT = gamemode::getLtoR();
	TRNA* RT = gamemode::getRtoL();
	TRNA *start, *end, *allend;
	for (start = LO, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return 1;
	}
	for (start = LA, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return 1;
	}
	for (start = LT, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return 1;
	}
	for (start = RT, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return 1;
	}
	TRNA *temp;
	for (temp = LO; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = LA; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = LT; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}
	for (temp = RT; temp->next != NULL; temp = temp->next)
	{
		temp->type = temp->type * -1;
	}

	for (start = LO, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return -1;
	}
	for (start = LA, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return -1;
	}
	for (start = LT, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return -1;
	}
	for (start = RT, end = start->next->next->next->next->next; end->next != NULL; start = start->next, end = end->next)
	{
		TRNA* temp;
		bool flag;
		for (i = 0, temp = start; i<5; i++, temp = temp->next)
		{
			flag = false;
			if (temp->type == WinCon[i].type)
				flag = true;
			else
				break;
		}
		if (flag)
			return -1;
	}
	return 0;
}
_入非非_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C/C++】10分钟教你用C++写一个贪吃蛇附带AI功能（附源代码详解和下载）
infinitor的博客
07-29 2664
C++编写贪吃蛇小游戏快速入门 刚学完C++。一时兴起，就花几天时间手动做了个贪吃蛇，后来觉得不过瘾，于是又加入了AI功能。希望大家Enjoy It. 效果图示 AI模式演示 imageimage 整体规划+原理 image 大体上可以分为图上所示的几个类。不过……怎么看都有点强行面向对象的味道在里面。。[哭笑][哭笑][哭笑]。不管了……代码写得可能有点凌乱，下面我会为大家一一讲解...
C++实现五子棋游戏（带AI）
11-11
应用MFC实现五子棋游戏，带简单的AI功能，方便新学者学习
C++ 之 简单的五子棋AI程序
weixin_30933531的博客
02-11 983
本人是大一新生，寒假无聊，抱着试试看的心态（没有想到可以完成），写了C++的简单五子棋程序，开心。 下面是效果图： 一、首先讲讲大致思路。 五子棋实现的基础： 二维数组是五子棋实现的基础。二维数组就像一个棋盘，其中0等于空格，1等于黑棋，2等于白棋，这里电脑就好比只能理解0和1的仆人，我们通过映射，使得五子棋变成计...
基于C++实现五子棋AI算法思想
08-27
主要为大家详细介绍了基于C++实现五子棋AI算法思想，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++五子棋AI
[PE]经典八炮的博客
01-28 2637
使用极小化极大算法，α-β剪枝的C++五子棋AI
C++实现简单的五子棋
07-18
如果项目包含FPlayer（可能代表“First Player”，即第一个玩家），那么可能还涉及了简单的AI设计。可能是一个基本的随机选择，也可能有一定的策略，如最小最大搜索。 10. **调试与测试**： 在开发过程中，调试和...
五子棋AI大赛参赛手册-v11
08-03
这次五子棋AI大赛不仅考验参赛者的编程技巧，更强调策略和算法的设计，对于人工智能的学习和实践是一次极好的机会。通过这种方式，参赛者可以深入理解如何让机器模拟人类思维，进行复杂决策，以及优化对战策略。
Cocos2d-x人机对战五子棋游戏
06-11
开发者只需编写一次代码，就可以通过Cocos2d-x的编译工具链将游戏编译为不同平台的版本。对于iOS、安卓和Win32平台，可能需要适配各自的用户界面和系统特性，例如在iOS上使用滑动手势，在安卓上处理不同屏幕尺寸和...
mfc 快乐五子棋
07-07
虽然描述中提到“很简单”，但实现一个功能完备的五子棋游戏依然涉及到许多编程和技术知识，包括用户界面设计、事件处理、游戏逻辑、人工智能（AI）等。 1. **用户界面设计**：MFC提供了丰富的控件和布局管理器，如...
vc++编写的五子棋
05-16
《VC++实现的五子棋游戏详解》 五子棋是一种深受人们喜爱的双人对弈棋类...通过深入研究这个项目，开发者不仅可以掌握MFC的基本用法，还能了解到如何结合人工智能技术来实现游戏的自动化决策，是一次宝贵的编程实践。
C++简单五子棋的AI设计实现
08-26
主要为大家详细介绍了C++简单五子棋的AI设计实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c++小游戏五子棋，带AI
12-25
c++小游戏五子棋，带AI，基于qt写的，代码浅显易懂，分为人人对战和人机对战两种模式
C++编写五子棋（带AI，mfc，附教程）
02-01
C++编程五子棋附AI内容详细教程开源代码，适合初学者参考与学习。
C++使用MFC基于Minimax算法和α-β剪枝的五子棋AI（带图形界面）
02-19
这里只给出了源代码，没有解决方案文件，大家可以自行组装。VS2022编译通过。博弈树最大搜索深度目前是4层（代码中因为序号从0开始，所以是3，其实还是4层这，已经是上限了）。
C++实现简单五子棋AI
薛崇祥的博客
10-09 4369
使用方法： 输入二维坐标0~14落子，输入-1 -1可以悔棋 #include&amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;gt; using namespace std; #define bas 15 #define Dep_limit 3 #define inf 0x3f3f3f int score[2][6]={{0,5,25,4000,inf,inf},{0,0,2,50,4000,inf}};//...
c语言五子棋最简单的ai,C++简单五子棋的AI设计实现
weixin_42425967的博客
05-23 1372
本文实例为大家分享了C++五子棋的AI设计实现代码，供大家参考，具体内容如下设计思路：通过接口获取信息来确定颜色，通过set_chess函数来确定落点。对每个点位给出两种颜色棋子的打分，分别存在两个15*15的数组里，数组下标代表点的位置。确定最大值所在数组之后，遍历该数组找出所有最大值对应的位置，然后对这些位置统计另一种颜色的棋子的分数，再选取一次最大值，从而确定要落点的位置。打分函数的设计：在...
cocos 2dx 基于C++的 五子棋AI算法思想
shenmirenLcy的博客
10-31 3900
今天我想要分享一下我做五子棋AI的思路。因为在做这个之前，我没有接触过任何像这种类似的东西。通过这一次，我也算是有所了解，我的思路也是来自很多网络上的博客，看了很多，最终总结出了自己的这样一个。 那我的五子棋是15*15的大小（一般也就是这样的一个大小）。我的AI算法要求每一次落子之后都要去计算每一个空暇的位置的“分值”，简单的说，我们需要一个存放棋子的数组，表示是否存放了棋子
C++ AI
最新发布
风之双子天谴
02-12 784
虽然Python是深度学习框架（如TensorFlow和PyTorch）的首选语言，但也有一些C++实现的深度学习框架，如Tiny-DNN和DeepLearning4j的C++后端。此外，对于更复杂的机器学习模型，通常会使用专门的机器学习库，如MLPack、Shogun或TensorFlow的C++ API，这些库提供了丰富的算法和工具来构建和训练模型。：许多机器学习库，如TensorFlow的C++ API、MLPack、Shogun等，都是用C++编写的。最后，它输出了这些参数。
用c++写一个五子棋ai算法
03-29
很抱歉，我是一名语言模型AI，无法编写代码。但是我可以为您提供一个五子棋AI算法的思路： 1. 构建棋盘：首先需要构建一个二维数组来表示棋盘，用0表示空位，用1表示黑子，用2表示白子。 2. 评估函数：制定一个评估函数，用于评估当前棋盘局面的好坏程度。评估函数需要考虑以下因素： a) 棋子数量：当前局面黑子和白子的数量。 b) 连子数量：当前局面黑子和白子的最长连续数量。 c) 棋形：当前局面存在的棋形，如冲四、活三等，这些棋形的威力不同，需要给予不同的分数。 3. Alpha-Beta剪枝算法：采用Alpha-Beta剪枝算法来优化搜索过程。该算法可以减少搜索的节点数量，提高搜索效率。 4. 极大极小算法：采用极大极小算法来搜索最优解。该算法可以通过搜索所有可能的走法来确定最优解。 5. 搜索深度：需要确定搜索的深度，以免搜索时间过长。可以通过动态调整搜索深度的方式来平衡搜索时间和搜索效果。 6. 实现思路：将上述算法结合起来，通过搜索所有可能走法，计算每个走法的得分，选取最高得分的走法作为AI的下一步棋。同时，为了增加AI的智能性，可以加入一些随机因素，使得AI的走法更具多样性。 希望这些思路可以帮助您编写出一个优秀的五子棋AI算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值