翻转黑白棋

Python实现⿊⽩棋⼈机对弈

Python实现⿊⽩棋⼈机对弈

规则

⿊⽩棋的每颗棋⼦由⿊⽩两⾊组成，⼀⾯⽩，⼀⾯⿊。每次落⼦，把本⽅颜⾊的棋⼦放在棋盘的空格上，若在横、竖、斜⼋个⽅向的任⼀⽅向上有

本⽅棋⼦，则被夹在中间的对⼿棋⼦全部翻转为本⽅棋⼦颜⾊；并且，仅在可以翻转棋⼦的地⽅才能落⼦。如果⼀⽅⾄少有⼀步合法棋步可下，他

就必须落⼦，不得弃权。棋盘已满或双⽅都没有棋⼦可下时棋局结束，以棋⼦数⽬来计算胜负，棋⼦多的⼀⽅获胜。在棋盘还没有下满时，如果⼀

⽅的棋⼦已经被对⽅吃光，则棋局也结束，将对⼿棋⼦吃光的⼀⽅获胜。

两位玩家轮流下棋，直到⼀⽅没有符合规则的落⼦位置，在这种情况下，剩下的⼀⽅继续下棋，直到对⼿有了可以落⼦的位置。此时，恢复两者轮

流下棋的顺序。如果⼀⽅落⼦在⾮法位置，则视为放弃本次对弈，对⽅获胜。游戏结束的条件：1）整个棋盘满了；2）⼀⽅的棋⼦已经被对⽅吃

光；3）两名玩家都没有可以落⼦的棋盘格；4）⼀⽅落⼦在⾮法位置。前3种情况以棋⼦数⽬来计算胜负，棋⼦多的⼀⽅获胜；第4种情况判定

对⽅获胜。

计算机选择落⼦位置的策略

选择落⼦位置的策略选择落⼦位置的策略对每个可能的落⼦位置,计算该位置的该位置的“分值”（可以翻转的对⼿棋⼦数量可以翻转的对

⼿棋⼦数量可以翻转的对⼿棋⼦数量.同分数选择⾏数⼩的。

实现思路

⿊⽩棋玩家的⼦的坐标放在集合中，改变集合元素实现下棋。根据集合中元素打印棋盘。

亟待完善的地⽅

机器下棋策略可以改善，设计递推⽅法

不同的持棋⽅式写了重复的代码，可以进⼀步包装

⽆效代码可以删除，如cont，

命名

importtime

importcsv

classHeiBaiPlayer(object):

status=True#是否有位置可以下

defeat=Fal#是否赢了

R_LIST=[(i,j)foriinrange(-1,2)forjinrange(-1,2)]

R_((0,0))

count=0

def__init__(lf,dim,players,_color):#_color只能是heiorbai，players只能是comorpeop

