From d311af01feb32550aaae8638d4cc167948f5464c Mon Sep 17 00:00:00 2001 From: Matt Strapp Date: Mon, 26 Apr 2021 10:53:43 -0500 Subject: Rebase newer branch --- Algorithm.py | 148 --------- Board.py | 78 ----- DotsNBoxes.py | 79 ----- Nodes.py | 18 -- python/GameState.py | 144 +++++++++ python/MCTS.py | 151 +++++++++ python/agent.py | 55 ++++ python/alphaBeta.py | 30 ++ python/ann.py | 170 ++++++++++ python/board.py | 110 +++++++ python/dataStructures.py | 32 ++ python/dotsandboxes/README.md | 134 ++++++++ python/dotsandboxes/dotsandboxesagent | 5 + python/dotsandboxes/dotsandboxesagent.py | 213 +++++++++++++ python/dotsandboxes/dotsandboxescompete.py | 212 +++++++++++++ python/dotsandboxes/dotsandboxesserver.py | 60 ++++ python/dotsandboxes/requirements.txt | 1 + python/dotsandboxes/static/dotsandboxes.css | 10 + python/dotsandboxes/static/dotsandboxes.html | 56 ++++ python/dotsandboxes/static/dotsandboxes.js | 454 +++++++++++++++++++++++++++ python/evaluate.py | 240 ++++++++++++++ python/start.sh | 7 + runnable_agent/Agent.jar | Bin 0 -> 531380 bytes runnable_agent/dotsandboxesagent | 3 + runnable_agent/final_ann | Bin 0 -> 2712 bytes sandbox/game.py | 282 ----------------- sandbox/pics/A.png | Bin 409 -> 0 bytes sandbox/pics/B.png | Bin 359 -> 0 bytes sandbox/pics/X.png | Bin 453 -> 0 bytes sandbox/pics/block.png | Bin 109 -> 0 bytes sandbox/pics/empty.png | Bin 145 -> 0 bytes sandbox/pics/lineX.png | Bin 110 -> 0 bytes sandbox/pics/lineXempty.png | Bin 133 -> 0 bytes sandbox/pics/lineY.png | Bin 110 -> 0 bytes sandbox/pics/lineYempty.png | Bin 127 -> 0 bytes 35 files changed, 2087 insertions(+), 605 deletions(-) delete mode 100644 Algorithm.py delete mode 100644 Board.py delete mode 100644 DotsNBoxes.py delete mode 100644 Nodes.py create mode 100644 python/GameState.py create mode 100644 python/MCTS.py create mode 100644 python/agent.py create mode 100644 python/alphaBeta.py create mode 100644 python/ann.py create mode 100644 python/board.py create mode 100644 python/dataStructures.py create mode 100644 python/dotsandboxes/README.md create mode 100755 python/dotsandboxes/dotsandboxesagent create mode 100644 python/dotsandboxes/dotsandboxesagent.py create mode 100644 python/dotsandboxes/dotsandboxescompete.py create mode 100644 python/dotsandboxes/dotsandboxesserver.py create mode 100644 python/dotsandboxes/requirements.txt create mode 100644 python/dotsandboxes/static/dotsandboxes.css create mode 100644 python/dotsandboxes/static/dotsandboxes.html create mode 100644 python/dotsandboxes/static/dotsandboxes.js create mode 100644 python/evaluate.py create mode 100755 python/start.sh create mode 100644 runnable_agent/Agent.jar create mode 100644 runnable_agent/dotsandboxesagent create mode 100644 runnable_agent/final_ann delete mode 100644 sandbox/game.py delete mode 100644 sandbox/pics/A.png delete mode 100644 sandbox/pics/B.png delete mode 100644 sandbox/pics/X.png delete mode 100644 sandbox/pics/block.png delete mode 100644 sandbox/pics/empty.png delete mode 100644 sandbox/pics/lineX.png delete mode 100644 sandbox/pics/lineXempty.png delete mode 100644 sandbox/pics/lineY.png delete mode 100644 sandbox/pics/lineYempty.png diff --git a/Algorithm.py b/Algorithm.py deleted file mode 100644 index 99488a8..0000000 --- a/Algorithm.py +++ /dev/null @@ -1,148 +0,0 @@ -# import MCTS -import math -from copy import deepcopy -from time import clock -from random import choice - -from GameState import GameState - -class Algo: # A class for defining algorithms used (minimax and alpha-beta pruning) - - def miniMax(State, Ply_num): # Function for the minimax algorithm - - for i in range(State.Current.dimY): - for j in range(State.Current.dimX): - if State.Current.Mat[i][j] == ' ' and (j, i) not in State.children: - State.Make(j, i, True) - if Ply_num < 2: - return (i, j) - - Minimum_Score = 1000 - i = 0 - - - j = 0 - for k, z in State.children.items(): - Result = Algo.Maximum(z, Ply_num - 1, Minimum_Score) - if Minimum_Score > Result: - Minimum_Score = Result - i = k[0] - j = k[1] - - return (i, j) - - - def Maximum(State, Ply_num, Alpha): # Alpha-beta pruning function for taking care of Alpha values - if Ply_num == 0: - return State.CurrentScore - - for i in range(State.Current.dimY): - for j in range(State.Current.dimX): - if State.Current.Mat[i][j] == ' ' and (j, i) not in State.children: - State.Make(j, i, False) - - Maximum_Score = -1000 - i = 0 - j = 0 - for k, z in State.children.items(): - Result = Algo.Minimum(z, Ply_num - 1, Maximum_Score) - if Maximum_Score < Result: - Maximum_Score = Result - if Result > Alpha: - return Result - - return Maximum_Score - - - def Minimum(State, Ply_num, Beta): # Alpha-beta pruning function for taking care of Beta values - if Ply_num == 0: - return State.CurrentScore - - for i in range(State.Current.dimY): - for j in range(State.Current.dimX): - if State.Current.Mat[i][j] == ' ' and (j, i) not in State.children: - State.Make(j, i, True) - - Minimum_Score = 1000 - i = 0 - j = 0 - for k, z in State.children.items(): - Result = Algo.Maximum(z, Ply_num - 1, Minimum_Score) - if Minimum_Score > Result: - Minimum_Score = Result - if Result < Beta: - return Result - - return Minimum_Score - -# class MCTSNode(object): -# """Monte Carlo Tree Node. -# Each node encapsulates a particular game state, the moves that -# are possible from that state and the strategic information accumulated -# by the tree search as it progressively samples the game space. -# """ - -# def __init__(self, state, parent=None, move=None): -# self.parent = parent -# self.move = move -# self.state = state - -# self.plays = 0 -# self.score = 0 - -# self.pending_moves = state.get_moves() -# self.children = [] - -# def select_child_ucb(self): -# # Note that each node's plays count is equal -# # to the sum of its children's plays -# def ucb(child): -# win_ratio = child.score / child.plays \ -# + math.sqrt(2 * math.log(self.plays) / child.plays) -# return win_ratio - -# return max(self.children, key=ucb) - -# def expand_move(self, move): -# self.pending_moves.remove(move) # raises KeyError - -# child_state = deepcopy(self.state) -# child_state.play_move(move) - -# child = MCTSNode(state=child_state, parent=self, move=move) -# self.children.append(child) -# return child - -# def get_score(self, result): -# # return result -# if result == 0.5: -# return result - -# if self.state.player == 2: -# if self.state.next_turn_player == result: -# return 0.0 -# else: -# return 1.0 -# else: -# if self.state.next_turn_player == result: -# return 1.0 -# else: -# return 0.0 - -# if self.state.next_turn_player == result: -# return 0.0 -# else: -# return 1.0 - -# def __repr__(self): -# s = 'ROOT\n' if self.parent is None else '' - -# children_moves = [c.move for c in self.children] - -# s += """Score ratio: {score} / {plays} -# Pending moves: {pending_moves} -# Children's moves: {children_moves} -# State: -# {state}\n""".format(children_moves=children_moves, **self.__dict__) - -# return s \ No newline at end of file diff --git a/Board.py b/Board.py deleted file mode 100644 index 405ec23..0000000 --- a/Board.py +++ /dev/null @@ -1,78 +0,0 @@ -from random import * - - -class Game: #A class for managing different situations and states happening in the game and on the board - def __init__(self, Mat, dimX, dimY): - self.Mat = Mat - self.dimX = dimX - self.dimY = dimY - - def Initiate(self): #initiating the game board with X and Y dimensions - for i in range(0, self.dimY): - R = [] - for j in range (0, self.dimX): - if i % 2 == 1 and j % 2 == 1: - R.append(1) # Assigning a random number from 1 to 9 to the spots in the board as the points - elif i % 2 == 0 and j % 2 == 0: - R.append('*') # printing asterisks as the dots in the board - else: - R.append(' ') # adding extra space for actions in the game - self.Mat.append(R) - - def Get_matrix(self): # Board matrix - ans = [] - for i in range(0, self.dimY): - R = [] - for j in range(0, self.dimX): - R.append(self.Mat[i][j]) - ans.append(R) - return ans - - def Draw_mat(self): # Drawing the board marix as dots and lines - - if self.dimX > 9: - print(" ", end='') - print(" ", end='') - for i in range(0, self.dimX): - print(str(i), end=' ') - print() - - if self.dimX > 9: - print(" ", end='') - print(" ", end='') - for i in range(0, self.dimX + 1): - print("___", end='') - print() - for j in range(self.dimY): - if self.dimX > 9 and j < 10: - print(" ", end='') - print(str(j) + "| ", end='') - for z in range(self.dimX): - print(str(self.Mat[j][z]), end=' ') - print() - print(" _________________________\n") - - def Get_currentState(self): - return Game(self.Get_matrix(), self.dimX, self.dimY) - - def action(self, i, j): # Applying the actions made by the human or the computer - Sum = 0 - - if j % 2 == 0 and i % 2 == 1: - self.Mat[j][i] = '-' - if j < self.dimY - 1: - if self.Mat[j+2][i] == '-' and self.Mat[j+1][i+1] == '|' and self.Mat[j+1][i-1] == '|': - Sum += self.Mat[j+1][i] - if j > 0: - if self.Mat[j-2][i] == '-' and self.Mat[j-1][i+1] == '|' and self.Mat[j-1][i-1] == '|': - Sum += self.Mat[j-1][i] - - else: - self.Mat[j][i] = '|' - if i < self.dimX - 1: - if self.Mat[j][i+2] == '|' and self.Mat[j+1][i+1] == '-' and self.Mat[j-1][i+1] == '-': - Sum += self.Mat[j][i+1] - if i > 0: - if self.Mat[j][i-2] == '|' and self.Mat[j+1][i-1] == '-' and self.Mat[j-1][i-1] == '-': - Sum += self.Mat[j][i-1] - return Sum \ No newline at end of file diff --git a/DotsNBoxes.py b/DotsNBoxes.py deleted file mode 100644 index 14cdd2a..0000000 --- a/DotsNBoxes.py +++ /dev/null @@ -1,79 +0,0 @@ -from random import * -import collections -from Algorithm import * -from Board import * -from Nodes import * -import MCTS - - -class DotsNBoxes: # A class for managing the moves made by the human and the computer - def __init__(self, Board_Xdim, Board_Ydim, Ply_num): - currentState = Game([], Board_Xdim, Board_Ydim) - currentState.Initiate() - self.State = Thing(currentState) - self.Ply_num = Ply_num - self.Score = 0 - - def Human(self): # Defining the Human player and his actions/Choices - self.State.Draw() - - # HumanX = int(input("Please enter the 'X' coordinate of your choice (an integer such as 4): ")) - # HumanY = int(input("Please enter the 'Y' coordinate of your choice (an integer such as 4): ")) - # if (HumanX, HumanY) not in self.State.children: - # self.State.Make(HumanX, HumanY, False) - # self.State = self.State.children[(HumanX, HumanY)] - - # else: - # self.State = self.State.children[(HumanX, HumanY)] - - move = Algo.miniMax(self.State, 2) - - self.State = self.State.children[(move[0], move[1])] - - print("AI1 selected the following coordinates to play:\n" + "(" ,str(move[0]), ", " + str(move[1]), ")", end = "\n\n") - - print("Current Score =====>> Your Score - AI Score = " + str(self.State.CurrentScore), end = "\n\n\n") - - if len(self.State.children) == 0: - self.State.Draw() - self.Evaluation() - return - - self.Computer() - - - def Computer(self): # Defining the Computer player and its actions/Choices - self.State.Draw() - - # Temporarily commented out. TODO hardcore MCTS into working then alternate comments lol - move = Algo.miniMax(self.State, 3) - self.State = self.State.children[(move[0], move[1])] - - # move = MCTS.MCTSGameController() # check what MCTSGameController returns? - - - print("AI2 selected the following coordinates to play:\n" + "(" ,str(move[0]), ", " + str(move[1]), ")", end = "\n\n") - - print("Current Score =====>> Your Score - AI Score = " + str(self.State.CurrentScore), end = "\n\n\n") - - if len(self.State.children) == 0: - self.State.Draw() - self.Evaluation() - return - - self.Human() - - def Evaluation(self): # Evaluation function for taking care of the final scores - print("Stop this Madness!!!\n") - if self.State.CurrentScore > 0: - print("You won you crazy little unicorn!! You are the new hope for the mankind!" + str(self.State.CurrentScore)) - exit() - elif self.State.CurrentScore < 0: - print("!!! Inevitable Doom!!! You were crushed by the AI!! "+ str(self.State.CurrentScore)) - exit() - else: - print("Draw! Well Congratulations! you are as smart as the AI!") - exit() - - def start(self): - self.Human() \ No newline at end of file diff --git a/Nodes.py b/Nodes.py deleted file mode 100644 index 51a256b..0000000 --- a/Nodes.py +++ /dev/null @@ -1,18 +0,0 @@ -class Thing: # A class for Node related operations - def __init__(self, currentState): - self.Current = currentState - self.CurrentScore = 0 - self.children = {} - - def Make(self, i, j, player): # Function for generating a child node - self.children[(i, j)] = Thing(self.Current.Get_currentState()) - mul = 1 - if player: - mul *= -1 - self.children[(i, j)].CurrentScore = (self.children[(i, j)].Current.action(i, j) * mul) + self.CurrentScore - - def Populate(self, i, j, Child): # Function for adding a node - self.children[(i,j)] = Child - - def Draw(self): # function for drawing the board - self.Current.Draw_mat() \ No newline at end of file diff --git a/python/GameState.py b/python/GameState.py new file mode 100644 index 0000000..eed8f36 --- /dev/null +++ b/python/GameState.py @@ -0,0 +1,144 @@ +from random import choice + +# Based on https://github.com/DieterBuys/mcts-player/ + +class GameState(object): + + def __init__(self): + self.next_turn_player = 1 + self.player = None + + @property + def game_result(self): + return None + + def get_moves(self): + return set() + + def get_random_move(self): + moves = self.get_moves() + return choice(tuple(moves)) if moves != set() else None + + def play_move(self, move): + pass + + +class DotsAndBoxesState(GameState): + def __init__(self, nb_rows, nb_cols, player): + super(DotsAndBoxesState, self).__init__() + + self.nb_rows = nb_rows + self.nb_cols = nb_cols + rows = [] + for ri in range(nb_rows + 1): + columns = [] + for ci in range(nb_cols + 1): + columns.append({"v": 0, "h": 0}) + rows.append(columns) + self.board = rows + + self.score = {1: 0, 2: 0} + self.player = player + print("Player: ", player) + + @property + def game_result(self): + def game_decided(nb_cols, nb_rows, scoreP, scoreO): + # the game is decided if the winner is already known even before the game is ended + # you're guaranteed to win the game if you have more than halve of the total points that can be earned + total_points = nb_rows * nb_cols + if scoreP > total_points // 2 or scoreO > total_points // 2: + return True + else: + return False + + # check if the board is full, then decide based on score + free_lines = self.get_moves() + player = self.player + opponent = self.player % 2 + 1 + + if not game_decided(self.nb_cols, self.nb_rows, self.score[player], self.score[opponent]) and len(free_lines) > 0: + return None + elif self.score[player] > self.score[opponent]: + return 1 + elif self.score[player] < self.score[opponent]: + return 0 + else: + return 0.5 + + def get_moves(self): + free_lines = [] + for ri in range(len(self.board)): + row = self.board[ri] + for ci in range(len(row)): + cell = row[ci] + if ri < (len(self.board) - 1) and cell["v"] == 0: + free_lines.append((ri, ci, "v")) + if ci < (len(row) - 1) and cell["h"] == 0: + free_lines.append((ri, ci, "h")) + return set(free_lines) + + def play_move(self, move): + r, c, o = move + assert move in self.get_moves() + + # check if this move makes a box + makes_box = False + if o == "h": + if r - 1 >= 0: + # check above + if self.board[r-1][c]["h"] != 0 and self.board[r-1][c]["v"] != 0 and self.board[r-1][c+1]["v"] != 0: + makes_box = True + self.score[self.next_turn_player] += 1 + if r + 1 <= self.nb_rows: + # check below + if self.board[r+1][c]["h"] != 0 and self.board[r][c]["v"] != 0 and self.board[r][c+1]["v"] != 0: + makes_box = True + self.score[self.next_turn_player] += 1 + + elif o == "v": + if c - 1 >= 0: + # check left + if self.board[r][c-1]["v"] != 0 and self.board[r][c-1]["h"] != 0 and self.board[r+1][c-1]["h"] != 0: + makes_box = True + self.score[self.next_turn_player] += 1 + + if c + 1 <= self.nb_cols: + # check right + if self.board[r][c+1]["v"] != 0 and self.board[r][c]["h"] != 0 and self.board[r+1][c]["h"] != 0: + makes_box = True + self.score[self.next_turn_player] += 1 + + + # register move + self.board[r][c][o] = self.next_turn_player + + if not makes_box: + # switch turns + self.next_turn_player = self.next_turn_player % 2 + 1 + + def __repr__(self): + str = "" + for r in range(self.nb_rows + 1): + for o in ["h", "v"]: + for c in range(self.nb_cols + 1): + if o == "h": + str += "." + if c != self.nb_cols: + if self.board[r][c][o] == 0: + str += " " + else: + str += "__" + else: + str += "\n" + elif o == "v": + if r != self.nb_rows: + if self.board[r][c][o] == 0: + str += " " + else: + str += "|" + if c != self.nb_cols: + str += " " + else: + str += "\n" + return str diff --git a/python/MCTS.py b/python/MCTS.py new file mode 100644 index 0000000..a65e2d4 --- /dev/null +++ b/python/MCTS.py @@ -0,0 +1,151 @@ +import math +from copy import deepcopy +from time import clock +from random import choice + +from GameState import GameState + +# Based on https://github.com/DieterBuys/mcts-player/ + +class GameController(object): + def get_next_move(self, state): + # when you get a new move, it is assumed that the game is not ended yet + assert state.get_moves() + + +class MCTSNode(object): + """Monte Carlo Tree Node. + Each node encapsulates a particular game state, the moves that + are possible from that state and the strategic information accumulated + by the tree search as it progressively samples the game space. + """ + + def __init__(self, state, parent=None, move=None): + self.parent = parent + self.move = move + self.state = state + + self.plays = 0 + self.score = 0 + + self.pending_moves = state.get_moves() + self.children = [] + + def select_child_ucb(self): + # Note that each node's plays count is equal + # to the sum of its children's plays + def ucb(child): + win_ratio = child.score / child.plays \ + + math.sqrt(2 * math.log(self.plays) / child.plays) + return win_ratio + + return max(self.children, key=ucb) + + def expand_move(self, move): + self.pending_moves.remove(move) # raises KeyError + + child_state = deepcopy(self.state) + child_state.play_move(move) + + child = MCTSNode(state=child_state, parent=self, move=move) + self.children.append(child) + return child + + def get_score(self, result): + # return result + if result == 0.5: + return result + + if self.state.player == 2: + if self.state.next_turn_player == result: + return 0.0 + else: + return 1.0 + else: + if self.state.next_turn_player == result: + return 1.0 + else: + return 0.0 + + if self.state.next_turn_player == result: + return 0.0 + else: + return 1.0 + + def __repr__(self): + s = 'ROOT\n' if self.parent is None else '' + + children_moves = [c.move for c in self.children] + + s += """Score ratio: {score} / {plays} +Pending moves: {pending_moves} +Children's moves: {children_moves} +State: +{state}\n""".format(children_moves=children_moves, **self.__dict__) + + return s + + +class MCTSGameController(GameController): + """Game controller that uses MCTS to determine the next move. + This is the class which implements the Monte Carlo Tree Search algorithm. + It builds a game tree of MCTSNodes and samples the game space until a set + time has elapsed. + """ + + def select(self): + node = self.root_node + + # Descend until we find a node that has pending moves, or is terminal + while node.pending_moves == set() and node.children != []: + node = node.select_child_ucb() + + return node + + def expand(self, node): + assert node.pending_moves != set() + + move = choice(tuple(node.pending_moves)) + return node.expand_move(move) + + def simulate(self, state, max_iterations=1000): + state = deepcopy(state) + + move = state.get_random_move() + while move is not None: + state.play_move(move) + move = state.get_random_move() + + max_iterations -= 1 + if max_iterations <= 0: + return 0.5 # raise exception? (game too deep to simulate) + + return state.game_result + + def update(self, node, result): + while node is not None: + node.plays += 1 + node.score += node.get_score(result) + node = node.parent + + def get_next_move(self, state, time_allowed=1.0): + super(MCTSGameController, self).get_next_move(state) + + # Create new tree (TODO: Preserve some state for better performance?) + self.root_node = MCTSNode(state) + iterations = 0 + + start_time = clock() + while clock() < start_time + time_allowed: + node = self.select() + + if node.pending_moves != set(): + node = self.expand(node) + + result = self.simulate(node.state) + self.update(node, result) + + iterations += 1 + + # Return most visited node's move + return max(self.root_node.children, key=lambda n: n.plays).move diff --git a/python/agent.py b/python/agent.py new file mode 100644 index 0000000..49bc1cc --- /dev/null +++ b/python/agent.py @@ -0,0 +1,55 @@ +import dotsandboxes.dotsandboxesagent as dba + +import sys +import argparse +import logging +from GameState import GameState, DotsAndBoxesState +from MCTS import MCTSNode, MCTSGameController + + +logger = logging.getLogger(__name__) +games = {} +agentclass = None + + +class Agent(dba.DotsAndBoxesAgent): + def __init__(self, player, nb_rows, nb_cols, timelimit): + super(Agent, self).__init__(player, nb_rows, nb_cols, timelimit) + self.GameStateClass = DotsAndBoxesState + self.game_state = self.GameStateClass(nb_rows, nb_cols, player) + self.controller = MCTSGameController() + + def register_action(self, row, column, orientation, player): + super(Agent, self).register_action(row, column, orientation, player) + # adjust agent specific board representation + move = (row, column, orientation) + self.game_state.play_move(move) + + def next_action(self): + r, c, o = self.controller.get_next_move(self.game_state, time_allowed=self.timelimit) + return r, c, o + + def end_game(self): + super(Agent, self).end_game() + + +# Adapted from provided code +def main(argv=None): + global agentclass + parser = argparse.ArgumentParser(description='Start agent to play Dots and Boxes') + parser.add_argument('--verbose', '-v', action='count', default=0, help='Verbose output') + parser.add_argument('--quiet', '-q', action='count', default=0, help='Quiet output') + parser.add_argument('port', metavar='PORT', type=int, help='Port to use for server') + args = parser.parse_args(argv) + + logger.setLevel(max(logging.INFO - 10 * (args.verbose - args.quiet), logging.DEBUG)) + logger.addHandler(logging.StreamHandler(sys.stdout)) + + agentclass = Agent + dba.agentclass = Agent + dba.start_server(args.port) + + +if __name__ == "__main__": + sys.exit(main()) + diff --git a/python/alphaBeta.py b/python/alphaBeta.py new file mode 100644 index 0000000..01f82cf --- /dev/null +++ b/python/alphaBeta.py @@ -0,0 +1,30 @@ + +def alpha_beta(node, alpha, beta): + + # Based on https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning#Pseudocode + # node needs to support three operations: isTerminal(), value(), getChildren(), maximizingPlayer() + + if node.isTerminal(): + return node.value() + + if node.maximizingPlayer(): + + v = float("-inf") + for child in node.getChildren(): + + v = max(v, alpha_beta(child, alpha, beta)) + alpha = max(alpha, v) + if beta <= alpha: + break + + else: + + v = float("inf") + for child in node.getChildren(): + + v = min(v, alpha_beta(child, alpha, beta)) + beta = min(beta, v) + if beta <= alpha: + break + + return v diff --git a/python/ann.py b/python/ann.py new file mode 100644 index 0000000..05ae647 --- /dev/null +++ b/python/ann.py @@ -0,0 +1,170 @@ +from numpy import * +from math import sqrt +from copy import deepcopy +from time import time + +class ANN: + + """ANN with one hidden layer, one output and full connections in between consecutive layers. + Initial weights are chosen from a normal distribution. + Activation function is tanh.""" + + INIT_SIGMA = 0.02 + REL_STOP_MARGIN = 0.01 + MAX_ITERATIONS = 1000000 + ACTIVATION = tanh + D_ACTIVATION = lambda x: 1 - tanh(x)**2 # Derivative of tanh + VEC_ACTIVATION = vectorize(ACTIVATION) + VEC_D_ACTIVATION = vectorize(D_ACTIVATION) + STEP_SIZE = 0.1 + + def __init__(self, input_size, hidden_size): + + #self.input_size = input_size + #self.hidden_size = hidden_size + self.hidden_weights = random.normal(0, ANN.INIT_SIGMA, (hidden_size, input_size)) + self.output_weights = random.normal(0, ANN.INIT_SIGMA, hidden_size) + + def get_weights(self): + return self.hidden_weights, self.output_weights + + def predict(self, input_vector): + + # Predicts the output for this input vector + # input_vector will be normalized + + input_vector = input_vector/linalg.norm(input_vector) + return ANN.ACTIVATION(dot(self.output_weights, ANN.VEC_ACTIVATION(dot(self.hidden_weights, input_vector)))) + + @staticmethod + def frob_norm(a, b): + + # Calculates the total Frobenius norm of both matrices A and B + return sqrt(linalg.norm(a)**2 + linalg.norm(b)**2) + + def train(self, examples): + + #print("Training") + start = time() + + # examples is a list of (input, output)-tuples + # input will be normalized + # We stop when the weights have converged within some relative margin + + for example in examples: + example[0] = example[0]/linalg.norm(example[0]) + + iteration = 0 + while True: + + + # Store old weights to check for convergence later + prev_hidden_weights = deepcopy(self.hidden_weights) + prev_output_weights = deepcopy(self.output_weights) + + for k in range(len(examples)): + + input_vector, output = examples[k] + + # Calculate outputs + hidden_input = dot(self.hidden_weights, input_vector) + hidden_output = ANN.VEC_ACTIVATION(hidden_input) + final_input = dot(self.output_weights, hidden_output) + predicted_output = ANN.ACTIVATION(final_input) + + #print("Output:", output) + #print("Predicted output:", predicted_output) + + # Used in calculations + prediction_error = output - predicted_output + output_derivative = ANN.D_ACTIVATION(final_input) + + # Adjust output weights and calculate requested hidden change + requested_hidden_change = prediction_error*output_derivative*self.output_weights + self.output_weights = self.output_weights + ANN.STEP_SIZE*prediction_error*hidden_output + + #print("After adjusting output weights:", ANN.ACTIVATION(dot(self.output_weights, hidden_output))) + + # Backpropagate requested hidden change to adjust hidden weights + self.hidden_weights = self.hidden_weights + ANN.STEP_SIZE*outer(requested_hidden_change*(ANN.VEC_D_ACTIVATION(hidden_input)), input_vector) + + #print("After adjusting hidden weights:", ANN.ACTIVATION(dot(self.output_weights, ANN.VEC_ACTIVATION(dot(self.hidden_weights, input_vector))))) + + # Check stop criteria + iteration += 1 + if iteration >= ANN.MAX_ITERATIONS: + break + + # Check stop criteria + if iteration >= ANN.MAX_ITERATIONS: + break + diff = ANN.frob_norm(self.hidden_weights - prev_hidden_weights, self.output_weights - prev_output_weights) + base = ANN.frob_norm(self.hidden_weights, self.output_weights) + #if base > 0 and diff/base < ANN.REL_STOP_MARGIN: + # break + + print(time() - start) + print("Stopped training after %s iterations."%iteration) + +# TESTING + +def print_difference(ann1, ann2): + + # Prints the differences in weights in between two ANN's with identical topology + + hidden_weights1, output_weights1 = ann1.get_weights() + hidden_weights2, output_weights2 = ann2.get_weights() + hidden_diff = hidden_weights1 - hidden_weights2 + output_diff = output_weights1 - output_weights2 + + print(hidden_diff) + print(output_diff) + print("Frobenius norms:") + print("Hidden weights difference:", linalg.norm(hidden_diff)) + print("Output weights difference:", linalg.norm(output_diff)) + print("Both:", ANN.frob_norm(hidden_diff, output_diff)) + +def RMSE(ann, examples): + + total = 0 + for input_vector, output in examples: + total += (output - ann.predict(input_vector))**2 + return sqrt(total/len(examples)) + +def generate_examples(amount, input_size, evaluate): + # evaluate is a function mapping an input vector onto a numerical value + examples = [] + inputs = random.normal(0, 100, (amount, input_size)) + for i in range(amount): + input_vector = inputs[i] + examples.append([input_vector, evaluate(input_vector)]) + return examples + +def test(): + + # Test the ANN by having it model another ANN with identical topology but unknown weights + + input_size = 5 + hidden_size = 3 + real = ANN(input_size, hidden_size) + model = ANN(input_size, hidden_size) + + # Generate training data + training_data = generate_examples(10000, input_size, real.predict) + validation_data = generate_examples(10000, input_size, real.predict) + + # Print initial difference, train, then print new difference + print("Initial difference:") + print_difference(real, model) + print("Initial RMSE (on training data):", RMSE(model, training_data)) + print("Initial RMSE (on validation data):", RMSE(model, validation_data)) + model.train(training_data) + print("After training:") + print_difference(real, model) + print("After training RMSE (on training data):", RMSE(model, training_data)) + print("After training RMSE (on validation data):", RMSE(model, validation_data)) + +if __name__ == "__main__": + test() + + diff --git a/python/board.py b/python/board.py new file mode 100644 index 0000000..36cfe8c --- /dev/null +++ b/python/board.py @@ -0,0 +1,110 @@ +from GameState import GameState + +class Board(GameState): + + # Interface methods + + def __init__(self, nb_rows, nb_cols, player): + + # Basic initialization + self.nb_rows = nb_rows + self.nb_cols = nb_cols + self.player = player # 1 or 2 + self.scores = [0, 0, 0] + self.max_score = nb_rows*nb_cols + + # Construct edges and nodes matrix + self.edges = [] # Boolean, true means uncut + self.nodes = [] # Represents valence of nodes from strings-and-coins + for x in range(self.nb_cols): + self.edges.append([True]*self.nb_rows) + self.edges.append([True]*(self.nb_rows + 1)) + self.nodes.append([4]*self.nb_rows) + self.edges.append([True]*self.nb_rows) + + # Construct all possible moves + self.moves_left = set() # Moves are represented as ints + for x in range(len(self.edges)): + for y in range(len(self.edges[x])): + self.moves_left.add(self.coords_to_edge(x, y)) + + # TODO: chain updating + # Initialize chains + # Chains are represented as lists of nodes + self.closed_chains = [] # Chains which start and end in nodes of valence + + @property + def game_result(self): + + own_score = self.scores[self.player] + opponent_score = self.scores[self.player % 2 + 1] + if len(self.moves_left) == 0: + diff = own_score - opponent_score + if diff > 0: + return 1 + elif diff < 0: + return 0 + else: + return 0.5 + else: + # Check if one player already has at least half of all points + if own_score > self.max_score//2: + return 1 + elif opponent_score > self.max_score//2: + return 0 + else: + return None + + def get_moves(self): + return self.moves_left + + def get_random_move(self): + moves = self.get_moves() + return choice(tuple(moves)) if moves != set() else None + + def play_move(self, move): + x, y = self.edge_to_coords(move) + self.edges[x][y] = False + self.moves_left.remove(move) + + # Update valence + if x%2 == 0: + # Horizontal edge, decrease valence of left and right nodes + for node_x in x//2 - 1, x//2: + if node_x >= 0 and node_x < nb_cols: + self.nodes[node_x][y] -= 1 + else: + # Vertical edge, decrease valence of top and bottom nodes + for node_y in y - 1, y: + if node_y >= 0 and node_y < nb_rows: + self.nodes[x//2][node_y] -= 1 + + # TODO: chain updating + + # Own methods + + def undo_move(self, move): + x, y = self.edge_to_coords(move) + self.edges[x][y] = True + self.moves_left.add(move) + + # Update valence + if x%2 == 0: + # Horizontal edge, decrease valence of left and right nodes + for node_x in x//2 - 1, x//2: + if node_x >= 0 and node_x < nb_cols: + self.nodes[node_x][y] += 1 + else: + # Vertical edge, decrease valence of top and bottom nodes + for node_y in y - 1, y: + if node_y >= 0 and node_y < nb_rows: + self.nodes[x//2][node_y] += 1 + + # TODO: chain updating + + def coords_to_edge(self, x, y): + return x*(self.nb_cols + 1) + y + + def edge_to_coords(self, move): + return move//(self.nb_cols + 1), move%(self.nb_cols + 1) + diff --git a/python/dataStructures.py b/python/dataStructures.py new file mode 100644 index 0000000..1e972fc --- /dev/null +++ b/python/dataStructures.py @@ -0,0 +1,32 @@ +class DisjointSet: + def __init__(self, nbElements): + self.parent = [] + self.rank = [] + for i in range(0, nbElements): + self.parent[i] = i + self.rank[i] = 0 + + def find(self, x): + if self.parent[x] != x: + self.parent[x] = self.find(self.parent[x]) + return self.parent[x] + + def union(self, x, y): + xRoot = self.find(x) + yRoot = self.find(y) + + # x and y already belong to the same set + if xRoot == yRoot: + return + + # merge the set of x and y + if self.rank[xRoot] < self.rank[yRoot]: + self.parent[xRoot] = yRoot + elif self.rank[xRoot] > self.rank[yRoot]: + self.parent[yRoot] = xRoot + else: + self.parent[xRoot] = yRoot + self.rank[yRoot] += 1 + + def inSameSet(self, x, y): + return self.find(x) == self.find(y) \ No newline at end of file diff --git a/python/dotsandboxes/README.md b/python/dotsandboxes/README.md new file mode 100644 index 0000000..e3f844c --- /dev/null +++ b/python/dotsandboxes/README.md @@ -0,0 +1,134 @@ +Dots and Boxes application +========================== + +Live demo: https://people.cs.kuleuven.be/wannes.meert/dotsandboxes/play + +![Screenshot of Dots and Boxes](https://people.cs.kuleuven.be/wannes.meert/dotsandboxes/screenshot.png?v=2) + +This setup is part of the course "Machine Learning: Project" (KU Leuven, +Faculty of engineering, Department of Computer Science, +[DTAI research group](https://dtai.cs.kuleuven.be)). + + +Installation +------------ + +The example agent is designed for Python 3.6 and requires the +[websockets](https://websockets.readthedocs.io) package. Dependencies can be +installed using pip: + + $ pip install -r requirements.txt + + +Start the game GUI +------------------ + +This program shows a web-based GUI to play the Dots and Boxes +game. This supports human-human, agent-human and agent-agent combinations. +It is a simple Javascript based application that runs entirely in the browser. +You can start it by opening the file `static/dotsandboxes.html` in a browser. +Or alternatively, you can start the app using the included simple server: + + $ ./dotsandboxesserver.py 8080 + +The game can then be played by directing your browser to http://127.0.0.1:8080. + + +Start the agent client +---------------------- + +This is the program that runs a game-playing agent. This application listens +to [websocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) +requests that communicate game information and sends back the next action it +wants to play. + +Starting the agent client is done using the following command: + + $ ./dotsandboxesagent + +This starts a websocket on the given port that can receveive JSON messages. + +The JSON messages given below should be handled by your agent. +Take into account the maximal time allowed to reply. + +### Initiate the game + +Both players get a message that a new game has started: + + { + "type": "start", + "player": 1, + "timelimit", 0.5, + "grid": [5, 5], + "game": "123456" + } + +where `player` is the number assigned to this agent, `timelimit` is the +time in seconds in which you need to send your action back to the server, +and `grid` is the grid size in rows and columns. + +If you are player 1, reply with the first action you want to perform: + + { + "type": "action", + "location": [1, 1], + "orientation": "v" + } + +The field `location` is expressed as row and column (zero-based numbering) and +`orientation` is either "v" (vertical) or "h" (horizontal). + + +### Action in the game + +When an action is played, the message sent to both players is: + + { + "type": "action", + "game": "123456", + "player": 1, + "nextplayer": 2, + "score": [0, 0], + "location": [1, 1], + "orientation": "v" + } + + +If it is your turn you should answer with a message that states your next +move: + + { + "type": "action", + "location": [1, 1], + "orientation": "v" + } + + +### Game end + +When the game ends after an action, the message is slightly altered: + + { + "type": "end", + "game": "123456", + "player": 1, + "nextplayer": 0, + "score": [3, 1], + "location": [1, 1], + "orientation": "v", + "winner": 1 + } + +The `type` field becomes `end` and a new field `winner` is set to the player +that has won the game. + + +Contact information +------------------- + +- Wannes Meert, https://people.cs.kuleuven.be/wannes.meert +- Hendrik Blockeel, https://people.cs.kuleuven.be/hendrik.blockeel +- Arne De Brabandere, https://people.cs.kuleuven.be/arne.debrabandere +- Sebastijan Dumančić, https://people.cs.kuleuven.be/sebastijan.dumancic +- Pieter Robberechts, https://people.cs.kuleuven.be/pieter.robberechts + diff --git a/python/dotsandboxes/dotsandboxesagent b/python/dotsandboxes/dotsandboxesagent new file mode 100755 index 0000000..eecf719 --- /dev/null +++ b/python/dotsandboxes/dotsandboxesagent @@ -0,0 +1,5 @@ +#!/bin/bash +# It is not necessary to use a shell script for this. Dropping the .py +# extension and including the correct shebang is also correct. +python3 $(dirname "$0")/dotsandboxesagent.py $@ + diff --git a/python/dotsandboxes/dotsandboxesagent.py b/python/dotsandboxes/dotsandboxesagent.py new file mode 100644 index 0000000..c8bc05e --- /dev/null +++ b/python/dotsandboxes/dotsandboxesagent.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +# encoding: utf-8 +""" +dotsandboxesagent.py + +Template for the Machine Learning Project course at KU Leuven (2017-2018) +of Hendrik Blockeel and Wannes Meert. + +Copyright (c) 2018 KU Leuven. All rights reserved. +""" +import sys +import argparse +import logging +import asyncio +import websockets +import json +from collections import defaultdict +import random + + +logger = logging.getLogger(__name__) +games = {} +agentclass = None + + +class DotsAndBoxesAgent: + """Example Dots and Boxes agent implementation base class. + It returns a random next move. + + A DotsAndBoxesAgent object should implement the following methods: + - __init__ + - add_player + - register_action + - next_action + - end_game + + This class does not necessarily use the best data structures for the + approach you want to use. + """ + def __init__(self, player, nb_rows, nb_cols, timelimit): + """Create Dots and Boxes agent. + + :param player: Player number, 1 or 2 + :param nb_rows: Rows in grid + :param nb_cols: Columns in grid + :param timelimit: Maximum time allowed to send a next action. + """ + self.player = {player} + self.timelimit = timelimit + self.ended = False + self.nb_rows = nb_rows + self.nb_cols = nb_cols + rows = [] + for ri in range(nb_rows + 1): + columns = [] + for ci in range(nb_cols + 1): + columns.append({"v": 0, "h": 0}) + rows.append(columns) + self.cells = rows + + def add_player(self, player): + """Use the same agent for multiple players.""" + self.player.add(player) + + def register_action(self, row, column, orientation, player): + """Register action played in game. + + :param row: + :param columns: + :param orientation: "v" or "h" + :param player: 1 or 2 + """ + self.cells[row][column][orientation] = player + + def next_action(self): + """Return the next action this agent wants to perform. + + In this example, the function implements a random move. Replace this + function with your own approach. + + :return: (row, column, orientation) + """ + logger.info("Computing next move (grid={}x{}, player={})"\ + .format(self.nb_rows, self.nb_cols, self.player)) + # Random move + free_lines = [] + for ri in range(len(self.cells)): + row = self.cells[ri] + for ci in range(len(row)): + cell = row[ci] + if ri < (len(self.cells) - 1) and cell["v"] == 0: + free_lines.append((ri, ci, "v")) + if ci < (len(row) - 1) and cell["h"] == 0: + free_lines.append((ri, ci, "h")) + if len(free_lines) == 0: + # Board full + return None + movei = random.randint(0, len(free_lines) - 1) + r, c, o = free_lines[movei] + return r, c, o + + def end_game(self): + self.ended = True + + +## MAIN EVENT LOOP + +async def handler(websocket, path): + logger.info("Start listening") + game = None + # msg = await websocket.recv() + try: + async for msg in websocket: + logger.info("< {}".format(msg)) + try: + msg = json.loads(msg) + except json.decoder.JSONDecodeError as err: + logger.error(err) + return False + game = msg["game"] + answer = None + if msg["type"] == "start": + # Initialize game + if msg["game"] in games: + games[msg["game"]].add_player(msg["player"]) + else: + nb_rows, nb_cols = msg["grid"] + games[msg["game"]] = agentclass(msg["player"], + nb_rows, + nb_cols, + msg["timelimit"]) + if msg["player"] == 1: + # Start the game + nm = games[game].next_action() + print('nm = {}'.format(nm)) + if nm is None: + # Game over + logger.info("Game over") + continue + r, c, o = nm + answer = { + 'type': 'action', + 'location': [r, c], + 'orientation': o + } + else: + # Wait for the opponent + answer = None + + elif msg["type"] == "action": + # An action has been played + r, c = msg["location"] + o = msg["orientation"] + games[game].register_action(r, c, o, msg["player"]) + if msg["nextplayer"] in games[game].player: + # Compute your move + nm = games[game].next_action() + if nm is None: + # Game over + logger.info("Game over") + continue + nr, nc, no = nm + answer = { + 'type': 'action', + 'location': [nr, nc], + 'orientation': no + } + else: + answer = None + + elif msg["type"] == "end": + # End the game + games[msg["game"]].end_game() + answer = None + else: + logger.error("Unknown message type:\n{}".format(msg)) + + if answer is not None: + print(answer) + await websocket.send(json.dumps(answer)) + logger.info("> {}".format(answer)) + except websockets.exceptions.ConnectionClosed as err: + logger.info("Connection closed") + logger.info("Exit handler") + + +def start_server(port): + server = websockets.serve(handler, 'localhost', port) + print("Running on ws://127.0.0.1:{}".format(port)) + asyncio.get_event_loop().run_until_complete(server) + asyncio.get_event_loop().run_forever() + + +## COMMAND LINE INTERFACE + +def main(argv=None): + global agentclass + parser = argparse.ArgumentParser(description='Start agent to play Dots and Boxes') + parser.add_argument('--verbose', '-v', action='count', default=0, help='Verbose output') + parser.add_argument('--quiet', '-q', action='count', default=0, help='Quiet output') + parser.add_argument('port', metavar='PORT', type=int, help='Port to use for server') + args = parser.parse_args(argv) + + logger.setLevel(max(logging.INFO - 10 * (args.verbose - args.quiet), logging.DEBUG)) + logger.addHandler(logging.StreamHandler(sys.stdout)) + + agentclass = DotsAndBoxesAgent + start_server(args.port) + + +if __name__ == "__main__": + sys.exit(main()) + diff --git a/python/dotsandboxes/dotsandboxescompete.py b/python/dotsandboxes/dotsandboxescompete.py new file mode 100644 index 0000000..ee2aee8 --- /dev/null +++ b/python/dotsandboxes/dotsandboxescompete.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +# encoding: utf-8 +""" +dotsandboxescompete.py + +Template for the Machine Learning Project course at KU Leuven (2017-2018) +of Hendrik Blockeel and Wannes Meert. + +Copyright (c) 2018 KU Leuven. All rights reserved. +""" + +import sys +import argparse +import logging +import asyncio +import websockets +import json +from collections import defaultdict +import random +import uuid +import time + +logger = logging.getLogger(__name__) + + +def start_competition(address1, address2, nb_rows, nb_cols, timelimit): + asyncio.get_event_loop().run_until_complete(connect_agent(address1, address2, nb_rows, nb_cols, timelimit)) + + +async def connect_agent(uri1, uri2, nb_rows, nb_cols, timelimit): + cur_game = str(uuid.uuid4()) + winner = None + cells = [] + cur_player = 1 + points = [0, 0, 0] + timings = [None, [], []] + + for ri in range(nb_rows + 1): + columns = [] + for ci in range(nb_cols + 1): + columns.append({"v":0, "h":0, "p":0}) + cells.append(columns) + + logger.info("Connecting to {}".format(uri1)) + async with websockets.connect(uri1) as websocket1: + logger.info("Connecting to {}".format(uri2)) + async with websockets.connect(uri2) as websocket2: + logger.info("Connected") + + # Start game + msg = { + "type": "start", + "player": 1, + "timelimit": timelimit, + "game": cur_game, + "grid": [nb_rows, nb_cols] + } + await websocket1.send(json.dumps(msg)) + msg["player"] = 2 + await websocket2.send(json.dumps(msg)) + + # Run game + while winner is None: + ask_time = time.time() + logger.info("Waiting for player {}".format(cur_player)) + if cur_player == 1: + msg = await websocket1.recv() + else: + msg = await websocket2.recv() + recv_time = time.time() + diff_time = recv_time - ask_time + timings[cur_player].append(diff_time) + logger.info("Message received after (s): {}".format(diff_time)) + try: + msg = json.loads(msg) + except json.decoder.JSONDecodeError as err: + logger.debug(err) + continue + if msg["type"] != "action": + logger.error("Unknown message: {}".format(msg)) + continue + r, c = msg["location"] + o = msg["orientation"] + next_player = user_action(r, c, o, cur_player, + cells, points, + nb_rows, nb_cols) + if points[1] + points[2] == nb_cols * nb_rows: + # Game over + winner = 1 + if points[2] == points[1]: + winner = 0 + if points[2] > points[1]: + winner = 2 + else: + msg = { + "type": "action", + "game": cur_game, + "player": cur_player, + "nextplayer": next_player, + "score": [points[1], points[2]], + "location": [r, c], + "orientation": o + } + await websocket1.send(json.dumps(msg)) + await websocket2.send(json.dumps(msg)) + + cur_player = next_player + + # End game + logger.info("Game ended: points1={} - points2={} - winner={}".format(points[1], points[2], winner)) + msg = { + "type": "end", + "game": cur_game, + "player": cur_player, + "nextplayer": 0, + "score": [points[1], points[2]], + "location": [r, c], + "orientation": o, + "winner": winner + } + await websocket1.send(json.dumps(msg)) + await websocket2.send(json.dumps(msg)) + + # Timings + for i in [1, 2]: + logger.info("Timings: player={} - avg={} - min={} - max={}"\ + .format(i, + sum(timings[i])/len(timings[i]), + min(timings[i]), + max(timings[i]))) + + logger.info("Closed connections") + + +def user_action(r, c, o, cur_player, cells, points, nb_rows, nb_cols): + logger.info("User action: player={} - r={} - c={} - o={}".format(cur_player, r, c, o)) + next_player = cur_player + won_cell = False + cell = cells[r][c] + if o == "h": + if cell["h"] != 0: + return cur_player + cell["h"] = cur_player + # Above + if r > 0: + if cells[r - 1][c]["v"] != 0 \ + and cells[r - 1][c + 1]["v"] != 0 \ + and cells[r - 1][c]["h"] != 0 \ + and cells[r][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r - 1][c]["p"] = cur_player + # Below + if r < nb_rows: + if cells[r][c]["v"] != 0 \ + and cells[r][c + 1]["v"] != 0 \ + and cells[r][c]["h"] != 0 \ + and cells[r + 1][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c]["p"] = cur_player + + if o == "v": + if cell["v"] != 0: + return cur_player + cell["v"] = cur_player; + # Left + if c > 0: + if cells[r][c - 1]["v"] != 0 \ + and cells[r][c]["v"] != 0 \ + and cells[r][c - 1]["h"] != 0 \ + and cells[r + 1][c - 1]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c - 1]["p"] = cur_player + # Right + if c < nb_cols: + if cells[r][c]["v"] != 0 \ + and cells[r][c + 1]["v"] != 0 \ + and cells[r][c]["h"] != 0 \ + and cells[r + 1][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c]["p"] = cur_player + + if not won_cell: + next_player = 3 - cur_player + else: + next_player = cur_player + print("Update points: player1={} - player2={}".format(points[1], points[2])) + return next_player + + +def main(argv=None): + parser = argparse.ArgumentParser(description='Start agent to play Dots and Boxes') + parser.add_argument('--verbose', '-v', action='count', default=0, help='Verbose output') + parser.add_argument('--quiet', '-q', action='count', default=0, help='Quiet output') + parser.add_argument('--cols', '-c', type=int, default=2, help='Number of columns') + parser.add_argument('--rows', '-r', type=int, default=2, help='Number of rows') + parser.add_argument('--timelimit', '-t', type=float, default=0.5, help='Time limit per request in seconds') + parser.add_argument('agents', nargs=2, metavar='AGENT', help='Websockets addresses for agents') + args = parser.parse_args(argv) + + logger.setLevel(max(logging.INFO - 10 * (args.verbose - args.quiet), logging.DEBUG)) + logger.addHandler(logging.StreamHandler(sys.stdout)) + + start_competition(args.agents[0], args.agents[1], args.rows, args.cols, args.timelimit) + + +if __name__ == "__main__": + sys.exit(main()) + diff --git a/python/dotsandboxes/dotsandboxesserver.py b/python/dotsandboxes/dotsandboxesserver.py new file mode 100644 index 0000000..1b66372 --- /dev/null +++ b/python/dotsandboxes/dotsandboxesserver.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +# encoding: utf-8 +""" +dotsandboxesserver.py + +Template for the Machine Learning Project course at KU Leuven (2017-2018) +of Hendrik Blockeel and Wannes Meert. + +Copyright (c) 2018 KU Leuven. All rights reserved. +""" + +import sys +import argparse +import logging +import http.server +import socketserver +import json + +logger = logging.getLogger(__name__) + + +class RequestHandler(http.server.SimpleHTTPRequestHandler): + def do_GET(self): + if self.path == "/": + self.send_response(302) + self.send_header("Location", "static/dotsandboxes.html") + self.end_headers() + return super().do_GET() + + def do_PUT(self): + response = { + 'result': 'ok' + } + self.send_response(200) + self.send_header('Content-type', 'application/json') + self.end_headers() + self.wfile.write(json.dumps(response).encode()) + + +def start_server(port): + with socketserver.TCPServer(("", port), RequestHandler) as httpd: + print("Running on http://127.0.0.1:{}".format(port)) + httpd.serve_forever() + + +def main(argv=None): + parser = argparse.ArgumentParser(description='Start server to play Dots and Boxes') + parser.add_argument('--verbose', '-v', action='count', default=0, help='Verbose output') + parser.add_argument('--quiet', '-q', action='count', default=0, help='Quiet output') + parser.add_argument('port', metavar='PORT', type=int, help='Port to use for server') + args = parser.parse_args(argv) + + logger.setLevel(max(logging.INFO - 10 * (args.verbose - args.quiet), logging.DEBUG)) + logger.addHandler(logging.StreamHandler(sys.stdout)) + + start_server(args.port) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/python/dotsandboxes/requirements.txt b/python/dotsandboxes/requirements.txt new file mode 100644 index 0000000..14774b4 --- /dev/null +++ b/python/dotsandboxes/requirements.txt @@ -0,0 +1 @@ +websockets diff --git a/python/dotsandboxes/static/dotsandboxes.css b/python/dotsandboxes/static/dotsandboxes.css new file mode 100644 index 0000000..71b1d3b --- /dev/null +++ b/python/dotsandboxes/static/dotsandboxes.css @@ -0,0 +1,10 @@ + +.footer { + color: #B3B3B3; + margin-bottom: 1ex; +} + +.footer a { + color: #87A0B3; +} + diff --git a/python/dotsandboxes/static/dotsandboxes.html b/python/dotsandboxes/static/dotsandboxes.html new file mode 100644 index 0000000..ecbcbb4 --- /dev/null +++ b/python/dotsandboxes/static/dotsandboxes.html @@ -0,0 +1,56 @@ + + + + + + + + +Dots and Boxes + + + + +
+

