375 lines
No EOL
13 KiB
Python
375 lines
No EOL
13 KiB
Python
import base as Base
|
|
import copy, random, time, math
|
|
from PIL import Image, ImageDraw
|
|
|
|
class Player(Base.Board):
|
|
def __init__(self, playerName, myIsUpper, size, myPieces, rivalPieces): #do not change this line
|
|
Base.Board.__init__(self, myIsUpper, size, myPieces, rivalPieces) #do not change this line
|
|
self.playerName = playerName
|
|
self.algorithmName = "myGreatMethod"
|
|
self.r = [[0,-1],[1,-1],[1,0],[0,1],[-1,1],[-1,0]]
|
|
|
|
|
|
def getAllEmptyCells(self):
|
|
result = []
|
|
for p in self.board:
|
|
for q in self.board[p]:
|
|
if self.isEmpty(p,q, self.board):
|
|
result.append( [p,q] )
|
|
return result
|
|
|
|
|
|
def getAllNonemptyCells(self):
|
|
result = []
|
|
for p in self.board:
|
|
for q in self.board[p]:
|
|
if not self.isEmpty(p,q, self.board):
|
|
result.append( [p,q] )
|
|
return result
|
|
|
|
def bfs(self,g,e):
|
|
b = {}
|
|
q = []
|
|
r = 0
|
|
b[str(e)] = True
|
|
b[str(g[str(e)][0])] = True
|
|
q.append(str(g[str(e)][0]))
|
|
|
|
while(len(q) > 0):
|
|
p = q[0]
|
|
del q[0]
|
|
r+=1
|
|
for i in g[p]:
|
|
if(b.get(str(i)) == None):
|
|
b[str(i)] = True
|
|
q.append(str(i))
|
|
|
|
return len(g)-1 == r
|
|
|
|
def grasshopper(self,cell):
|
|
result = []
|
|
for i in self.r:
|
|
q = [cell[0]+i[0],cell[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(not self.isEmpty(q[0],q[1],self.board)):
|
|
while(True):
|
|
q = [q[0]+i[0],q[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(self.isEmpty(q[0],q[1],self.board)):
|
|
result.append(q)
|
|
break
|
|
else:
|
|
break
|
|
return result
|
|
|
|
def bug(self,cell):
|
|
result = []
|
|
b = {}
|
|
b[str(cell)] = True
|
|
for i in self.r:
|
|
q = [cell[0]+i[0],cell[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(len(self.board[cell[0]][cell[1]]) > 1):
|
|
result.append(q)
|
|
b[str(q)] = True
|
|
continue
|
|
if(not self.isEmpty(q[0],q[1],self.board)):
|
|
result.append(q)
|
|
else:
|
|
if(b.get(str(q)) == None):
|
|
g = False
|
|
# e = False
|
|
for j in self.r:
|
|
w = [q[0]+j[0],q[1]+j[1]]
|
|
if(self.inBoard(w[0],w[1])):
|
|
if(not self.isEmpty(w[0],w[1],self.board) and b.get(str(w)) == None):
|
|
g = True
|
|
# t = [w[0]-cell[0],w[1]-cell[1]]
|
|
# if(t in self.r and self.isEmpty(w[0],w[1],self.board)):
|
|
# e = True
|
|
if(g):
|
|
b[str(q)] = True
|
|
result.append(q)
|
|
return result
|
|
|
|
def ant(self,cell):
|
|
result = []
|
|
b = {}
|
|
b[str(cell)] = True
|
|
a = [cell]
|
|
while(len(a) > 0):
|
|
p = a[0]
|
|
del a[0]
|
|
for i in self.r:
|
|
q = [p[0]+i[0],p[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(self.isEmpty(q[0],q[1],self.board) and b.get(str(q)) == None):
|
|
g = False
|
|
e = False
|
|
for j in self.r:
|
|
w = [q[0]+j[0],q[1]+j[1]]
|
|
if(self.inBoard(w[0],w[1])):
|
|
if(not self.isEmpty(w[0],w[1],self.board) and b.get(str(w)) == None):
|
|
g = True
|
|
t = [w[0]-p[0],w[1]-p[1]]
|
|
if(t in self.r and self.isEmpty(w[0],w[1],self.board)):
|
|
e = True
|
|
if(e and g):
|
|
a.append(q)
|
|
b[str(q)] = True
|
|
result.append(q)
|
|
return result
|
|
|
|
def bee(self,p):
|
|
result = []
|
|
b = {}
|
|
b[str(p)] = True
|
|
for i in self.r:
|
|
q = [p[0]+i[0],p[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(self.isEmpty(q[0],q[1],self.board) and b.get(str(q)) == None):
|
|
g = False
|
|
e = False
|
|
for j in self.r:
|
|
w = [q[0]+j[0],q[1]+j[1]]
|
|
if(self.inBoard(w[0],w[1])):
|
|
if(not self.isEmpty(w[0],w[1],self.board) and b.get(str(w)) == None):
|
|
g = True
|
|
t = [w[0]-p[0],w[1]-p[1]]
|
|
if(t in self.r and self.isEmpty(w[0],w[1],self.board)):
|
|
e = True
|
|
if(e and g):
|
|
b[str(q)] = True
|
|
result.append(q)
|
|
return result
|
|
|
|
def spider(self,cell):
|
|
result = []
|
|
b = {}
|
|
b[str(cell)] = True
|
|
a = [cell]
|
|
n = 0
|
|
path = []
|
|
while(len(a) > 0 and n < 5):
|
|
n += 1
|
|
if(len(a) == 0):
|
|
break
|
|
p = a[0]
|
|
del a[0]
|
|
for i in self.r:
|
|
q = [p[0]+i[0],p[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(self.isEmpty(q[0],q[1],self.board) and b.get(str(q)) == None):
|
|
g = False
|
|
e = False
|
|
for j in self.r:
|
|
w = [q[0]+j[0],q[1]+j[1]]
|
|
if(self.inBoard(w[0],w[1])):
|
|
t = [w[0]-p[0],w[1]-p[1]]
|
|
if(t in self.r and not self.isEmpty(w[0],w[1],self.board) and b.get(str(w)) == None):
|
|
g = True
|
|
if(t in self.r and self.isEmpty(w[0],w[1],self.board) and b.get(str(w)) == None):
|
|
e = True
|
|
if(e and g):
|
|
# print(self.isEmpty(q[0],q[1],self.board))
|
|
a.append(q)
|
|
path.append(q)
|
|
# print(n,q)
|
|
# b[str(q)] = True
|
|
# if(n == 4 or n == 5):
|
|
# result.append(q)
|
|
for aa in a:
|
|
b[str(aa)] = True
|
|
# print(self.myMove)
|
|
if(len(path) == 6):
|
|
result = path[4:]
|
|
print(path)
|
|
# print(result)
|
|
return result
|
|
|
|
|
|
|
|
def move(self):
|
|
""" return [animal, oldP, oldQ, newP, newQ], or [animal, None, None, newP, newQ] or [] """
|
|
|
|
emptyCells = self.getAllEmptyCells()
|
|
|
|
# tah 0
|
|
if(self.myMove == 0):
|
|
q = random.choice(list(self.myPieces.keys())) # !
|
|
if(len(emptyCells) == 169):
|
|
return [q, None, None, 3,6]
|
|
else:
|
|
m = [[2,6],[4,6],[3,5],[4,5],[2,7],[3,7]]
|
|
n = random.randint(0,len(m)-1) # !
|
|
return [q, None,None,m[n][0],m[n][1]]
|
|
# tah 1-3
|
|
allFigures = self.getAllNonemptyCells()
|
|
myFigures = []
|
|
enemyFigures = []
|
|
graph = {}
|
|
|
|
for cell in allFigures:
|
|
if(graph.get(str(cell)) == None):
|
|
graph[str(cell)] = []
|
|
for i in self.r:
|
|
q = [cell[0]+i[0],cell[1]+i[1]]
|
|
if(graph.get(str(q)) != None):
|
|
graph[str(cell)] = graph[str(cell)] + [q]
|
|
graph[str(q)] = graph[str(q)] + [cell]
|
|
|
|
a = self.board[cell[0]][cell[1]][-1]
|
|
if(self.myColorIsUpper == a.isupper()):
|
|
myFigures.append(cell)
|
|
else:
|
|
enemyFigures.append(cell)
|
|
|
|
movableFigures = {}
|
|
possibleEmptyCells = []
|
|
|
|
for cell in myFigures:
|
|
if(self.myMove > 3):
|
|
if(self.bfs(graph,cell) or len(self.board[cell[0]][cell[1]]) > 1):
|
|
animal = self.board[cell[0]][cell[1]][-1]
|
|
if(animal.lower() == 'g'):
|
|
arr = self.grasshopper(cell)
|
|
if(len(arr) > 0):
|
|
movableFigures[str(cell)] = arr
|
|
elif(animal.lower() == 'b'):
|
|
arr = self.bug(cell)
|
|
if(len(arr) > 0):
|
|
movableFigures[str(cell)] = arr
|
|
elif(animal.lower() == 'a'):
|
|
arr = self.ant(cell)
|
|
if(len(arr) > 0):
|
|
movableFigures[str(cell)] = arr
|
|
elif(animal.lower() == 'q'):
|
|
arr = self.bee(cell)
|
|
if(len(arr) > 0):
|
|
movableFigures[str(cell)] = arr
|
|
elif(animal.lower() == 's'):
|
|
arr = self.spider(cell)
|
|
if(len(arr) > 0):
|
|
movableFigures[str(cell)] = arr
|
|
|
|
for i in self.r:
|
|
q = [cell[0]+i[0],cell[1]+i[1]]
|
|
if(self.inBoard(q[0],q[1])):
|
|
if(self.isEmpty(q[0],q[1],self.board)):
|
|
end = False
|
|
for e in enemyFigures:
|
|
if(end):
|
|
break
|
|
a = [e[0]-q[0],e[1]-q[1]]
|
|
if(a in self.r):
|
|
end = True
|
|
if(not end):
|
|
possibleEmptyCells.append((q))
|
|
|
|
if(len(possibleEmptyCells) == 0 and len(movableFigures) == 0):
|
|
return []
|
|
if(len(possibleEmptyCells) == 1):
|
|
randomP, randomQ = possibleEmptyCells[0]
|
|
else:
|
|
if(len(possibleEmptyCells) > 0 ):
|
|
randomEmptyCell = possibleEmptyCells[ random.randint(0, len(possibleEmptyCells)-1) ]
|
|
randomP, randomQ = randomEmptyCell
|
|
|
|
if(len(possibleEmptyCells) > 0 ):
|
|
if(self.myMove == 3):
|
|
q = 'q'
|
|
if(self.myColorIsUpper):
|
|
q = 'Q'
|
|
if(self.myPieces[q] == 1):
|
|
return [q,None,None,randomP,randomQ]
|
|
|
|
|
|
if len(emptyCells) == 0:
|
|
return []
|
|
|
|
result = None
|
|
while(result == None):
|
|
# Place
|
|
if(len(possibleEmptyCells) > 0 ):
|
|
for animal in self.myPieces:
|
|
p = random.choice(list(self.myPieces.keys()))
|
|
if self.myPieces[p] > 0:
|
|
result = [ p, None, None, randomP, randomQ ]
|
|
break
|
|
|
|
# Move
|
|
if(len(movableFigures) > 0 and self.myMove > 3):
|
|
randomFigure,figureMoves = random.choice(list(movableFigures.items()))
|
|
randomFigure = randomFigure.replace('[','').replace(']','').replace(' ','').split(',')
|
|
randomFigure = list(map(int,randomFigure))
|
|
|
|
if(len(figureMoves) == 1):
|
|
randomMove = figureMoves[0]
|
|
else:
|
|
randomMove = figureMoves[ random.randint(0, len(figureMoves)-1) ]
|
|
|
|
randomFigureP, randomFigureQ = randomFigure
|
|
animal = self.board[ randomFigureP ][ randomFigureQ ][-1]
|
|
|
|
result = [animal, randomFigureP, randomFigureQ, randomMove[0], randomMove[1] ]
|
|
break
|
|
return result
|
|
|
|
|
|
|
|
|
|
def updatePlayers(move, activePlayer, passivePlayer):
|
|
""" write move made by activePlayer player
|
|
this method assumes that all moves are correct, no checking is made
|
|
"""
|
|
if len(move) == 0:
|
|
return
|
|
|
|
animal, p,q, newp, newq = move
|
|
if p == None and q == None:
|
|
activePlayer.myPieces[animal]-=1
|
|
passivePlayer.rivalPieces = activePlayer.myPieces.copy()
|
|
else:
|
|
activePlayer.board[p][q] = activePlayer.board[p][q][:-1]
|
|
passivePlayer.board[p][q] = passivePlayer.board[p][q][:-1]
|
|
|
|
activePlayer.board[newp][newq] += animal
|
|
passivePlayer.board[newp][newq] += animal
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
boardSize = 13
|
|
smallFigures = { "q":1, "a":2, "b":2, "s":2, "g":2 }
|
|
bigFigures = { figure.upper(): smallFigures[figure] for figure in smallFigures }
|
|
|
|
P1 = Player("player1", False, 13, smallFigures, bigFigures)
|
|
P2 = Player("player2", True, 13, bigFigures, smallFigures)
|
|
|
|
filename = "begin.png"
|
|
P1.saveImage(filename)
|
|
|
|
moveIdx = 0
|
|
while True:
|
|
|
|
move = P1.move()
|
|
print("P1 returned", move)
|
|
updatePlayers(move, P1, P2)
|
|
filename = "move-{:03d}-player1.png".format(moveIdx)
|
|
P1.saveImage(filename)
|
|
|
|
|
|
move = P2.move()
|
|
print("P2 returned", move)
|
|
updatePlayers(move, P2, P1)
|
|
filename = "move-{:03d}-player2.png".format(moveIdx)
|
|
P1.saveImage(filename)
|
|
|
|
moveIdx += 1
|
|
P1.myMove = moveIdx
|
|
P2.myMove = moveIdx
|
|
|
|
if moveIdx > 4:
|
|
print("End of the test game")
|
|
break |