={(dim//2+1,dim//2),(dim//2,dim//2+1)}

s=players

={(dim//2,dim//2),(dim//2+1,dim//2+1)}

=dim

lf._color=_color#dic

defqp_print(lf):

'''

根据场中的hei和bai打印棋盘

:return:

'''

foriinrange(+1):

ifi==0:

print("",end='')

print(''.join([str(chr(97+x))forxinrange()]))

el:

forjinrange(+1):

ifj==0:

print(chr(96+i),end='')

el:

if(i,j):

print('X',end='')

elif(i,j):

print('O',end='')

el:

#print((i,j))

print('.',end='')

print()

deflegal_position(lf,players):

'''

:paramplayers:bai或者hei的集合

:return:字典{bai玩家或者hei玩家可以落⼦位置：反转对⼿⼦的位置}

'''

ifplayers==:

_players=

el:

_players=

kong=[(i,j)foriinrange(1,+1)forjinrange(1,+1)]

kong=t(kong)-

#print(kong)

p_players_list_in={}#如果落在p，会有的夹在中间的反⾊⼦集合

forpinkong:

all_r_players_list_in=[]#所有⽅向的反⾊夹在中间⼦的集合

forrinlf.R_LIST:

_players_list_in=[]#某⼀⽅向夹在中间反⾊⼦的集合

i=1

lst=[]

while1:

if(p[0]+i*r[0],p[1]+i*r[1])in_players:

(tuple([p[0]+i*r[0],p[1]+i*r[1]]))

i+=1

if(p[0]+i*r[0],p[1]+i*r[1])inplayers:

_players_list_in+=lst

break

ifi>+1:

break

el:

break

if_players_list_in:#如果这个⽅向有jiazai中间的反⾊⼦

all_r_players_list_in+=_players_list_in

ifall_r_players_list_in:#如果落在p，会夹在中间的反⾊⼦集合【】

p_players_list_in[p]=all_r_players_list_in

#print(p_players_list_in,'这是测试')

returnp_players_list_in

defcallback(lf):

'''

根据对象不同选择不同的下棋⽅式

:return:机器下棋还是⼈⼯下棋

'''

s=='com':

er_xia

s=='peop':

s_xia

defcolor(lf):

iflf._color=='hei':

defhefa(lf,players,p):

defhefa(lf,players,p):

'''

测试某⼀位置是否合法，如果合法，返回相应反转的⼦的位置，不合法返回Fal

:paramp:位置元组

:return:列表

'''

_position(players).keys():

_position(players)[p]

returnFal

defdefen(lf,players,p):

'''

某⼀位置的得分

:paramplayers:t

:paramp:(,)

:return:

'''

returnlen((players,p))

defcomputer_xia(lf,players):#要么是⿊，要么是⽩，players类型是集合

_position(players).keys():

print('comnoInvalidmoven========')

=Fal

el:

=True

p_score={}

_position(players).keys():

p_score[p]=(players,p)

score=max(p_())

forpin[(i,j)foriinrange(1,+1)forjinrange(1,+1)]:

(players,p):

ifp_score[p]==score:

return{p:_position(players)[p]}

defplayers_xia(lf,players):#要么是⿊，要么是⽩，players类型是集合

'''

⼈⼯下棋，先判断有⽆位置可以下，在让⽤户选择落⼦位置，如果位置出错=True

:paramplayers:⼈player拥有⼦位置的集合

:return:{落⼦位置:反转对⾯位置}

'''

_position(players).keys():

print('poeplenoInvalidmoven========')

=Fal

el:

=True

try:

s=input("你的落⼦位置（例如ab：a⾏b列）:?")

posintion=tuple([ord(s[0])-96,ord(s[1])-96])

_position(players).keys():

return{posintion:_position(players=players)[posintion]}

el:

=True

exceptExceptiona:

print('SthWrong,Tryagain',e)

s=input("你的落⼦位置:?")

posintion=tuple([ord(s[0])-96,ord(s[1])-96])

_position(players).keys():

return{posintion:_position(players=players)[posintion]}

el:

=True

defchange(lf,dic):

'''

下棋之后改变hei和bai中的元素

:paramdic:{落⼦位置:反转对⾯位置}

:return:新的hei和bai集合

'''

iflf._color=='hei':

=|t(list(()))|t(list(())[0])

=-t(list(())[0])

el:

=|t(list(()))|t(list(())[0])

=-t(list(())[0])

defcom_turn():

'''

电脑下棋

:return:

'''

=

=

color_t=()#颜⾊集合

HeiBaiPlayer_function=ck()#下棋⽅法传⼊集合

dic=HeiBaiPlayer_function(color_t)#得到下棋位置和反转位置

:

_print()

el:

==Fal:

=True

=0

print('=='*5)

print('机器下棋位置：反转对⽅位置',dic)

(dic)

#print(,)

_print()

:

=True

defpeop_turn():

'''

⼈下棋

:return:

'''

=

=

color_t=()

HeiBaiPlayer_function=ck()#下棋的函数

dic=HeiBaiPlayer_function(color_t)

:

_print()

:

==Fal:

=True

=0

print('=='*5)

#print('⼈的下棋位置:反转对⽅位置',dic)

#print('⼈的下棋位置:反转对⽅位置',dic)

(dic)

#print('⿊,⽩',,)

_print()

el:

_print()

=True

#print("⼈输了")

t1=()

begin_time=me('%Y%m%d%H:%M:%S')

Dimension=eval(input('Dimension:'))#⽤户输⼊开始

OX=input('Computerplays(X/O):')

ifOX=='O':

com=HeiBaiPlayer(dim=Dimension,players='com',_color='bai')

peop=HeiBaiPlayer(dim=Dimension,players='peop',_color='hei')

hei_player='computer'

ifOX=='X':

com=HeiBaiPlayer(dim=Dimension,players='com',_color='hei')

peop=HeiBaiPlayer(dim=Dimension,players='peop',_color='bai')

hei_player='players'

ifcom._color=='hei':

count=0

_print()

while1:

com_turn()

====Fal:

print("Bothplayershavenovalidmove.")

print("GameOver")

print('com:{}**peop:{}'.format((),()))

iflen(())>len(()):

print('comwin!!')

eliflen(())

print('playerswin!!')

el:

print('0⽐0')

score=str(len(()))+':'+str(len(()))

break

peop_turn()

:

print('ver.')

print('comwin')

score='Humangiveup'

break

====Fal:

print("Bothplayershavenovalidmove.")

print("GameOver")

print('com:{}**peop:{}'.format((),()))

iflen(())>len(()):

print('comwin!!')

eliflen(())

print('playerswin!!')

el:

print('0⽐0')

score=str(len(()))+':'+str(len(()))

break

_print()

ifpeop._color=='hei':

count=0

_print()

while1:

peop_turn()

:

print('ver.')

print('comwin')

score='Humangiveup'

break

====Fal:

print("Bothplayershavenovalidmove.")

print("GameOver")

print('com:{}**peop:{}'.format((),()))

iflen(())>len(()):

print('comwin!!')

eliflen(())

print('playerswin!!')

el:

print('0⽐0')

score=str(len(()))+':'+str(len(()))

break

com_turn()

====Fal:

print("Bothplayershavenovalidmove.")

print("GameOver")

print('com:{}**peop:{}'.format((),()))

iflen(())>len(()):

print('comwin!!')

eliflen(())

print('playerswin!!')

el:

print('0⽐0')

score=str(len(()))+':'+str(len(()))

break

_print()

t2=()

time_p=int(t2-t1)

ifhei_player=='computer':

bai_player='players'

el:

bai_player='computer'

defsave_info(begin_time,time_p,dim,hei_player,bai_player,score):

withopen('','a',newline='')asf:

writer=(f)

ow([begin_time,time_p,str(dim)+'*'+str(dim),hei_player,bai_player,score])

save_info(begin_time,time_p,Dimension,hei_player,bai_player,score)

1544455193(1).jpg

1544455180(1).jpg