C语言五子棋算法

2023-02-23 05:10:02Python014

C语言五子棋算法,第1张

任何一种棋类游戏其关键是对当前棋局是否有正确的评分,评分越准确则电脑的AI越高。五子棋游戏也是如此，但在打分之前，我们先扫描

整个棋盘，把每个空位从八个方向上的棋型填入数组gStyle(2, 15, 15, 8, 2)，其中第一个下标为1时表示黑棋，为2时表示白棋，第二和第三

个下标表示(x,y)，第四个下标表示8个方向，最后一个下标为1时表示棋子数，为2时表示空格数，如：gStyle(1,2,2,1,1)=3表示与坐标(2,2)在第1个方向上相邻的黑棋棋子数为3

gstyle(1,2,2,1,2)=4表示与坐标(2,2)在第1个方向上的最近的空格数为4

在定义方向时，也应该注意一定的技巧，表示两个相反的方向的数应该差4，在程序中我是这样定义的：

Const DIR_UP = 1

Const DIR_UPRIGHT = 2

Const DIR_RIGHT = 3

Const DIR_RIGHTDOWN = 4

Const DIR_DOWN = 5

Const DIR_DOWNLEFT = 6

Const DIR_LEFT = 7

Const DIR_LEFTUP = 8

这样我们前四个方向可以通过加四得到另一个方向的值。如果你还是不太明白，请看下面的图：

---------

---oo----

-ox*xx---

---------

图中的*点从标为(4,4),（打*的位置是空位）,则:

gStyle(2,4,4,1,1)=1在(4,4)点相邻的上方白棋数为1

gStyle(2,4,4,1,2)=2在(4,4)点的上方距上方白棋最近的空格数为2

gStyle(1,4,4,3,1)=2在(4,4)点相邻的右方黑棋数为2

gStyle(1,4,4,3,2)=1在(4,4)点的右方距右方黑棋最近的空格数为3

...一旦把所有空点的棋型值填完，我们很容易地得出黑棋水平方向上点(4,4)的价值，由一个冲1（我把有界的棋称为冲）和活2（两边无界的

棋称为活）组成的。对于而白棋在垂直方向上点(4,4)的价值是一个活1，而在/方向也是活1所以，只要我们把该点的对于黑棋和白棋的价值算出

来，然后我们就取棋盘上各个空点的这两个值的和的最大一点作为下棋的点。然而，对各种棋型应该取什么值呢？我们可以先作如下假设：

　 Fn 表示先手n个棋子的活棋型，如：F4表示先手活四

　 Fn'表示先手n个棋子的冲棋型，如：F4'表示先手冲四

　 Ln 表示后手n个棋子的活棋型，如：L3表示后手活三

　 Ln'表示后手n个棋子的冲棋型，如：L3'表示后手冲三

根据在一行中的棋型分析，得到如下关系：

L1'<=F1'<L2'<=F2'<=L1<F1<L2<F2<L3'<=F3'<L4'<F4'=F4

从这个关系包含了进攻和防守的关系（当然，这个关系是由我定的，你可以自己定义这些关系）。对这些关系再进一步细化，如在一个可下

棋的点，其四个方向上都有活三，也比不上一个冲四，所以我们可以又得到4*F3<L4'这个关系，同样，我们还可以得到其它的关系，如：4*F2<L3、4*L3<F3...，这些的关系由于你的定法和我的定法制可能不一样，这样计算机的AI也就不一样，最后我们把分值最小的L1'值定为1，则我们就得

到了下面各种棋型的分值，由C语言表示为：

F[2][5]={{0,2,5,50,16000},{0,10,30,750,16000}}

L[2][5]={{0,1,5,50,3750},{0,10,30,150,4000}}

F数组表示先手，第一个下标为0时表示冲型，第二个下标表示棋子数，则F2'对应F[0][2]L数组表示后手，第一个下标为0时表示冲型，第二

个下标表示棋子数，则L2对应F[1][2]Ok，棋型的分值关系确定好了以后，我们把每一个可下点的四个方向的棋型值相加（包括先手和后手的分

值），最后选择一个最大值，并把这一点作为计算机要下的点就OK了:)。后话：

1、得到最大值也许不止一个点，但在我的程序中只选择第一个最大点，当然你可以用于个随机数来决定

选择那一个最大值点，也可以对这些最大值点再作进一步的分析。

2、在这个算法中我只考虑了周围有棋子的点，而其它点我没有考虑。

3、可以再更进一步，用这个算法来预测以后的几步棋，再选择预测值最好的一步，这样电脑的AI就更高了

4、这个算法没有考虑黑棋的禁手（双3、双四和多于五子的连棋）。因为在平时我下的五子棋是没有这些

禁手的。

五子棋C语言代码如下：

#include <stdio.h>

#include <bios.h>

#include <ctype.h>

#include <conio.h>

#include <dos.h>

#define CROSSRU 0xbf /*右上角点*/

