def __init__(self, master):
self.frame = Frame(master)
self.frame.pack()
self.height = 400
self.width = 400
self.grid_column = 8
self.grid_row = 8
self.canvas = Canvas(self.frame, height=self.height, width=self.width)
self.cellwidth = int(self.canvas["width"]) / self.grid_column
self.cellheight = int(self.canvas["height"]) / self.grid_row
self.draw_grid()
self.canvas.pack()
with open("board.json", "r") as boar_data:
board = json.load(boar_data)
self.model = board["board"]
self.player = 1
self.pos = (0, 0)
self.draw_chips()
self.game = Othello(copy.deepcopy(self.model))
self.machine = Label(self.frame, text="CPU 2")
self.machine.pack(side=LEFT)
self.player1 = Label(self.frame, text="Player1 2")
self.player1.pack(side=RIGHT)
def handler(event, self=self):
return self.__on_click(event)
self.canvas.bind('<Button-1>', handler)
self.hi_there = Button(self.frame,
text="Jugar",
command=self.start_game)
self.hi_there.pack(side=LEFT)
def learn(self, num_episode, p_type, op_type, ld_val):
for i in xrange(num_episode):
#print(i)
game = Othello()
black_player = Player(self, game, True, p_type)
white_player = Player(self, game, False, op_type)
game.game_board.updateValidMoves()
print("{}: {} vs. {}, lambda - {}:").format(
self.iteration, p_type, op_type, ld_val)
print("Valid Moves: {}").format(game.validMovesStringify())
for k, v in black_player.getNNInputs().items():
print("{}: {}").format(game.validMoveStringify(k),
self.getValue(np.matrix(v)))
print("")
while True:
#print turn
if game.game_board.black_turn:
#print("Black's Turn")
pstateVector = black_player.getBoardVector()
black_player.makeMove()
cstateVector = black_player.getBoardVector()
else:
#print("White's Turn")
pstateVector = white_player.getBoardVector()
white_player.makeMove()
cstateVector = white_player.getBoardVector()
if game.isGameOver():
break
else:
self.train(pstateVector, 0, cstateVector, False)
if (game.black_score > game.white_score):
#game is over, update matrix and reset elegibility matrix
self.bwin += 1
self.train(pstateVector, 1, cstateVector, True)
self.reset()
# print("black wins\n")
elif (game.black_score < game.white_score):
#game is over, update matrix and reset elegibility matrix
self.wwin += 1
self.train(pstateVector, 0, cstateVector, True)
self.reset()
# print("white wins\n")
elif (game.black_score == game.white_score):
#game is over, update matrix and reset elegibility matrix
self.train(pstateVector, 0.5, cstateVector, True)
self.reset()
# print("tie\n")
self.iteration += 1
print("{}: {} vs. {}, lambda - {}:").format(self.iteration, p_type,
op_type, self.ld)
print("black wins: {}").format(self.bwin)
print("white wins: {}\n").format(self.wwin)
def Play(i, players):
oth = Othello(players)
oth.StartGame(startByFirst=bool(i % 2), showBoard=True)
result = oth.board.GetCount()
if (result[0] > result[1]): return 1
elif (result[0] < result[1]): return -1
else: return 0
def start_Game(self):
telo = Othello()
print('*** Start game *** ')
print("Jugadas : ",telo.actions(self.model))
alpa = alphabeta_search(self.model,telo)
print("Maquina pos nueva: ",alpa)
self.model = telo.result(self.model,[alpa[0],alpa[1]])
self.drawChips()
def play1(nn_black, nn_white, player_black):
game = Othello()
if player_black:
agent = Player(nn_white, game, not player_black, "alphabeta")
else:
agent = Player(nn_black, game, not player_black, "alphabeta")
while True:
#if no valid moves, switch turns and check for winner
if game.isGameOver():
break
#print score
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
#print board
print(game.game_board)
#agent's turn
if game.game_board.black_turn and not player_black:
print("Black's Turn")
agent.makeMove()
elif not game.game_board.black_turn and player_black:
print("White's Turn")
agent.makeMove()
#player's turn
else:
if player_black:
print("Black's Turn")
else:
print("White's Turn")
#Print valid moves
print("Valid Moves: {}").format(game.validMovesStringify())
#Get move input
move = raw_input("Choose move (q to quit): ")
#validate input
is_valid_move = game.validateMoveInput(move)
if is_valid_move:
if move == "q" :
break
else:
move = game.moveToCoords(move)
game.setTile(move[0], move[1])
print("\n==========================================================\n")
#Game Over
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
print(game.game_board)
#Check score
if(game.black_score > game.white_score):
print("Black Wins!")
elif(game.black_score < game.white_score):
print("White Wins!")
elif(game.black_score == game.white_score):
print("It's a tie!")
def playGui(nn):
root = tk.Tk()
game = Othello()
black_player = Player(nn, game, True, "human_gui")
white_player = Player(nn, game, False, "nn")
gui_board = GameBoard(root, game, black_player, white_player)
gui_board.play()
def play2():
game = Othello()
while True:
game.game_board.updateValidMoves()
#if no valid moves, switch turns and check for winner
if game.game_board.valid_moves == {}:
if game.game_board.black_turn:
print("Black cannot make any valid moves")
else:
print("White's cannot make any valid moves")
game.game_board.switchTurns()
#check for winner
game.game_board.updateValidMoves()
if game.game_board.valid_moves == {}:
break
#print score
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
#print board
print(game.game_board)
#print turn
if game.game_board.black_turn:
print("Black's Turn")
else:
print("White's Turn")
#Print valid moves
print("Valid Moves: {}").format(game.validMovesStringify())
#Get move input
move = raw_input("Choose move (q to quit): ")
#validate input
is_valid_move = game.validateMoveInput(move)
if is_valid_move:
if move == "q" :
break
else:
move = game.moveToCoords(move)
game.setTile(move[0], move[1])
print("\n==========================================================\n")
#Game Over
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
print(game.game_board)
#Check score
if(game.black_score > game.white_score):
print("Black Wins!")
elif(game.black_score < game.white_score):
print("White Wins!")
elif(game.black_score == game.white_score):
print("It's a tie!")
def __onClick(self, event):
telo = Othello()
i=int(event.y/self.cellheight)
j=int(event.x/self.cellwidth)
self.pos =(i,j)
self.player = telo.to_move(self.model)
lisMovValidos = telo.actions(self.model)
lisNew = [i,j]
movValido = False
if self.model[i][j]==0 and lisNew in lisMovValidos:
self.model = telo.result(self.model,[i,j])
movValido = True
if movValido:
if(self.player==1):
self.player=2
else:
self.player=1
self.drawChips()
"""alpa = alphabeta_search(self.model,telo)
def play0(nn_black, nn_white):
global bWin, wWin, ties
game = Othello()
black_player = Player(nn_black, game, True)
white_player = Player(nn_white, game, False, "random")
while True:
#if no valid moves, switch turns and check for winner
if game.isGameOver():
break
#print score
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
#print board
print(game.game_board)
#print turn
if game.game_board.black_turn:
print("Black's Turn")
black_player.makeMove()
else:
print("White's Turn")
white_player.makeMove()
print("\n==========================================================\n")
#Game Over
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
print(game.game_board)
#Check score
if(game.black_score > game.white_score):
bWin +=1
print("Black Wins!")
elif(game.black_score < game.white_score):
wWin +=1
print("White Wins!")
elif(game.black_score == game.white_score):
ties+=1
print("It's a tie!")
nn.addModule(hiddenLayer3)
nn.addModule(hiddenLayer4)
nn.addModule(hiddenLayer5)
nn.addConnection(FullConnection(inLayer, hiddenLayer1))
nn.addConnection(FullConnection(inLayer, hiddenLayer2))
nn.addConnection(FullConnection(hiddenLayer1, hiddenLayer3))
nn.addConnection(FullConnection(hiddenLayer2, hiddenLayer3))
nn.addConnection(FullConnection(hiddenLayer2, hiddenLayer5))
nn.addConnection(FullConnection(hiddenLayer3, hiddenLayer4))
nn.addConnection(FullConnection(hiddenLayer3, hiddenLayer5))
nn.addConnection(FullConnection(hiddenLayer3, outLayer))
nn.addConnection(FullConnection(hiddenLayer4, outLayer))
nn.addConnection(FullConnection(hiddenLayer5, outLayer))
nn.sortModules()
othello = Othello()
smartPlayer = SmartPlayer(nn,othello.boardSize)
tacticalPlayer = TacticalPlayer()
tacticalPlayer.newGame(othello,random.choice([othello.WHITE_PLAYER,othello.BLACK_PLAYER]));
smartPlayer.newGame(othello,tacticalPlayer.enemy);
playGame(othello,tacticalPlayer,smartPlayer)
if othello.getWinner() == tacticalPlayer.color:
outcome = -1
print "Tactical Player wins over Network Player 4"
count += 1
semicount += 1
elif othello.getWinner() == smartPlayer.color:
outcome = 1
print "Network Player 4 wins over Tactical Player"
def game_begin():
print('New game starts!')
try:
size = int(input('Input the size of the board (Integers Only!!!!):'))
block = int(input('Input the number of blocks on the board (Integers Only!!!!):'))
except:
print('You did not input a number, now game starts with 8*8 board and 3 blocks')
size = 8
block = 3
print('-----------------------------------------------------')
print('Choose whether to play first')
first = input('input Y or N: ')
if first == 'Y' : play = 1
elif first == 'N' : play = -1
else:
print('Your input is wrong, now you need to play first')
play = 1
print('-----------------------------------------------------')
print(' Hints : 2 is wall, 1 is you and -1 is AI')
oth = Othello(size, block)
oth.print_board()
while True:
actions = oth.action_valid(play)
isfinish = oth.finish(actions)
if isfinish < 0:
if play == 1:
print('-----------------------------------------------------')
print('Now you have several valid actions to choose')
print(actions)
indexIn = input('Input the index you want to choose(Integers Only and must be less than {}):'.format(len(actions)))
index = int(indexIn) -1
if index >= size or index < 0:
print('Your input is inValid. You determined to choose the first one.')
index = 0
action = actions[index]
oth.player_action(action)
oth.change(action, play)
print('Ok, now the board has changed:')
oth.print_board()
else:
print('-----------------------------------------------------')
print('Now it is the AI turn')
print('Valid actions:', actions)
oth.computer_action(actions)
oth.print_board()
play *= -1
else:
print('-----------------------------------------------------')
print('Okay, game over = 3 = ')
if isfinish == 1:
print('Great !!! You Win!!!!')
elif isfinish == 2:
print('Oops ..Sorry, good Luck next time!')
else:
print('Not bad, you are the same as AI!')
break
hiddenLayer2 = LinearLayer(80)
hiddenLayer3 = SigmoidLayer(33)
outLayer = SoftmaxLayer(64)
nn.addInputModule(inLayer)
nn.addOutputModule(outLayer)
nn.addModule(hiddenLayer1)
nn.addModule(hiddenLayer2)
nn.addModule(hiddenLayer3)
nn.addConnection(FullConnection(inLayer, hiddenLayer1))
nn.addConnection(FullConnection(inLayer, hiddenLayer2))
nn.addConnection(FullConnection(hiddenLayer2, hiddenLayer3))
nn.addConnection(FullConnection(hiddenLayer1, outLayer))
nn.addConnection(FullConnection(hiddenLayer3, outLayer))
nn.sortModules()
othello = Othello()
smartPlayer = SmartPlayer(nn, othello.boardSize)
randomPlayer = TacticalPlayer()
randomPlayer.newGame(othello, random.choice([othello.WHITE_PLAYER, othello.BLACK_PLAYER]))
smartPlayer.newGame(othello, randomPlayer.enemy)
playGame(othello, randomPlayer, smartPlayer)
if othello.getWinner() == randomPlayer.color:
outcome = -1
print "Tactical Player wins over Network Player 1"
count += 1
semicount += 1
elif othello.getWinner() == smartPlayer.color:
outcome = 1
print "Network Player 1 wins over Tactical Player"
wincnt += 1
if mode == 'NextOne':
player = NextOne(Stone("○"),name,education_bord)
elif mode == 'CountStone':
player = CountStone(Stone("○"),name,education_bord)
elif mode == 'Random':
player = Random(Stone("○"),name,education_bord)
elif mode == 'Q_learning':
player = Q_learning(Stone("○"),name,education_bord)
elif mode == 'Naive':
player = Naive(Stone("○"),name,education_bord)
elif mode == 'MLP':
player = MLP_p(Stone("○"),name,education_bord)
return player
player1 = get_player('MLP','P1','black')
player2 = get_player('Random','P2','white')
player1.battleMode()
game = Othello(nplay=600,show_result=True,show_board=False)
game.play(player1,player2)
# player2 = get_player('Q_learning','P2','white','no')
# game = Othello(nplay=120000,show_result=True,show_board=False)
# game.play(player1,player2)
# player1.q.save('p1.pickle')
# player2.q.save('p2.pickle')
# player1.battleMode()
# print()
# player2 = get_player('Random','P2','white')
# game = Othello(nplay=600,show_result=True,show_board=False)
# game.play(player1,player2)
from SmartPlayer import SmartPlayer
from RandomPlayer import RandomPlayer
from GreedyPlayer import GreedyPlayer
from Othello import Othello
from Player import playGame
from HumanPlayer import HumanPlayer
from pybrain.tools.customxml.networkreader import NetworkReader
from TacticalPlayer import TacticalPlayer
import random
#nn = NetworkReader.readFrom("othelloNetwork.xml")
#opponentPlayer = SmartPlayer(nn,8) #change this to change the opponent to be testing against
opponentPlayer = TacticalPlayer()
humanPlayer = HumanPlayer()
othello = Othello()
othello.resetGame()
humanPlayer.newGame(othello,random.choice([othello.WHITE_PLAYER,othello.BLACK_PLAYER]))
opponentPlayer.newGame(othello,humanPlayer.enemy)
playGame(othello,humanPlayer,opponentPlayer)
if othello.getWinner() == humanPlayer.color:
print "You won!"
elif othello.getWinner() == opponentPlayer.color:
print "You lost!"
else:
print "Tie game! :("
class App:
def __init__(self, master):
self.frame = Frame(master)
self.frame.pack()
self.height = 400
self.width = 400
self.grid_column = 8
self.grid_row = 8
self.canvas = Canvas(self.frame, height=self.height, width=self.width)
self.cellwidth = int(self.canvas["width"]) / self.grid_column
self.cellheight = int(self.canvas["height"]) / self.grid_row
self.draw_grid()
self.canvas.pack()
with open("board.json", "r") as boar_data:
board = json.load(boar_data)
self.model = board["board"]
self.player = 1
self.pos = (0, 0)
self.draw_chips()
self.game = Othello(copy.deepcopy(self.model))
self.machine = Label(self.frame, text="CPU 2")
self.machine.pack(side=LEFT)
self.player1 = Label(self.frame, text="Player1 2")
self.player1.pack(side=RIGHT)
def handler(event, self=self):
return self.__on_click(event)
self.canvas.bind('<Button-1>', handler)
self.hi_there = Button(self.frame,
text="Jugar",
command=self.start_game)
self.hi_there.pack(side=LEFT)
def draw_grid(self):
for i in range(self.grid_row):
for j in range(self.grid_column):
x1 = i * self.cellwidth
y1 = j * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
self.canvas.create_rectangle(x1, y1, x2, y2, fill="green")
def draw_chip(self):
x = self.pos[1] * self.cellwidth
y = self.pos[0] * self.cellheight
if self.player == 1:
self.canvas.create_oval(x,
y,
x + self.cellwidth,
y + self.cellheight,
fill='black')
self.player = 2
else:
self.canvas.create_oval(x,
y,
x + self.cellwidth,
y + self.cellheight,
fill='white')
self.player = 1
def draw_chips(self):
white = 0
black = 0
for i in range(len(self.model)):
row = self.model[i]
for j in range(len(row)):
val = self.model[i][j]
x = j * self.cellwidth
y = i * self.cellheight
if val == 1:
white += 1
self.canvas.create_oval(x,
y,
x + self.cellwidth,
y + self.cellheight,
fill='black')
elif val == 2:
black += 1
self.canvas.create_oval(x,
y,
x + self.cellwidth,
y + self.cellheight,
fill='white')
def set_points(self, white, black):
txt1 = StringVar()
txt1.set("CPU: " + str(black))
self.machine.config(textvariable=txt1)
txt2 = StringVar()
txt2.set("Player: " + str(white))
self.player.config(textvariable=txt2)
def __on_click(self, event):
i = int(event.y / self.cellheight)
j = int(event.x / self.cellwidth)
self.pos = (i, j)
if self.model[i][j] == 0:
self.model[i][j] = self.player
self.player = 1
new_state = self.game.game_user(self.pos)
if len(new_state) is not 0:
self.model = new_state
self.game.result_operation = []
self.player = 1
self.game.set_move(self.player)
self.draw_chips()
self.start_game()
def start_game(self):
self.game.set_move(self.player)
self.model = self.game.play_game()
self.game.result_operation = []
self.player = 2
self.game.set_move(self.player)
self.draw_chips()
from SmartPlayer import SmartPlayer
from RandomPlayer import RandomPlayer
from GreedyPlayer import GreedyPlayer
from Othello import Othello
from Player import playGame
from HumanPlayer import HumanPlayer
from pybrain.tools.customxml.networkreader import NetworkReader
from TacticalPlayer import TacticalPlayer
import random
import time
nn = NetworkReader.readFrom("othelloNetwork.xml")
player1 = SmartPlayer(nn,8) #change this to change the opponent to be testing against
player2 = RandomPlayer()
othello = Othello()
othello.resetGame()
player1.newGame(othello,random.choice([othello.WHITE_PLAYER,othello.BLACK_PLAYER]))
player2.newGame(othello,player1.enemy)
while not othello.isGameOver():
if (player1.color == othello.WHITE_PLAYER):
print "Neural Network is white"
else:
print "Neural Network is black"
othello.printBoard()
time.sleep(1)
if (othello.whoGoesNext() == player1.color):
move = player1.getMove()
othello.makeMove(move[0],move[1],player1.color)
def playVerbose(nn_black, nn_white):
continue_play = False
game = Othello()
black_player = Player(nn_black, game, True)
white_player = Player(nn_white, game, False, "pos_values")
#white_player = Player(None, game, False, "greedy")
while True:
if game.isGameOver():
break
#print score
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
#print board
print(game.game_board)
#if coninuing play
if continue_play:
if game.game_board.black_turn:
black_player.makeMove()
else:
white_player.makeMove()
#if not coninuing play
else:
#print turn
if game.game_board.black_turn:
print("Black's Turn")
else:
print("White's Turn")
rand = None
#print valid moves
if game.game_board.black_turn:
print("Black's Turn")
print("Valid Moves: {}").format(game.validMovesStringify())
for k, v in black_player.getNNInputs().items():
print("{}: {}").format(game.validMoveStringify(k), black_player.nn.getValue(np.matrix(v)))
else:
print("White's Turn")
# print("Valid Moves: {}").format(game.validMovesStringify())
# rand = random.randrange(0, len(game.game_board.valid_moves.keys()))
# print("Random index: {}").format(rand)
print("Valid Moves: {}").format(game.validMovesStringify())
for k, v in black_player.getNNInputs().items():
print("{}: {}").format(game.validMoveStringify(k), black_player.nn.getValue(np.matrix(v)))
command = raw_input("n to next (default), c to play game, q to quit: ")
if command == "n" or command == "":
if game.game_board.black_turn:
black_player.makeMove()
else:
white_player.makeMove(rand)
elif command == "c":
continue_play = True
if game.game_board.black_turn:
black_player.makeMove()
else:
white_player.makeMove(rand)
elif command == "q":
break
else:
print("not a valid command, try again")
print("\n==========================================================\n")
#Game Over
print("Black - {}\tWhite - {}").format(game.black_score, game.white_score)
print(game.game_board)
#Check score
if(game.black_score > game.white_score):
print("Black Wins!")
elif(game.black_score < game.white_score):
print("White Wins!")
elif(game.black_score == game.white_score):
print("It's a tie!")
def minimax_a_b_p(self,
boardObj,
maximizingPlayer,
alpha=-math.inf,
beta=math.inf,
depth=0):
""" recursion, finds the best move based on the heuristic of the board """
if depth == 0 or boardObj.Game_Finish():
return boardObj # .Heuristic(self.player,self.enemy)
if maximizingPlayer:
maxEval = Othello()
maxEval.setHeuristic(-math.inf)
test = self.posibleMoves(boardObj, self.player)
if test == []:
return boardObj
for child in test:
evalBoard = self.minimax_a_b_p(child,
False,
alpha=alpha,
beta=beta,
depth=depth - 1)
if maxEval.Heuristic(self.player,
self.enemy) < evalBoard.Heuristic(
self.player, self.enemy):
maxEval = evalBoard
alpha = max(alpha, evalBoard.Heuristic(self.player,
self.enemy))
if beta <= alpha:
break
return maxEval
else:
minEval = Othello()
minEval.setHeuristic(math.inf)
test = self.posibleMoves(boardObj, self.enemy)
if test == []:
return boardObj
for child in test:
evalBoard = self.minimax_a_b_p(child,
True,
alpha=alpha,
beta=beta,
depth=depth - 1)
if minEval.Heuristic(self.player,
self.enemy) > evalBoard.Heuristic(
self.player, self.enemy):
minEval = evalBoard
beta = min(beta, evalBoard.Heuristic(self.player, self.enemy))
if beta <= alpha:
break
return minEval
def get_play_data(agent_1, agent_2):
othello = Othello()
first_states = deque()
first_rewards = deque()
first_actions = deque()
second_states = deque()
second_rewards = deque()
second_actions = deque()
board, changeable_Pos, Position_Row, Position_Col, Change_Position, done = othello.make(
)
while not done:
if othello.color == 1:
state = getState(board, changeable_Pos, Position_Row, Position_Col,
Change_Position)
first_states.appendleft(state)
reward_1, reward_2 = getReward(board)
first_rewards.appendleft(reward_1)
setrow, setcol = agent_1.take_action(board, changeable_Pos,
Position_Row, Position_Col,
Change_Position)
board, changeable_Pos, Position_Row, Position_Col, Change_Position, done = othello.step(
setrow, setcol)
first_actions.appendleft(8 * setrow + setcol)
else:
state = getState(board, changeable_Pos, Position_Row, Position_Col,
Change_Position)
second_states.appendleft(state)
reward_1, reward_2 = getReward(board)
second_rewards.appendleft(reward_2)
setrow, setcol = agent_2.take_action(board, changeable_Pos,
Position_Row, Position_Col,
Change_Position)
board, changeable_Pos, Position_Row, Position_Col, Change_Position, done = othello.step(
setrow, setcol)
second_actions.appendleft(8 * setrow + setcol)
state = getState(board, changeable_Pos, Position_Row, Position_Col,
Change_Position)
reward_1, reward_2 = getReward(board)
first_states.appendleft(state)
second_states.appendleft(state)
first_states = torch.FloatTensor(first_states)
second_states = torch.FloatTensor(second_states)
first_actions = torch.FloatTensor(first_actions)
second_actions = torch.FloatTensor(second_actions)
first_rewards.appendleft(reward_1)
second_rewards.appendleft(reward_2)
first_rewards = torch.FloatTensor(list(first_rewards)[:-1])
second_rewards = torch.FloatTensor(list(second_rewards)[:-1])
discount_rate = 1
if reward_1 > reward_2:
first_values = torch.FloatTensor(
[discount_rate**i for i in range(len(first_rewards))])
second_values = torch.FloatTensor(
[-discount_rate**i for i in range(len(second_rewards))])
elif reward_1 < reward_2:
first_values = torch.FloatTensor(
[-discount_rate**i for i in range(len(first_rewards))])
second_values = torch.FloatTensor(
[discount_rate**i for i in range(len(second_rewards))])
else:
first_values = torch.FloatTensor(
[0 for i in range(len(first_rewards))])
second_values = torch.FloatTensor(
[0 for i in range(len(second_rewards))])
data_first = {
'states': first_states,
'rewards': first_rewards,
'actions': first_actions,
'values': first_values,
}
data_secound = {
'states': second_states,
'rewards': second_rewards,
'actions': second_actions,
'values': second_values,
}
return data_first, data_secound
def __init__(self, input_data):
'''
Initializes the GUI board and the Othello model
'''
# store input data
num_rows = input_data.get_num_rows()
num_cols = input_data.get_num_cols()
self._next_player = input_data.get_first_player()
top_left_color = input_data.get_top_left_color()
self._who_wins = input_data.get_who_wins()
# set up the GUI: Canvas and labels
self._root_window = tkinter.Tk()
self._root_window.title("Othello - FULL")
self._board = Board(num_rows, num_cols)
self._board_width, self._board_height = self.board_size(
num_rows, num_cols)
self._canvas = tkinter.Canvas(master=self._root_window,
width=self._board_width,
height=self._board_height,
background=_BACKGROUND_COLOR)
self._canvas.grid(row=0,
column=0,
padx=2,
pady=2,
sticky=tkinter.N + tkinter.S + tkinter.E + tkinter.W)
self._next_turn = tkinter.StringVar()
self._turn_label = tkinter.Label(master=self._root_window,
textvariable=self._next_turn,
font=_DEFAULT_FONT)
self._turn_label.grid(row=1,
column=0,
padx=2,
pady=2,
sticky=tkinter.W)
self._disc_counts = tkinter.StringVar()
self._count_label = tkinter.Label(master=self._root_window,
textvariable=self._disc_counts,
font=_DEFAULT_FONT)
self._count_label.grid(row=2,
column=0,
padx=2,
pady=2,
sticky=tkinter.W)
# set up window resizing
self._root_window.columnconfigure(0, weight=1)
self._root_window.rowconfigure(0, weight=1)
# set up callback handlers for button release and configuration
self._canvas.bind('<ButtonRelease-1>', self._on_button_down)
self._canvas.bind('<Configure>', self._on_canvas_resize)
# set up Othello model
self._game_over = False
self._othello = Othello(num_rows, num_cols, self._next_player)
self._othello.setBoard(top_left_color)
self._process_next_move()
class OthelloBoardApp:
def __init__(self, input_data):
'''
Initializes the GUI board and the Othello model
'''
# store input data
num_rows = input_data.get_num_rows()
num_cols = input_data.get_num_cols()
self._next_player = input_data.get_first_player()
top_left_color = input_data.get_top_left_color()
self._who_wins = input_data.get_who_wins()
# set up the GUI: Canvas and labels
self._root_window = tkinter.Tk()
self._root_window.title("Othello - FULL")
self._board = Board(num_rows, num_cols)
self._board_width, self._board_height = self.board_size(
num_rows, num_cols)
self._canvas = tkinter.Canvas(master=self._root_window,
width=self._board_width,
height=self._board_height,
background=_BACKGROUND_COLOR)
self._canvas.grid(row=0,
column=0,
padx=2,
pady=2,
sticky=tkinter.N + tkinter.S + tkinter.E + tkinter.W)
self._next_turn = tkinter.StringVar()
self._turn_label = tkinter.Label(master=self._root_window,
textvariable=self._next_turn,
font=_DEFAULT_FONT)
self._turn_label.grid(row=1,
column=0,
padx=2,
pady=2,
sticky=tkinter.W)
self._disc_counts = tkinter.StringVar()
self._count_label = tkinter.Label(master=self._root_window,
textvariable=self._disc_counts,
font=_DEFAULT_FONT)
self._count_label.grid(row=2,
column=0,
padx=2,
pady=2,
sticky=tkinter.W)
# set up window resizing
self._root_window.columnconfigure(0, weight=1)
self._root_window.rowconfigure(0, weight=1)
# set up callback handlers for button release and configuration
self._canvas.bind('<ButtonRelease-1>', self._on_button_down)
self._canvas.bind('<Configure>', self._on_canvas_resize)
# set up Othello model
self._game_over = False
self._othello = Othello(num_rows, num_cols, self._next_player)
self._othello.setBoard(top_left_color)
self._process_next_move()
def run(self) -> None:
'''
Runs the Othello application taking user inputs
'''
self._root_window.mainloop()
def board_size(self, num_rows, num_cols) -> (int, int):
'''
Returns the size of the board in pixel units
Draws bigger cells when number of columns is less than 4
so that the complete title of the window is displayed.
'''
if (num_cols == 4):
return (num_cols * 70, num_rows * 70)
else:
return (num_cols * 50, num_rows * 50)
def _on_button_down(self, event: tkinter.Event):
'''
Event handler for left mouse button release event
'''
if self._game_over == False:
canvas = event.widget
x = canvas.canvasx(event.x)
y = canvas.canvasy(event.y)
#print ((event.x, event.y), (x,y))
player_input = self._board.cell_location(
point.from_pixel(x, y, self._board_width, self._board_height))
try:
if self._othello._validateInput(player_input,
self._next_player):
self._othello.updateBoard(player_input, self._next_player)
self._process_next_move()
except InvalidMoveError:
pass # nothing to do if invalid move
def _process_next_move(self):
'''
Processes the next move by calling the Othello model.
Called after initial board set up and after every uesr selection
'''
#self.printBoard()
self._draw_board(self._othello.getBoard())
if self._othello.continuePlaying(): # game still continuing
self._next_player = self._othello.getNextPlayer()
self._next_turn.set('Next Turn: ' +
self.display_color(self._next_player))
else: # game over. determine and print winner
self._game_over = True
self._next_turn.set("WINNER: " + self._winner())
# set the tile count for both ongoing or end game
num_tiles = self._othello.determineNumberTiles()
self._disc_counts.set('Black: ' + str(num_tiles[_BLACK]) +
' White: ' + str(num_tiles[_WHITE]))
def _winner(self) -> str:
'''
Determines the winner by comparing the tile counts
against the winner criteria provided as input to the game.
'''
num_tiles = self._othello.determineNumberTiles()
winner = "None"
if (self._who_wins == ">"): # higher count wins
if (num_tiles[_BLACK] < num_tiles[_WHITE]):
winner = "White"
elif (num_tiles[_BLACK] > num_tiles[_WHITE]):
winner = "Black"
elif (self._who_wins == "<"): # lower count wins
if (num_tiles[_BLACK] > num_tiles[_WHITE]):
winner = "White"
elif (num_tiles[_BLACK] < num_tiles[_WHITE]):
winner = "Black"
return winner
def _on_canvas_resize(self, event: tkinter.Event):
'''
Handler for canvas resize.
Redraws the entire board with current dimensions
'''
self._canvas.delete(tkinter.ALL)
self._board_width = self._canvas.winfo_width()
self._board_height = self._canvas.winfo_height()
self._draw_board(self._othello.getBoard())
def _draw_board(self, board_info) -> None:
'''
Draw the Othello game board
First draws the vertical and horizontal grid lines on the canvas
Then draws the currently available black and white discs from the Othello model
'''
board_size = self._board.board_size()
next_x = 0
for vert_line in range(board_size[1]):
# print((next_x,0,next_x,self._board_height))
self._canvas.create_line(next_x,
0,
next_x,
self._board_height,
fill='red',
width='2.0')
next_x = next_x + (self._board_width / board_size[1])
next_y = 0
for hor_line in range(board_size[0]):
# print((0, next_y, self._board_width, next_y,))
self._canvas.create_line(0,
next_y,
self._board_width,
next_y,
fill='red',
width='2.0')
next_y = next_y + (self._board_height / board_size[0])
for row in range(board_size[0]):
for col in range(board_size[1]):
cell = self._board.cell_from_loc(row, col)
self._draw_disc(cell, self.display_color(board_info[row][col]))
def display_color(self, color_code: str) -> str:
'''
Translates the color code understood by Othello model to readable string for GUI display
'''
if (color_code == 'W'):
return 'White'
elif (color_code == 'B'):
return 'Black'
else:
return None
def _draw_disc(self, cell: Cell, color: str) -> None:
'''
Draws the disc of the provided color in the given Cell object instance
'''
if (color != None):
disc_coords = cell.disc_coords()
top_left = disc_coords[0].pixel(self._board_width,
self._board_height)
bottom_right = disc_coords[1].pixel(self._board_width,
self._board_height)
self._canvas.create_oval(top_left[0],
top_left[1],
bottom_right[0],
bottom_right[1],
fill=color,
outline='black')
def printBoard(self):
#prints the board on console - for debug purposes only
boardInfo = self._othello.getBoard()
for row in boardInfo:
rowStr = ""
for col in row:
rowStr += col + " "
print(rowStr)
ai.append((AI(name=i)))
prev_percentage = 0
for i in range(len(winner_of_generation)):
winner_of_generation[i].set_name(i + n_ai)
ai.append(winner_of_generation[i])
score = np.zeros(len(ai), dtype='int')
print('Complete: ', end='', flush=True)
for i in range(len(ai)):
percentage = int(i / len(ai) * 100)
[
print('#', end='', flush=True)
for x in range(percentage - prev_percentage)
]
prev_percentage = percentage
for j in range((i + 1), len(ai)):
game = Othello()
winner = game.play_self(ai[i], ai[j])
score[winner.get_name()] += 1
print('| 100%')
winners = score.argsort()[-n_winners:][::-1]
ai_winners = []
for winner in winners:
ai_winners.append(ai[winner])
print('Ai-{} won {} out of {} ({:.2f}%) games.\n'.format(
winners[0], score[winners[0]],
len(ai) - 1, score[winners[0]] / (len(ai) - 1) * 100))
# Adds the best AI of this generation to the list of contenders
if ai_winners[0] not in winner_of_generation and (score[winners[0]] /
(len(ai) - 1)) > 0.625:
winner_of_generation.append(ai_winners[0])
def setup_othello(self):
othello = Othello()
return othello, othello.board
window = Window(size=[800, 800], set=False)
window.open = True
window.text_color = BLACK
window.background_color = BLACK
window.text_size = 30
#window.size=[900,20]
results = []
i = 0
number = 10000
display = False
while i < number and window.open:
i += 1
game = Othello(window, display)
game()
winner_side = (game.state + 1) % 2
results.append(winner_side)
message = "Results for " + str(
i) + " tests:\n" + "White victories: " + str(
results.count(0)) + "\n" + "Black victories: " + str(
results.count(1)) + "\n"
window.print(str(message), size=[50, 20])
window.flip()
print(message)
message = "Results for " + str(i) + " tests:\n" + "White victories: " + str(
results.count(0)) + "\n" + "Black victories: " + str(
results.count(1)) + "\n"
print(message)
current_generation_individual_group = []
for i in range(POPULATION_LIST):
current_generation_individual_group.append(
population(np.random.normal(0.0, 1.0, (GENE_COUNT))))
for generation in range(GENERATIONS):
print(count)
# オセロ盤の評価
for i in current_generation_individual_group:
for j in current_generation_individual_group:
if i == j:
continue
else:
player1 = get_player('MLP', 'P1', 'black', i.individual)
player2 = get_player('MLP', 'P2', 'white', j.individual)
FirstMove, SecondMove = Othello().play(player1, player2)
i.score += FirstMove
j.score += SecondMove
# エリート選択とルーレット選択
elite, other = select_elite(current_generation_individual_group,
RANKING)
roulette = roulette_def(other, ROULETTE)
next_list = elite + roulette
print("\n-----第 " + str(generation + 1) + " 世代の結果-----")
print(" First: " + str(elite[0].score) + " " +
str(elite[0].individual))
print(" Second: " + str(elite[1].score) + " " +
str(elite[1].individual))
print(" Third: " + str(other[0].score) + " " +
str(other[0].individual))
from Othello import Othello
from Othello import AI
import numpy as np
import matplotlib.pyplot as plt
generation = int(input('Which generation do you wish to play against:'))
w1 = np.load('weights\weight-Gen{:03d}-1.npy'.format(generation))
w2 = np.load('weights\weight-Gen{:03d}-2.npy'.format(generation))
ai = AI(weight1=w1, weight2=w2)
player = int(
input(
'Which player do you wish to be (black: -1, white: 1) (or choose another ai):'
))
game = Othello()
print(np.average(np.abs(w1)))
print(np.average(np.abs(w2)))
if player > 1:
w1 = np.load('weights\weight-Gen{:03d}-1.npy'.format(player))
w2 = np.load('weights\weight-Gen{:03d}-2.npy'.format(player))
ai2 = AI(weight1=w1, weight2=w2)
ai.set_name('Gen' + str(generation))
ai2.set_name('Gen' + str(player))
game.play_self(ai, ai2, display_board=True)
else:
game.play(ai, player)
# n, bins, patches = plt.hist(w1, 50, normed=1, facecolor='green', alpha=0.75)
# plt.show()
hiddenLayer3 = SigmoidLayer(50)
hiddenLayer4 = SigmoidLayer(50)
outLayer = SoftmaxLayer(64)
nn.addInputModule(inLayer)
nn.addOutputModule(outLayer)
nn.addModule(hiddenLayer1)
nn.addConnection(FullConnection(inLayer, hiddenLayer1, inSliceTo=16))
nn.addConnection(FullConnection(inLayer, hiddenLayer1, inSliceFrom=16, inSliceTo=32))
nn.addConnection(FullConnection(inLayer, hiddenLayer1, inSliceFrom=32, insliceTo=48))
nn.addConnection(FullConnection(inLayer, hiddenLayer1, inSliceFrom=48))
nn.addConnection(FullConnection(hiddenLayer1, outLayer))
nn.sortModules()
othello = Othello()
smartPlayer = SmartPlayer(nn,othello.boardSize)
greedyPlayer = TacticalPlayer()
greedyPlayer.newGame(othello,random.choice([othello.WHITE_PLAYER,othello.BLACK_PLAYER]));
smartPlayer.newGame(othello,greedyPlayer.enemy);
playGame(othello,greedyPlayer,smartPlayer)
if othello.getWinner() == greedyPlayer.color:
outcome = -1
print "Tactical Player wins over Network Player 5"
count += 1
semicount += 1
elif othello.getWinner() == smartPlayer.color:
outcome = 1
print "Network Player 5 wins over Tactical Player"
from warnings import filterwarnings
filterwarnings('ignore')
#from GameVision import OthelloGame
from GameVision import OthelloGame
from Othello import Othello
sys.path.insert(0,
os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from RL.rule_agent import randomAgent, greedyAgent
from RL.DQN_agent import agent as dqn_agent
from RL.A2C_agent import agent as A2C_agent
if __name__ == "__main__":
game = OthelloGame()
othello = Othello()
game.main()
random_agent = randomAgent()
greedy_agent = greedyAgent()
agent_1 = A2C_agent(input_dim=3, lam=0.8, gamma=0.99, lr=1e-4)
param = torch.load('a2c_1_param2.pt')
agent_1.model.load_state_dict(param)
agent_2 = A2C_agent(input_dim=3, lam=0.8, gamma=0.99, lr=1e-4)
param = torch.load('a2c_2_param2.pt')
agent_2.model.load_state_dict(param)
while (1):
for event in pygame.event.get():
def PlayGame():
verbose1 = False
# verbose1 = True
verbose2 = False
# verbose2 = True
Wtotalwin = 0
Btotalwin = 0
testtime = 1
nowtime = 0
while( nowtime < testtime ):
#8x8のオセロのゲームを生成する
game = Othello(8)
#まだ打てる手があるならゲームを続ける
while(game.GetCanMove() != []):
if verbose1 :
print repr(game)
print 'Can->'+str(game.GetCanMove())
#使えるAI
# MCTS(rootgame=game, times=100, verbose=False)
# MC(rootgame=game, times=100, verbose=False)
# ScoreMax(gmae)
# ProbabilitySelect(game)
# Less_chance(game)
# RandAI(game)
if game.lastMoved == 'B':
# white 白のAI
m = MC(game, 100, False)
if verbose1 : print "W",
else:
# black 黒のAI
m = RandAI(game)
if verbose1 : print "B",
game.DoMove(m)
if verbose1 : print "Do-> "+str(m)+"\n"
#勝敗の表示
if game.GetScore(game.lastMoved) == 1.0:
print str(game.lastMoved) + " win"
if game.lastMoved == 'W':
Wtotalwin+=1
else:
Btotalwin+=1
elif game.GetScore(game.lastMoved) == 0.0:
print str(game.GetOpponent(game.lastMoved)) + " win"
if game.lastMoved == 'W':
Btotalwin+=1
else:
Wtotalwin+=1
else:
print "draw"
nowtime+=1
print "--------------------"
print "White : "+str(Wtotalwin)
print "Black : "+str(Btotalwin)