Dots and Boxes

+
+
+
+
+
+
+

Size of game:

+
+
+ Rows and Columns +
+ + +
+
+
+

Players:

+
+
Agent 1
+ +
+
+
Agent 2
+ +
+

Fill in the address where an agent can be reached using WebSockets (e.g. ws://127.0.0.1:8089). + If a field is empty a human player is assumed. +

+ +
+
+
+
+ © DTAI Research Group, KU Leuven — Source +
+
+ + + + + diff --git a/python/dotsandboxes/static/dotsandboxes.js b/python/dotsandboxes/static/dotsandboxes.js new file mode 100644 index 0000000..11e9447 --- /dev/null +++ b/python/dotsandboxes/static/dotsandboxes.js @@ -0,0 +1,454 @@ +/** + * dotsandboxes.js + * + * Template for the Machine Learning Project course at KU Leuven (2017-2018) + * of Hendrik Blockeel and Wannes Meert. + * + * Copyright (c) 2018 KU Leuven. All rights reserved. + **/ + +function generateGuid() { + var result, i, j; + result = ''; + for(j=0; j<32; j++) { + if( j == 8 || j == 12|| j == 16|| j == 20) + result = result + '-'; + i = Math.floor(Math.random()*16).toString(16).toUpperCase(); + result = result + i; + } + return result; +} + +// GAME LOGIC + +var cur_game = generateGuid(); +var cur_player = 1; +var cur_ended = false; +var points = [0, 0, 0]; +var timelimit = 0.5; +var nb_cols = 6; +var nb_rows = 6; +var data = new Array(0); + +function restart_game() { + //console.log("Restarting game"); + cur_game = generateGuid(); + nb_cols = parseInt(document.getElementById('nb-cols').value); + if (nb_cols == "" || isNaN(nb_cols)) { + nb_cols = 6; + } + nb_rows = parseInt(document.getElementById('nb-rows').value); + if (nb_rows == "" || isNaN(nb_rows)) { + nb_rows = 6; + } + cur_ended = false; + console.log("Starting game", cur_game); + points = [0, 0, 0]; + cur_player = 1; + var old_length = 0; + for (var ri=0; ri= data.length) { + data.push(new Array(0)); + } + var row = data[ri]; + for (var ci=0; ci= row.length) { + row.push({l:0, t:0, p:0, r:0, c:0}); + } + var l = 0; + var t = 0; + var p = 0; + if (ri == nb_rows) { + l = undefined; + p = undefined; + } + if (ci == nb_cols) { + t = undefined; + p = undefined + } + var cell = row[ci]; + cell.l = l; + cell.t = t; + cell.p = p; + cell.r = ri; + cell.c = ci; + } + old_length = row.length; + for (var ci=nb_cols + 1; ci 0) { + if (data[r - 1][c].l != 0 + && data[r - 1][c + 1].l != 0 + && data[r - 1][c].t != 0 + && data[r][c].t != 0) { + won_cell = true; + points[cur_player] += 1; + data[r - 1][c].p = cur_player; + } + } + // Below + if (r < nb_rows) { + if (data[r][c].l != 0 + && data[r][c + 1].l != 0 + && data[r][c].t != 0 + && data[r + 1][c].t != 0) { + won_cell = true; + points[cur_player] += 1; + data[r][c].p = cur_player; + } + } + } + + if (o == "v") { + if (cell.l != 0) { + return; + } + cell.l = cur_player; + // Left + if (c > 0) { + if (data[r][c - 1].l != 0 + && data[r][c].l != 0 + && data[r][c - 1].t != 0 + && data[r + 1][c - 1].t != 0) { + won_cell = true; + points[cur_player] += 1; + data[r][c - 1].p = cur_player; + } + } + // Right + if (c < nb_cols) { + if (data[r][c].l != 0 + && data[r][c + 1].l != 0 + && data[r][c].t != 0 + && data[r + 1][c].t != 0) { + won_cell = true; + points[cur_player] += 1; + data[r][c].p = cur_player; + } + } + } + + msg["score"] = [points[1], points[2]]; + + if (!won_cell) { + cur_player = 3 - cur_player; + msg.nextplayer = cur_player; + } + update_board(); + if (points[1] + points[2] == nb_cols * nb_rows) { + // Game over + var winner = 1 + if (points[2] == points[1]) { + winner = 0; + } + if (points[2] > points[1]) { + winner = 2; + } + cur_ended = true; + msg.type = "end"; + msg.nextplayer = 0; + msg.winner = winner; + } + send_to_agents(msg); +} + +var field_margin = 10; +var cell_width = 40; +var cell_margin = 4; +var player_height = 40; +var width = 400; +var height = 600; +var line_width = 5; + +var player_color = [ + "#E6E6E6", + "#FC6666", + "#0F80FF" +]; + +var svg = d3.select("#playing-area").append("svg") + .attr("width", width) + .attr("height", height) + .append("g") + .attr("transform", "translate("+field_margin+","+field_margin+")"); + +var player = svg.append("g") + .attr("class", "player") + .attr("transform", "translate(0,10)"); + +var field = svg.append("g") + .attr("class", "field") + .attr("transform", "translate(0,"+player_height+")"); + + +function update_board() { + // PLAYERS - enter & update + var player_text = player.selectAll("text") + .data([cur_player, cur_player]); + + player_text = player_text.enter().append("text") + .attr("x", function(c, i) { return i * 100;}) + .merge(player_text) + .text(function(c, i) {return "Player " + (i + 1) + ": "+points[i + 1];}) + .attr("fill", function(c, i) { + if (c == i + 1) { + return player_color[c]; + } else { + return player_color[0]; + } + }); + + // ROWS - enter & update + var rows = field.selectAll(".row") + .data(data) + .attr("fill", function() {return null;}); + + rows.exit().remove(); + + rows = rows.enter().append("g") + .attr("class", "row") + .attr("transform", function(row, i) {return "translate(0," + cell_width * i + ")";}) + .merge(rows); + + // COLS - enter & update + var cols = rows.selectAll(".col") + .data(function(col) {return col;}); + + cols.exit().remove(); + + var cols_enter = cols.enter().append("g") + .attr("class", "col") + .attr("transform", function(col, ri) {return "translate("+cell_width * ri+",0)";}); + + // CELL - enter + cols_enter.append("rect") + .attr("class", "cell") + .attr("rx", cell_margin) + .attr("ry", cell_margin) + .attr("opacity", 0.25) + .attr("x", cell_margin) + .attr("y", cell_margin) + .attr("width", cell_width - 2*cell_margin) + .attr("height", cell_width - 2*cell_margin); + + // HLINE - enter + cols_enter.append("line") + .attr("class", "hline") + .attr("x1", function(cell, ci) {return cell_margin;}) + .attr("x2", function(cell, ci) {return cell_width - cell_margin;}) + .attr("y1", 0) + .attr("y2", 0) + .attr("stroke-linecap", "round") + .attr("stroke", function(cell) {return player_color[cell.t];}); + + cols_enter.append("path") + .attr("d", "M"+cell_margin+",0"+ + "L"+(cell_width/2)+",-"+(cell_width/3)+ + "L"+(cell_width-cell_margin)+",0"+ + "L"+(cell_width/2)+","+(cell_width/3)+"Z") + .attr("stroke", "black") + .attr("stroke-width", 2) + .attr("opacity", "0") + .on("click", function(cell) { + if (agents[cur_player].active == true) { + console.log("Ignoring click, automated agent") + } else { + user_click(cell, "h"); + } + }); + + // VLINE - enter + cols_enter.append("line") + .attr("class", "vline") + .attr("y1", function(cell, ci) {return cell_margin;}) + .attr("y2", function(cell, ci) {return cell_width - cell_margin;}) + .attr("x1", 0) + .attr("x2", 0) + .attr("stroke-linecap", "round") + .attr("stroke", function(cell) {return player_color[cell.l];}); + + cols_enter.append("path") + .attr("d", "M0,"+cell_margin+ + "L-"+(cell_width/3)+","+(cell_width/2)+ + "L0,"+(cell_width-cell_margin)+ + "L"+(cell_width/3)+","+(cell_width/2)+"Z") + .attr("stroke", "black") + .attr("stroke-width", 2) + .attr("opacity", "0") + .on("click", function(cell) { + if (agents[cur_player].active == true) { + console.log("Ignoring click, automated agent"); + } else { + user_click(cell, "v"); + } + }); + + cols = cols_enter + .merge(cols); + + // HLINE - update + cols.selectAll(".hline") + .attr("stroke-width", function(cell) { + if (typeof(cell.t) == "undefined") { + return 0; + } + return line_width; + }) + .attr("stroke", function(cell) {return player_color[cell.t];}); + + // VLINE - update + cols.selectAll(".vline") + .attr("stroke-width", function(cell, ci) { + if (typeof(cell.l) == "undefined") { + return 0; + } + return line_width; + }) + .attr("stroke", function(cell) {return player_color[cell.l];}); + + // CELL - update + cols.selectAll(".cell") + .attr("fill", function(cell) { + if (cell.p == undefined) { + return "white"; + } + return player_color[cell.p]; + }); +} + + +// AGENT CONNECTIONS + +var agents = [ + {}, + {address: undefined, active: false, socket: undefined}, + {address: undefined, active: false, socket: undefined} +]; + +var msg_queue = []; + + +function start_connections() { + for (var i=1; i<3; i++) { + agents[i] = {address:undefined, active: false, socket: undefined}; + var address = document.getElementById('agent'+i).value; + if (address != "") { + //console.log("Starting websocket for agent "+i+" on address "+address); + var agent = agents[i]; + agent.address = address; + agent.socket = new WebSocket(address); + agent.socket.onopen = (function (ii, iagent) { return function(event) { + console.log("Agent "+ii+" connected") + iagent.active = true; + iagent.socket.onmessage = function(event) { + var msg = JSON.parse(event.data); + //console.log("Get msg from agent "+ii, msg); + if (msg.type == "action") { + if (cur_player == ii) { + console.log("Received action from ACTIVE player "+ii, msg); + user_click(data[msg.location[0]][msg.location[1]], msg.orientation); + } else { + console.log("Received action from NON-ACTIVE player "+ii, msg); + } + } + return false; + }; + iagent.socket.onclose = function(event) { + console.log("Closing connection to agent "+ii); + }; + iagent.socket.onerror = function(event) { + console.log("Error on connection to agent "+ii, event); + }; + msg = { + "type": "start", + "player": ii, + "timelimit": timelimit, + "game": cur_game, + "grid": [nb_rows, nb_cols] + }; + iagent.socket.send(JSON.stringify(msg)); + };}(i, agent)); + } + } +} + + +function send_to_agents(msg) { + msg_queue.push(JSON.stringify(msg)); + try_sending_to_agents(); +} + + +function try_sending_to_agents() { + var all_connected = true; + for (var i=1; i<3; i++) { + if (agents[i].address !== undefined && agents[i].active == false) { + all_connected = false; + break; + } + } + if (!all_connected) { + // Wait until all are connected + setTimeout(try_sending_to_agents, 100); + } else { + if (msg_queue.length == 0 ) { + return; + } + var msg = msg_queue.shift(); + console.log("Send msg to agents", msg); + for (var i=1; i<3; i++) { + if (agents[i].active == true) { + agents[i].socket.send(msg); + } + } + } +} + + +// STARTUP + +function restart() { + restart_game(); + update_board(); + start_connections(); +} + +var restartbtn = document.getElementById("restart-btn"); +restartbtn.onclick = function() { + console.log("Restart game"); + restart(); +}; + +restart(); diff --git a/python/evaluate.py b/python/evaluate.py new file mode 100644 index 0000000..fb60211 --- /dev/null +++ b/python/evaluate.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +# encoding: utf-8 +""" +dotsandboxescompete.py + +Template for the Machine Learning Project course at KU Leuven (2017-2018) +of Hendrik Blockeel and Wannes Meert. + +Copyright (c) 2018 KU Leuven. All rights reserved. +""" + +import sys +import argparse +import logging +import asyncio +import websockets +import json +from collections import defaultdict +import random +import uuid +import time +import csv + +logger = logging.getLogger(__name__) +OUTPUTWRITER = None + + +def start_competition(address1, address2, nb_rows, nb_cols, timelimit): + asyncio.get_event_loop().run_until_complete(connect_agent(address1, address2, nb_rows, nb_cols, timelimit)) + + +async def connect_agent(uri1, uri2, nb_rows, nb_cols, timelimit): + cur_game = str(uuid.uuid4()) + winner = None + cells = [] + cur_player = 1 + points = [0, 0, 0] + timings = [None, [], []] + + for ri in range(nb_rows + 1): + columns = [] + for ci in range(nb_cols + 1): + columns.append({"v":0, "h":0, "p":0}) + cells.append(columns) + + logger.info("Connecting to {}".format(uri1)) + async with websockets.connect(uri1) as websocket1: + logger.info("Connecting to {}".format(uri2)) + async with websockets.connect(uri2) as websocket2: + logger.info("Connected") + + # Start game + msg = { + "type": "start", + "player": 1, + "timelimit": timelimit, + "game": cur_game, + "grid": [nb_rows, nb_cols] + } + await websocket1.send(json.dumps(msg)) + msg["player"] = 2 + await websocket2.send(json.dumps(msg)) + + # Run game + while winner is None: + ask_time = time.time() + logger.info("Waiting for player {}".format(cur_player)) + if cur_player == 1: + msg = await websocket1.recv() + else: + msg = await websocket2.recv() + recv_time = time.time() + diff_time = recv_time - ask_time + timings[cur_player].append(diff_time) + logger.info("Message received after (s): {}".format(diff_time)) + try: + msg = json.loads(msg) + except json.decoder.JSONDecodeError as err: + logger.debug(err) + continue + if msg["type"] != "action": + logger.error("Unknown message: {}".format(msg)) + continue + r, c = msg["location"] + o = msg["orientation"] + next_player = user_action(r, c, o, cur_player, + cells, points, + nb_rows, nb_cols) + if points[1] + points[2] == nb_cols * nb_rows: + # Game over + winner = 1 + if points[2] == points[1]: + winner = 0 + if points[2] > points[1]: + winner = 2 + else: + msg = { + "type": "action", + "game": cur_game, + "player": cur_player, + "nextplayer": next_player, + "score": [points[1], points[2]], + "location": [r, c], + "orientation": o + } + await websocket1.send(json.dumps(msg)) + await websocket2.send(json.dumps(msg)) + + cur_player = next_player + + # End game + logger.info("Game ended: points1={} - points2={} - winner={}".format(points[1], points[2], winner)) + msg = { + "type": "end", + "game": cur_game, + "player": cur_player, + "nextplayer": 0, + "score": [points[1], points[2]], + "location": [r, c], + "orientation": o, + "winner": winner + } + await websocket1.send(json.dumps(msg)) + await websocket2.send(json.dumps(msg)) + + # Timings + for i in [1, 2]: + logger.info("Timings: player={} - avg={} - min={} - max={}"\ + .format(i, + sum(timings[i])/len(timings[i]), + min(timings[i]), + max(timings[i]))) + + logger.info("Closed connections") + OUTPUTWRITER.writeln({'score1': points[1], 'score2': points[2], 'winner': winner}) + + +def user_action(r, c, o, cur_player, cells, points, nb_rows, nb_cols): + logger.info("User action: player={} - r={} - c={} - o={}".format(cur_player, r, c, o)) + next_player = cur_player + won_cell = False + cell = cells[r][c] + if o == "h": + if cell["h"] != 0: + return cur_player + cell["h"] = cur_player + # Above + if r > 0: + if cells[r - 1][c]["v"] != 0 \ + and cells[r - 1][c + 1]["v"] != 0 \ + and cells[r - 1][c]["h"] != 0 \ + and cells[r][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r - 1][c]["p"] = cur_player + # Below + if r < nb_rows: + if cells[r][c]["v"] != 0 \ + and cells[r][c + 1]["v"] != 0 \ + and cells[r][c]["h"] != 0 \ + and cells[r + 1][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c]["p"] = cur_player + + if o == "v": + if cell["v"] != 0: + return cur_player + cell["v"] = cur_player; + # Left + if c > 0: + if cells[r][c - 1]["v"] != 0 \ + and cells[r][c]["v"] != 0 \ + and cells[r][c - 1]["h"] != 0 \ + and cells[r + 1][c - 1]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c - 1]["p"] = cur_player + # Right + if c < nb_cols: + if cells[r][c]["v"] != 0 \ + and cells[r][c + 1]["v"] != 0 \ + and cells[r][c]["h"] != 0 \ + and cells[r + 1][c]["h"] != 0: + won_cell = True + points[cur_player] += 1 + cells[r][c]["p"] = cur_player + + if not won_cell: + next_player = 3 - cur_player + else: + next_player = cur_player + print("Update points: player1={} - player2={}".format(points[1], points[2])) + return next_player + + +def main(argv=None): + parser = argparse.ArgumentParser(description='Start agent to play Dots and Boxes') + parser.add_argument('--verbose', '-v', action='count', default=0, help='Verbose output') + parser.add_argument('--quiet', '-q', action='count', default=0, help='Quiet output') + parser.add_argument('--cols', '-c', type=int, default=2, help='Number of columns') + parser.add_argument('--rows', '-r', type=int, default=2, help='Number of rows') + parser.add_argument('--timelimit', '-t', type=float, default=0.5, help='Time limit per request in seconds') + parser.add_argument('--number', '-n', type=int, default=1, help='Number of games that will be played for the evaluation') + parser.add_argument('--output', '-o', default="output.csv", help='File where game results will be written to') + parser.add_argument('agents', nargs=2, metavar='AGENT', help='Websockets addresses for agents') + args = parser.parse_args(argv) + + logger.setLevel(max(logging.INFO - 10 * (args.verbose - args.quiet), logging.DEBUG)) + logger.addHandler(logging.StreamHandler(sys.stdout)) + + global OUTPUTWRITER + OUTPUTWRITER = OutputWriter(args.output) + + for i in range(args.number): + start_competition(args.agents[0], args.agents[1], args.rows, args.cols, args.timelimit) + + OUTPUTWRITER.close() + + +class OutputWriter: + def __init__(self, outputfile): + self.csvfile = open(outputfile, 'w', newline='') + try: + fieldnames = ['score1', 'score2', 'winner'] + self.writer = csv.DictWriter(self.csvfile, fieldnames=fieldnames) + self.writer.writeheader() + except IOError: + self.csvfile.close() + + def writeln(self, csvdict): + self.writer.writerow(csvdict) + + def close(self): + self.csvfile.close() + + +if __name__ == "__main__": + sys.exit(main()) + diff --git a/python/start.sh b/python/start.sh new file mode 100755 index 0000000..6be69a2 --- /dev/null +++ b/python/start.sh @@ -0,0 +1,7 @@ +(cd dotsandboxes; python3 dotsandboxesserver.py 8080) & +python3 agent.py 10001 & +python3 agent.py 10002 & +read -p "Press enter to close all programs." + +trap "exit" INT TERM +trap "kill 0" EXIT diff --git a/runnable_agent/Agent.jar b/runnable_agent/Agent.jar new file mode 100644 index 0000000..6b969cc Binary files /dev/null and b/runnable_agent/Agent.jar differ diff --git a/runnable_agent/dotsandboxesagent b/runnable_agent/dotsandboxesagent new file mode 100644 index 0000000..3788e28 --- /dev/null +++ b/runnable_agent/dotsandboxesagent @@ -0,0 +1,3 @@ +#!/bin/bash +cd "$(dirname "$0")" +java -jar Agent.jar -p $@ \ No newline at end of file diff --git a/runnable_agent/final_ann b/runnable_agent/final_ann new file mode 100644 index 0000000..7be12c1 Binary files /dev/null and b/runnable_agent/final_ann differ diff --git a/sandbox/game.py b/sandbox/game.py deleted file mode 100644 index 003d943..0000000 --- a/sandbox/game.py +++ /dev/null @@ -1,282 +0,0 @@ -import pygame -import numpy as np -import sys - - -class Game: - def __init__(self): - self.grid_size = 10 # default - if len(sys.argv) > 1: - self.grid_size = int(sys.argv[1]) - - # It turns out that there are nice structures when setting ~0.75 walls per slot - self.start_walls = int(0.75 * self.grid_size ** 2) - - self.accept_clicks = True - - # variables for the boxes for each player (x would be computer) - self.a_boxes = 0 - self.b_boxes = 0 - self.x_boxes = 0 - - self.turn = "X" - self.caption = "'s turn " - - # 0 empty 1 is A 2 is B and 3 is X - self.grid_status = np.zeros((self.grid_size, self.grid_size), np.int) - self.upper_walls_set_flags = np.zeros((self.grid_size, self.grid_size), np.dtype(bool)) - self.left_walls_set_flags = np.zeros((self.grid_size, self.grid_size), np.dtype(bool)) - - # set the outer walls - for column in range(self.grid_size): - for row in range(self.grid_size): - if column == 0: - self.left_walls_set_flags[column][row] = True - if row == 0: - self.upper_walls_set_flags[column][row] = True - - # initialize pygame - pygame.init() - - # set the display size (one slot has 30x30 pixels; Walls: 4x26 Box: 26x26) - self.screen = pygame.display.set_mode([30 * self.grid_size + 4, 30 * self.grid_size + 4]) - - # load all images - self.empty = pygame.image.load("pics/empty.png") - self.A = pygame.image.load("pics/A.png") - self.B = pygame.image.load("pics/B.png") - self.X = pygame.image.load("pics/X.png") - self.block = pygame.image.load("pics/block.png") - self.lineX = pygame.image.load("pics/lineX.png") - self.lineXempty = pygame.image.load("pics/lineXempty.png") - self.lineY = pygame.image.load("pics/lineY.png") - self.lineYempty = pygame.image.load("pics/lineYempty.png") - - tries = 0 - # set the start walls randomly but do not create any opportunity to directly close boxes - while self.start_walls > 0 and tries < 4*self.grid_size**2: - x = np.random.randint(self.grid_size) - y = np.random.randint(self.grid_size) - up = np.random.randint(2) - - if up: - if not self.upper_walls_set_flags[x][y] \ - and self.get_number_of_walls(x, y) < 2 \ - and self.get_number_of_walls(x, y - 1) < 2: - self.upper_walls_set_flags[x][y] = True - self.start_walls -= 1 - else: - if not self.left_walls_set_flags[x][y] \ - and self.get_number_of_walls(x, y) < 2 \ - and self.get_number_of_walls(x - 1, y) < 2: - self.left_walls_set_flags[x][y] = True - self.start_walls -= 1 - - tries += 1 - - # now it's the first players turn - self.turn = "A" - self.show() - - while True: - # go through all events and check the types - for event in pygame.event.get(): - # quit the game when the player closes it - if event.type == pygame.QUIT: - pygame.quit() - exit(0) - - # left click - elif event.type == pygame.MOUSEBUTTONDOWN and pygame.mouse.get_pressed()[0]: - if not self.accept_clicks: - continue - - # get the current position of the cursor - x = pygame.mouse.get_pos()[0] - y = pygame.mouse.get_pos()[1] - - # check whether it was a not set wall that was clicked - wall_x, wall_y = self.get_wall(x, y) - - if not (wall_x >= 0 and wall_y >= 0): - continue - - upper_wall = wall_y % 30 == 0 - - if upper_wall: - if not self.upper_walls_set_flags[wall_x//30][wall_y//30]: - self.upper_walls_set_flags[wall_x//30][wall_y//30] = True - self.screen.blit(self.lineX, (wall_x, wall_y)) - else: - continue - else: - if not self.left_walls_set_flags[wall_x//30][wall_y//30]: - self.left_walls_set_flags[wall_x//30][wall_y//30] = True - self.screen.blit(self.lineY, (wall_x, wall_y)) - else: - continue - - if not self.set_all_slots() > 0: - if self.turn == "A": - self.turn = "B" - elif self.turn == "B": - self.turn = "A" - - if self.won(): - self.accept_clicks = False - - else: - - # set the display caption - pygame.display.set_caption(self.turn + self.caption + " A:" + str( - self.a_boxes) + " B:" + str(self.b_boxes)) - - # update the players screen - pygame.display.flip() - - def get_number_of_walls(self, slot_column, slot_row): - """ - Get the number of set walls around the passed slot - :param slot_column: x of the slot - :param slot_row: y of the slot - :return: number of set walls - """ - number_of_walls = 0 - - if slot_column == self.grid_size - 1: - number_of_walls += 1 - elif self.left_walls_set_flags[slot_column + 1][slot_row]: - number_of_walls += 1 - - if slot_row == self.grid_size - 1: - number_of_walls += 1 - elif self.upper_walls_set_flags[slot_column][slot_row + 1]: - number_of_walls += 1 - - if self.left_walls_set_flags[slot_column][slot_row]: - number_of_walls += 1 - - if self.upper_walls_set_flags[slot_column][slot_row]: - number_of_walls += 1 - - return number_of_walls - - @staticmethod - def get_wall(pos_x, pos_y): - rest_x = pos_x % 30 - rest_y = pos_y % 30 - - wall_slot_x = pos_x//30 - wall_slot_y = pos_y//30 - - # in a corner - if rest_x < 4 and rest_y < 4: - return -1, -1 - - if rest_x < 4: - # is left wall of the slot - return wall_slot_x*30, wall_slot_y*30 + 4 - - if rest_y < 4: - # is upper wall of the slot - return wall_slot_x*30 + 4, wall_slot_y*30 - - # inside the box => not a wall - return -1, -1 - - def set_all_slots(self): - """ - Find all newly closed boxes and close them for the current player - :return: number of closed boxes - """ - to_return = 0 - - for column_ in range(self.grid_size): - for row_ in range(self.grid_size): - if self.grid_status[column_][row_] != 0 or self.get_number_of_walls(column_, row_) < 4: - continue - - if self.turn == "A": - self.grid_status[column_][row_] = 1 - self.screen.blit(self.A, (column_ * 30 + 4, row_ * 30 + 4)) - self.a_boxes += 1 - elif self.turn == "B": - self.grid_status[column_][row_] = 2 - self.screen.blit(self.B, (column_ * 30 + 4, row_ * 30 + 4)) - self.b_boxes += 1 - elif self.turn == "X": - self.grid_status[column_][row_] = 3 - self.screen.blit(self.X, (column_ * 30 + 4, row_ * 30 + 4)) - self.x_boxes += 1 - - to_return += 1 - - return to_return - - def won(self): - """ - Check whether the game was finished - If so change the caption to display the winner - :return: won or not - """ - if self.a_boxes + self.b_boxes + self.x_boxes == self.grid_size ** 2: - if self.a_boxes < self.b_boxes: - won_caption = "Player B won! Congrats" - elif self.b_boxes < self.a_boxes: - won_caption = "Player A won! Congrats" - else: - won_caption = "It's a tie!" - - # set the display caption - pygame.display.set_caption(won_caption) - - # update the players screen - pygame.display.flip() - - return True - else: - return False - - def show(self): - """ - Reload the screen - Use the current grid and wall information to - update the players screen - """ - self.screen.fill(0) - - # loop over all slots - for column in range(self.grid_size): - for row in range(self.grid_size): - x, y = column * 30, row * 30 - self.screen.blit(self.block, (x, y)) - x += 4 - if not self.upper_walls_set_flags[column][row]: - self.screen.blit(self.lineXempty, (x, y)) - else: - self.screen.blit(self.lineX, (x, y)) - x -= 4 - y += 4 - if not self.left_walls_set_flags[column][row]: - self.screen.blit(self.lineYempty, (x, y)) - else: - self.screen.blit(self.lineY, (x, y)) - - # calculate x and y in pixels - x, y = column * 30 + 4, row * 30 + 4 - - if self.grid_status[column][row] == 0: - self.screen.blit(self.empty, (x, y)) - elif self.grid_status[column][row] == 1: - self.screen.blit(self.A, (x, y)) - elif self.grid_status[column][row] == 2: - self.screen.blit(self.B, (x, y)) - elif self.grid_status[column][row] == 3: - self.screen.blit(self.X, (x, y)) - - pygame.display.set_caption(self.turn + self.caption + " A:" + str(self.a_boxes) + " B:" + str( - self.b_boxes)) - pygame.display.flip() - - -game = Game() # start a game \ No newline at end of file diff --git a/sandbox/pics/A.png b/sandbox/pics/A.png deleted file mode 100644 index 7d04d60..0000000 Binary files a/sandbox/pics/A.png and /dev/null differ diff --git a/sandbox/pics/B.png b/sandbox/pics/B.png deleted file mode 100644 index c9f6ec7..0000000 Binary files a/sandbox/pics/B.png and /dev/null differ diff --git a/sandbox/pics/X.png b/sandbox/pics/X.png deleted file mode 100644 index 64bcf7c..0000000 Binary files a/sandbox/pics/X.png and /dev/null differ diff --git a/sandbox/pics/block.png b/sandbox/pics/block.png deleted file mode 100644 index 8c2f9d8..0000000 Binary files a/sandbox/pics/block.png and /dev/null differ diff --git a/sandbox/pics/empty.png b/sandbox/pics/empty.png deleted file mode 100644 index 8d3daad..0000000 Binary files a/sandbox/pics/empty.png and /dev/null differ diff --git a/sandbox/pics/lineX.png b/sandbox/pics/lineX.png deleted file mode 100644 index cec7bc0..0000000 Binary files a/sandbox/pics/lineX.png and /dev/null differ diff --git a/sandbox/pics/lineXempty.png b/sandbox/pics/lineXempty.png deleted file mode 100644 index ff09abe..0000000 Binary files a/sandbox/pics/lineXempty.png and /dev/null differ diff --git a/sandbox/pics/lineY.png b/sandbox/pics/lineY.png deleted file mode 100644 index 32fe351..0000000 Binary files a/sandbox/pics/lineY.png and /dev/null differ diff --git a/sandbox/pics/lineYempty.png b/sandbox/pics/lineYempty.png deleted file mode 100644 index ef10800..0000000 Binary files a/sandbox/pics/lineYempty.png and /dev/null differ -- cgit v1.2.3