#define CROSSLU 0xda /*左上角点*/

#define CROSSLD 0xc0 /*左下角点*/

#define CROSSRD 0xd9 /*右下角点*/

#define CROSSL 0xc3 /*左边*/

#define CROSSR 0xb4 /*右边*/

#define CROSSU 0xc2 /*上边*/

#define CROSSD 0xc1 /*下边*/

#define CROSS 0xc5 /*十字交叉点*/

/*定义棋盘左上角点在屏幕上的位置*/

#define MAPXOFT 5

#define MAPYOFT 2

/*定义1号玩家的操作键键码*/

#define PLAY1UP 0x1157/*上移--'W'*/

#define PLAY1DOWN 0x1f53/*下移--'S'*/

#define PLAY1LEFT 0x1e41/*左移--'A'*/

#define PLAY1RIGHT 0x2044/*右移--'D'*/

#define PLAY1DO 0x3920/*落子--空格键*/

/*定义2号玩家的操作键键码*/

#define PLAY2UP 0x4800/*上移--方向键up*/

#define PLAY2DOWN 0x5000/*下移--方向键down*/

#define PLAY2LEFT 0x4b00/*左移--方向键left*/

#define PLAY2RIGHT 0x4d00/*右移--方向键right*/

#define PLAY2DO 0x1c0d/*落子--回车键Enter*/

/*若想在游戏中途退出, 可按 Esc 键*/

#define ESCAPE 0x011b

/*定义棋盘上交叉点的状态, 即该点有无棋子 */

/*若有棋子, 还应能指出是哪个玩家的棋子 */

#define CHESSNULL 0 /*没有棋子*/

#define CHESS1 'O'/*一号玩家的棋子*/

#define CHESS2 'X'/*二号玩家的棋子*/

/*定义按键类别*/

#define KEYEX99v 0/*退出键*/

#define KEYFALLCHESS 1/*落子键*/

#define KEYMOVECURSOR 2/*光标移动键*/

#define KEYINVALID 3/*无效键*/

/*定义符号常量: 真, 假 --- 真为1, 假为0 */

#define TRUE 1

#define FALSE 0

/**********************************************************/

/* 定义数据结构 */

/*棋盘交叉点坐标的数据结构*/

struct point

{

int x,y

}

或者下面这个：

#include <graphics.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

#define N 15

#define B 7

#define STOP -10000

#define OK 1

#define NO 0

#define UP 328

#define DOWN 336

#define LEFT 331

#define RIGHT 333

int a[N+1][N+1]

int zx,zy

int write=1,biaoji=0

struct zn{

long sum

int y

int x

}w[N+1][N+1],max,max1

void cbar(int i,int x,int y,int r)

void map(int a[][])

int getkey()

int key()

void zuobiao(int x,int y,int i)

int tu(int a[][],int write)

int wtu(int a[][],int write)

int zhineng(int a[][])

int zh5(int y,int x,int a[][])

long zzh5(int b[][],int i)

main()

{

int i,j

int gdriver=DETECT

int gmode

initgraph(&gdriver,&gmode,"")

zx=(N+1)/2

zy=(N+1)/2

for(i=1i<=Ni++)

for(j=1j<=Nj++)

a[i][j]=0

map(a)

i=1

while(i)

{

int k,n

k=wtu(a,write)

if(k==STOP) goto end

map(a)

n=zhineng(a)

if(n==STOP) goto end

map(a)

}

end:

}

int zhineng(int a[N+1][N+1])

