def __init__(self, m, n, mode):
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
# save size and mode
self.size = [m, n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
# set the game to entry point
self.start(self._currentPlayer)
if self.UIRequired():
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.MachineGUI.gameLoop()
def __init__(self, m, n, mode):
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
# save size and mode
self.size = [m,n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
# set the game to entry point
self.start(self._currentPlayer)
if self.UIRequired():
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.MachineGUI.gameLoop()
def __init__(self, win, size, player1, player2):
self.running = True
self.win = win
self.size = size
self.p1 = Player("red", 1)
self.p1.setSide(1)
self.p2 = Player("blue", 2)
self.p2.setSide(-1)
self.players = (self.p1, self.p2)
self.currentPlayer = 1
self.GUI = None
self.turnText = None
self.player1 = player1
self.player2 = player2
windowSize = 520
self.GUI = HexGUI(self.win, self.size, 20, [80, 100])
self.turnText = Text(Point(windowSize / 3, windowSize / 10),
"Player " + str(self.currentPlayer) + "'s Turn (thinking)")
self.turnText.setSize(20)
self.turnText.draw(self.win)
self.board = self.GUI.getBoard()
class Game:
def __init__(self, m, n, mode):
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
# save size and mode
self.size = [m, n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
self._currentPlayerType = "human"
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
if self.mode == "ki" or self.mode == "machine":
self.KI = PatternKI(self)
# set the game to entry point
self.start(self._currentPlayer)
if self.UIRequired():
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.MachineGUI.gameLoop()
def UIRequired(self):
if self.mode == "human" or self.mode == "ki" or self.mode == "inter":
return True
else:
return False
def start(self, firstPlayer):
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
if self.mode == "ki" or self.mode == "machine":
self.KI = PatternKI(self)
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def onGameStarted(self):
if self.UIRequired():
# draw the gui
self.HexGUI.draw()
# Game finished event
def onGameFinished(self):
if self.UIRequired():
# move over to main menu and present the winner
self.HexGUI.openPage("menu")
self.HexGUI.won(self.HexBoard.winner())
# generate random player number
def chooseFirst(self):
self._currentPlayer = round(random.random()) + 1
# is the getter for the private variable
def currentPlayer(self):
return self._currentPlayer
# is the current Player human?
def isPlayerHuman(self):
return self._currentPlayerType == "human"
# alter the players
def changePlayer(self):
if self._currentPlayer == 1:
self._currentPlayer = 2
else:
self._currentPlayer = 1
if self.mode == "ki":
if self._currentPlayerType == "human":
self._currentPlayerType = "ki"
else:
self._currentPlayerType = "human"
# control flow for click event
def makeMove(self, move):
# Notify
EventManager.notify("MoveBegan")
# if already marked dont do anything
if self.HexBoard.isMarked(move[1], move[0]):
EventManager.notify("MoveDenied")
else:
# otherwise count the click
self.moveCounter = self.moveCounter + 1
# notify Model
self.HexBoard.receiveMove(move)
# notify View
self.changePlayer()
EventManager.notify("PlayerChanged")
if not self.isPlayerHuman():
move = self.KI.getMove()
self.makeMove(move)
EventManager.notify("MoveFinished")
class HexGame(object):
def __init__(self, win, size, player1, player2):
self.running = True
self.win = win
self.size = size
self.p1 = Player("red", 1)
self.p1.setSide(1)
self.p2 = Player("blue", 2)
self.p2.setSide(-1)
self.players = (self.p1, self.p2)
self.currentPlayer = 1
self.GUI = None
self.turnText = None
self.player1 = player1
self.player2 = player2
windowSize = 520
self.GUI = HexGUI(self.win, self.size, 20, [80, 100])
self.turnText = Text(Point(windowSize / 3, windowSize / 10),
"Player " + str(self.currentPlayer) + "'s Turn (thinking)")
self.turnText.setSize(20)
self.turnText.draw(self.win)
self.board = self.GUI.getBoard()
def print_board(self):
result = (" " + u"\u25a0") * self.GUI.size + u" \u25E9\n"
for i in range(self.GUI.size):
result += " " * i + u"\u25A1" + " "
for j in range(self.GUI.size):
result += print_block(self.GUI.board[i, j]) + " "
result += u"\u25A1" + "\n"
result += " " * (self.GUI.size) + u"\u25EA" + (" " + u"\u25a0") * self.GUI.size + "\n" + "\n"
label = str(self.players[self.currentPlayer].getSide()) + "'s turn to place a " + print_block(
self.players[self.currentPlayer].getSide()) + " piece"
return result + label
def switchPlayer(self):
self.currentPlayer = (self.currentPlayer + 1) % 2
self.turnText.setText("Player " + str(self.currentPlayer + 1) + "'s Turn (thinking)")
def isRunning(self):
return self.running
def forceQuit(self):
self.running = False
self.win.mouseX = self.win.mouseY = [] # get out of the getMouse() loop
self.win.close()
exit(0)
def player1Go(self):
playerSide = self.players[self.currentPlayer].getSide()
if self.player1.__dict__ == humanPlayer().__dict__:
co = self.player1.getMove(self.win, self.GUI)
else:
my_strategy = strategy(self.board, self.size, playerSide)
#print "len", len(my_strategy.getPossiMoves())
if my_strategy.alreadyPlacedBlockNum() <= 1:
co = my_strategy.greatFirstMove()
else:
co = self.player1.getMove(self.board, playerSide)
print "player1 move =", co
# print "board", self.board
if self.GUI.placePiece(co, self.players[self.currentPlayer]):
# print 'playerside', playerSide
my_strategy = strategy(self.board, self.size, playerSide)
winner = my_strategy.winner()
# print "winner =", winner
if winner == None:
self.switchPlayer()
elif winner == self.currentPlayer + 1:
self.turnText.setTextColor("magenta")
self.turnText.setText("Player " + str(winner) + " wins.")
return winner
return None
def player2Go(self):
playerSide = self.players[self.currentPlayer].getSide()
if self.player2.__dict__ == humanPlayer().__dict__:
co = self.player2.getMove(self.win, self.GUI)
else:
# my_strategy = strategy(self.board, self.size, playerSide)
# if self.size * self.size - len(my_strategy.getPossiMoves()) <= 1:
# co = my_strategy.greatFirstMove()
# else:
co = self.player2.getMove(self.board, playerSide)
print "player2 move =", co
# print "board", self.board
if self.GUI.placePiece(co, self.players[self.currentPlayer]):
# print 'playerside', playerSide
my_strategy = strategy(self.board, self.size, playerSide)
winner = my_strategy.winner()
if winner == None:
self.switchPlayer()
elif winner == self.currentPlayer + 1:
self.turnText.setTextColor("magenta")
self.turnText.setText("Player " + str(winner) + " wins.")
return winner
else:
return False
return None
def play(self):
self.currentPlayer = 0
while self.running:
self.turnText.setTextColor(self.players[self.currentPlayer].getColor())
times = time.clock()
winner = self.player1Go()
timeSpan = time.clock() - times
print "time used for this move:" + str(timeSpan) +"\n" + self.print_board()
if winner == self.currentPlayer + 1:
print str(self.players[self.currentPlayer].getSide()) + " wins"
return winner
self.turnText.setTextColor(self.players[self.currentPlayer].getColor())
times = time.clock()
winner = self.player2Go()
timeSpan = time.clock() - times
print "time used for this move:" + str(timeSpan) +"\n" + self.print_board()
if winner == self.currentPlayer + 1:
print str(self.players[self.currentPlayer].getSide()) + " wins"
return winner
return None
class Game:
def __init__(self, m, n, mode):
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
# save size and mode
self.size = [m, n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
# set the game to entry point
self.start(self._currentPlayer)
if self.UIRequired():
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.MachineGUI.gameLoop()
def UIRequired(self):
if self.mode == "human" or self.mode == "ki" or self.mode == "inter":
return True
else:
return False
def start(self, firstPlayer):
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def onGameStarted(self):
if self.UIRequired():
# draw the gui
self.HexGUI.draw()
# Game finished event
def onGameFinished(self):
if self.UIRequired():
# move over to main menu and present the winner
self.HexGUI.openPage("menu")
self.HexGUI.won(self.HexBoard.winner())
# generate random player number
def chooseFirst(self):
self._currentPlayer = round(random.random()) + 1
# is the getter for the private variable
def currentPlayer(self):
return self._currentPlayer
# alter the players
def changePlayer(self):
if self._currentPlayer == 1:
self._currentPlayer = 2
else:
self._currentPlayer = 1
# control flow for click event
def makeMove(self, move):
# Notify
EventManager.notify("MoveBegan")
# if already marked dont do anything
if self.HexBoard.isMarked(move[1], move[0]):
EventManager.notify("MoveDenied")
else:
# otherwise count the click
self.moveCounter = self.moveCounter + 1
# notify Model
self.HexBoard.receiveMove(move)
# notify View
self.changePlayer()
EventManager.notify("PlayerChanged")
EventManager.notify("MoveFinished")
def __init__(self, m, n, mode):
self._pause = False
# save size and mode
self.size = [m, n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
self._currentPlayerType = "human"
if mode == "copy":
return
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
EventManager.subscribe("MoveFinished", self.onMoveFinished)
EventManager.subscribe("GameUILoaded", self.onGameUILoaded)
EventManager.subscribe("ToggleVictoryPath", self.onToggleVictoryPath)
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
self.GameState = 0
self.moveCounter = 0
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
if self.mode == "ki":
self.KI = HexKI(self.size[0], self.size[1])
if self.mode == "inter" or self.mode == "machine":
self.KI = []
self.KI.append(HexKI(self.size[0], self.size[1]))
self.KI.append(HexKI(self.size[0], self.size[1]))
self._currentPlayerType = "ki"
# set the game to entry point
#self.start(self._currentPlayer)
if self.UIRequired():
EventManager.subscribe("UITick", self.onUITick)
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.GameState = 1
self.MachineGUI.gameLoop()
class Game:
def __init__(self, m, n, mode):
self._pause = False
# save size and mode
self.size = [m, n]
self.mode = mode
# just to init the value
self._currentPlayer = 1
self._currentPlayerType = "human"
if mode == "copy":
return
# init all events
EventManager.initEvents()
EventManager.subscribe("GameFinished", self.onGameFinished)
EventManager.subscribe("GameStarted", self.onGameStarted)
EventManager.subscribe("MoveFinished", self.onMoveFinished)
EventManager.subscribe("GameUILoaded", self.onGameUILoaded)
EventManager.subscribe("ToggleVictoryPath", self.onToggleVictoryPath)
# instantiate model and view
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
self.GameState = 0
self.moveCounter = 0
if self.UIRequired():
self.HexGUI = HexGUI(self.size[0], self.size[1], self)
else:
self.MachineGUI = MachineGUI(self.size[0], self.size[1], self)
if self.mode == "ki":
self.KI = HexKI(self.size[0], self.size[1])
if self.mode == "inter" or self.mode == "machine":
self.KI = []
self.KI.append(HexKI(self.size[0], self.size[1]))
self.KI.append(HexKI(self.size[0], self.size[1]))
self._currentPlayerType = "ki"
# set the game to entry point
#self.start(self._currentPlayer)
if self.UIRequired():
EventManager.subscribe("UITick", self.onUITick)
# main loop starts for event receiving
self.HexGUI.mainloop()
if self.UIRequired() == False:
self.GameState = 1
self.MachineGUI.gameLoop()
def onUITick(self):
self.doKIMove()
def onToggleVictoryPath(self):
if self.UIRequired():
vertices = self.HexBoard.getVictoryPath()
self.HexGUI._GUIGameBoard.Pattern.toggleVictoryPath(vertices)
def pause(self):
self._pause = not self._pause
def UIRequired(self):
if self.mode == "human" or self.mode == "ki" or self.mode == "inter":
return True
else:
return False
def start(self, firstPlayer):
self.GameState = 0
EventManager.notify("GameStarting")
# move counter init
self.moveCounter = 0
# generate fresh state
self.HexBoard = HexBoard(self.size[0], self.size[1])
self.HexBoard.setReferenceToGame(self)
# current player depending on decision
self._currentPlayer = firstPlayer
if self.mode == "ki":
self.KI = MonteCarloTreeSearch(self, 2) # TODO: ki_player_id == 2?
# self.KI = HexKI(self.size[0], self.size[1])
if self.mode == "inter" or self.mode == "machine":
self.KI = []
self.KI.append(HexKI(self.size[0], self.size[1]))
self.KI.append(HexKI(self.size[0], self.size[1]))
self._currentPlayerType = "ki"
# if random number wanted, generate one
if firstPlayer == 0:
self.chooseFirst()
EventManager.notify("GameStarted")
def onGameStarted(self):
self.GameState = 1
if self.UIRequired():
# draw the gui
self.HexGUI.draw()
# Game finished event
def onGameFinished(self):
self.GameState = 0
if self.UIRequired():
# move over to main menu and present the winner
self.HexGUI.openPage("menu")
self.HexGUI.won(self.HexBoard.winner())
def onGameUILoaded(self):
pass
#if self.mode == "inter" or (self.mode == "ki" and self._currentPlayerType == "human"):
# print("IM KI")
# generate random player number
def chooseFirst(self):
self._currentPlayer = round(random.random()) + 1
# is the getter for the private variable
def currentPlayer(self):
return self._currentPlayer
# is the current Player human?
def isPlayerHuman(self):
return self._currentPlayerType == "human"
# alter the players
def changePlayer(self):
if self._currentPlayer == 1:
self._currentPlayer = 2
else:
self._currentPlayer = 1
if self.mode == "ki":
if self._currentPlayerType == "human":
self._currentPlayerType = "ki"
else:
self._currentPlayerType = "human"
if self.mode in ["inter", "machine"]:
self._currentPlayerType = "ki"
# control flow for click event
def makeMove(self, move):
# Notify
EventManager.notify("MoveBegan")
# if already marked dont do anything
if self.HexBoard.isMarked(move[0], move[1]):
EventManager.notify("MoveDenied")
assert False
else:
# otherwise count the click
self.moveCounter = self.moveCounter + 1
# notify Model
self.HexBoard.receiveMove(move)
if self.mode == "inter":
self.KI[0].receiveMove(move)
self.KI[1].receiveMove(move)
elif self.mode == "ki":
self.KI.receiveMove(move)
# notify View
self.changePlayer()
EventManager.notify("PlayerChanged")
EventManager.notify("MoveFinished")
def doKIMove(self):
if self.GameState == 1:
if not self.isPlayerHuman() and self.mode == "ki":
move = self.KI.nextMove()
self.makeMove(move)
elif self.mode == "inter" or self.mode == "machine":
move = self.KI[self.currentPlayer() - 1].nextMove()
#print(move, self.currentPlayer())
#print("making", move)
self.makeMove(move)
def onMoveFinished(self):
pass
