78 lines
2.7 KiB
Python
78 lines
2.7 KiB
Python
from player import Player
|
|
from myminimax import Minimax
|
|
|
|
from copy import deepcopy
|
|
|
|
class Robot(Player):
|
|
def __init__(self,side,prediction=1):
|
|
self.id="Robot"
|
|
Player.__init__(self,side)
|
|
self.prediction=prediction
|
|
self.step_choices=1
|
|
|
|
def play(self,board,position,click):
|
|
if board.moving is None or not board.moving_shown:
|
|
self.smartPlay(board)
|
|
|
|
def randomPlay(self,board):
|
|
pieces=self.getSidePieces(board,self.side)
|
|
pieces=self.getMovablePieces(pieces,board)
|
|
r=random.randint(0,len(pieces)-1)
|
|
piece=pieces[r]
|
|
position=board.locateByEntity(piece)
|
|
moves=board.getMoves(piece,position)
|
|
r=random.randint(0,len(moves)-1)
|
|
move=moves[r]
|
|
board.piece_selecter=piece
|
|
board.moves_selecter=moves
|
|
board.move_selection=move
|
|
self.choice=board.piece_selecter,move
|
|
self.hasChosen=True
|
|
|
|
def smartPlay(self,board):
|
|
##print(len(self.getPossibilities(board,self.side)))
|
|
tree=self.predict(board,self.prediction)
|
|
#print(tree)
|
|
minimax=Minimax(tree,0)
|
|
choice=minimax.choice
|
|
#print(minimax.start)
|
|
#print(choice)
|
|
possibilities=self.getFastChoices(board,self.side)
|
|
piece,position,move=possibilities[choice]
|
|
#print(tree[choice])
|
|
#print(possibilities[choice])
|
|
board.piece_selecter=piece
|
|
board.moves_selecter=board.getMoves(piece,position)
|
|
board.move_selection=move
|
|
self.choice=board.piece_selecter,move
|
|
self.hasChosen=True
|
|
##print(self.analyse(board))
|
|
|
|
def predict(self,board,max_n=1,n=0):
|
|
old_value=self.analyse(board)
|
|
side=(self.side-1+n)%2+1
|
|
##print("side ",side)
|
|
if n<max_n:
|
|
possibilities=self.getFastChoices(board,side)
|
|
##print(len(possibilities),n)
|
|
storage=[]
|
|
for possibility in possibilities:
|
|
piece,position,move=possibility
|
|
n_board=deepcopy(board)
|
|
n_board.move(piece,position,move)
|
|
value=self.analyse(board)
|
|
storage.append((n_board,value))
|
|
##print(storage)
|
|
storage=sorted(storage, key=lambda columns: columns[1],reverse=True)
|
|
##print(storage)
|
|
storage=storage[:len(storage)-n*self.step_choices]
|
|
#print(storage)
|
|
output=[]
|
|
for n_board,value in storage:
|
|
##print(value-old_value)
|
|
#if value-old_value>=n*self.step_choices:
|
|
output.append(self.predict(n_board,max_n,n+1))
|
|
return output
|
|
else:
|
|
return self.analyse(board)
|