{

int i,j

int k

max.sum=-1

for(i=0i<=Ni++)

for(j=0j<+Nj++)

{

w[i][j].sum=0

w[i][j].x=i

w[i][j].y=j

}

for(i=1i<=N-4i++)

for(j=1j<=N-4j++)

{

k=zh5(i,j,a)

if(k==STOP) return (STOP)

}

for(i=1i<=Ni++)

for(j=1j<=Nj++)

{

if(max.sum<w[i][j].sum)

{

max.sum=w[i][j].sum

max.y=i

max.x=j

}

else if(max.sum==w[i][j].sum)

{

if(((max.y-zy)*(max.y-zy)+(max.x-zx)*(max.x-zx))>((i-zy)*(i-zy)+(j-zx)*(j-zx)))

max.sum=w[i][j].sum

max.y=i

max.x=j

}

if(a[max.y][max.x]==0)

{

a[max.y][max.x]=-1

zy=max.y

zx=max.x

}

int zh5(int y,int x,int a[N+1][N+1])

{

int i,j

int b[6][6]

long c[13]

long d[6][6]

long temp

for(i=yi<=y+4i++)

for(j=xj<=x+4j++)

b[i+1-y][j+1-x]=a[i][j]

c[1]=b[1][1]+b[1][2]+b[1][3]+b[1][4]+b[1][5]

c[2]=b[2][1]+b[2][2]+b[2][3]+b[2][4]+b[2][5]

c[3]=b[3][1]+b[3][2]+b[3][3]+b[3][4]+b[3][5]

c[4]=b[4][1]+b[4][2]+b[4][3]+b[4][4]+b[4][5]

c[5]=b[5][1]+b[5][2]+b[5][3]+b[5][4]+b[5][5]

c[6]=b[1][1]+b[2][1]+b[3][1]+b[4][1]+b[5][1]

c[7]=b[1][2]+b[2][2]+b[3][2]+b[4][2]+b[5][2]

c[8]=b[1][3]+b[2][3]+b[3][3]+b[4][3]+b[5][3]

c[9]=b[1][4]+b[2][4]+b[3][4]+b[4][4]+b[5][4]

c[10]=b[1][5]+b[2][5]+b[3][5]+b[4][5]+b[5][5]

c[11]=b[1][1]+b[2][2]+b[3][3]+b[4][4]+b[5][5]

c[12]=b[1][5]+b[2][4]+b[3][3]+b[4][2]+b[5][1]

for(i=1i<=12i++)

{

switch(c[i])

{

case 5:biaoji=1return(STOP)

case -5:biaoji=-1return(STOP)

case -4:c[i]=100000break

case 4:c[i]=100000break

case -3:c[i]=150break

case 3:c[i]=150break

case -2:c[i]=120break

case 2:c[i]=100break

case -1:c[i]=1break

case 1:c[i]=1break

default: c[i]=0

}

for(i=1i<=12i++)

{

if(c[i]==150)

c[i]+=zzh5(b,i)

}

for(i=1i<=5i++)

for(j=1j<=5j++)

d[i][j]=0

for(i=1i<=5i++)

for(j=1j<=5j++)

{

if(i==j) d[i][j]+=c[11]

if((i+j)==6) d[i][j]+=c[12]

d[i][j]+=c[i]+c[j+5]

}

for(i=1i<=5i++)

for(j=1j<=5j++)

{

if(b[i][j]!=0)

d[i][j]=-2

}

max1.sum=-1

max1.y=0

max1.x=0

for(i=1i<=5i++)

for(j=1j<=5j++)

{

if(max1.sum<d[i][j])

{

max1.sum=d[i][j]

max1.y=i

max1.x=j

w[i+y-1][j+x-1].sum+=max1.sum

}

else if(max1.sum==d[i][j])

{

if(((i+y-1-zy)*(i+y-1-zy)+(j+x-1-zx)*(j+x-1-zx))>((max1.y+y-1-zy)*(max1.y+y-1-zy)+(max1.x+x-1-zx)*(max1.x+x-1-zx)))

{

max1.sum=d[i][j]

max1.y=i

max1.x=j

}

long zzh5(int b[6][6],int n)

{

int i,j,k,l,m

switch(n)

{

case 1:i=b[1][1]j=b[1][2]k=b[1][3]l=b[1][4]m=b[1][5]break

case 2:i=b[2][1]j=b[2][2]k=b[2][3]l=b[2][4]m=b[2][5]break

case 3:i=b[3][1]j=b[3][2]k=b[3][3]l=b[3][4]m=b[3][5]break

case 4:i=b[4][1]j=b[4][2]k=b[4][3]l=b[4][4]m=b[4][5]break

case 5:i=b[5][1]j=b[5][2]k=b[5][3]l=b[5][4]m=b[5][5]break

case 6:i=b[1][1]j=b[2][1]k=b[3][1]l=b[4][1]m=b[5][1]break

case 7:i=b[1][2]j=b[2][2]k=b[3][2]l=b[4][2]m=b[5][2]break

case 8:i=b[1][3]j=b[2][3]k=b[3][3]l=b[4][3]m=b[5][3]break

case 9:i=b[1][4]j=b[2][4]k=b[3][4]l=b[4][4]m=b[5][4]break

case 10:i=b[1][5]j=b[2][5]k=b[3][5]l=b[4][5]m=b[5][5]break

case 11:i=b[1][1]j=b[2][2]k=b[3][3]l=b[4][4]m=b[5][5]break

case 12:i=b[1][5]j=b[2][4]k=b[3][3]l=b[4][2]m=b[5][1]break

}

if((i==0&&j==1&&k==1&&l==1&&m==0))

return (900)

if((i==0&&j==-1&&k==-1&&l==-1&&m==0))

return(1000)

if((i==0&&j==0&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==0&&m==0))

return(20)

if((i==0&&j==0&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==0&&m==0))

return(20)

if((i==-1&&j==1&&k==1&&l==1&&m==1)||(i==1&&j==-1&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==-1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==-1&&m==1)||(i==1&&j==1&&k==1&&l==1&&m==-1))

return(-60)

if((i==1&&j==-1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==-1&&m==1))

return(-60)

}

int wtu(int a[N+1][N+1],int write)

{

int i=1

map(a)

zuobiao(zx,zy,1)

while(i)

{

int k

k=tu(a,write)

if(k==OK) i=0