def __init__(self, go_engine, debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands komi : float komi used for the current game board: GoBoard SIZExSIZE array representing the current board state """ self.stdout = sys.stdout self._debug_mode = debug_mode sys.stdout = self self.go_engine = go_engine self.go_engine.komi = 0 self.go_engine.selfatari = 1 self.go_engine.pattern = 1 self.board = GoBoard(7) self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "num_sim": self.num_sim_cmd, "showoptions": self.showoptions_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w, b}'), "num_sim": (1, 'Usage: num_sim #(e.g. num_sim 100 )'), "showoptions": (0, 'showotions does not get arguments') }
def __init__(self, go_engine, debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands debug_mode: prints debug messages """ self.stdout = sys.stdout sys.stdout = self self._debug_mode = debug_mode self.go_engine = go_engine self.komi = 0 self.board = GoBoard(7) self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "solve": self.solve_cmd, "timelimit": self.timeout_cmd, "print_toplay": self.print_toplay_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w, b}'), "solve": (0, 'Usage: command takes no arguments, solves for current player.'), "timelimit": (1, 'Usage: sets maximum time solve and genmove functions may run') #"print_toplay":(0, "Usage: command to print current toplay") }
def test_size_2_legal_moves(self): size = 2 goboard = GoBoard(size) moves = GoBoardUtil.generate_legal_moves(goboard, BLACK) self.assertEqual( moves, [ goboard.pt(1, 1), goboard.pt(1, 2), goboard.pt(2, 1), goboard.pt(2, 2) ], )
def test_size_2(self): goboard = GoBoard(2) self.assertEqual(goboard.size, 2) self.assertEqual(goboard.NS, 3) self.assertEqual(goboard.WE, 1) self.assertEqual(goboard.ko_recapture, None) self.assertEqual(goboard.current_player, BLACK) self.assertEqual(goboard.maxpoint, 13) self.assertEqual(goboard.board[0], BORDER) self.assertEqual(goboard.board[goboard.pt(1, 1)], EMPTY) self.assertEqual(goboard.board[goboard.pt(1, 2)], EMPTY) self.assertEqual(goboard.board[goboard.pt(2, 1)], EMPTY) self.assertEqual(goboard.board[goboard.pt(2, 2)], EMPTY)
def run(): """ start the gtp connection and wait for commands. """ board = GoBoard(7) con = GtpConnection(FlatMCSimPlayer(10, board), board) con.start_connection()
def run(): """ start the gtp connection and wait for commands. """ board = GoBoard(7) con = GtpConnection(Gomoku(), board) con.start_connection()
def run(sim, sim_rule): """ Start the gtp connection and wait for commands. """ board = GoBoard(7) con = GtpConnection(Gomoku3(sim, sim_rule), board) con.start_connection()
def do_test_pointsets(self, size): goboard = GoBoard(size) count = count_colors(goboard) self.assertEqual(count[EMPTY], size * size) self.assertEqual(count[BLACK], 0) self.assertEqual(count[WHITE], 0) num_border = 3 * (size + 1) self.assertEqual(count[BORDER], num_border)
def playGame(player1, player2): t = GoBoard(7) numMoves = 0 while t.winner() == EMPTY and numMoves < 40: player = selectPlayer(numMoves, player1, player2) t.play_move(player.genMove(t), t.current_player) numMoves += 1 #print("Game winner:", t.winner(), "Moves:", t.moves) return t.winner()
def init_pvp(): #Initiates the pvp objects and variables global board global board_history global start_pva global start_pvp global turn global win global win_sequence board = GoBoard(15) board_history = Board_History() start_pva = 0 start_pvp = 1 turn = 0 win = 0 win_sequence = []
def reset_pvp(): #resets the pvp objects and variables global board global board_history global last_black global last_white global start_pvp global turn global win global win_sequence board = GoBoard(15) board_history = Board_History() last_black = None last_white = None start_pvp = 1 turn = 0 win = 0 win_sequence = []
def init_pva(difficulty): #Initiates the pva objects and variables global Ai global board global board_history global turn global start_pva global start_pvp global timer global win global win_sequence board = GoBoard() board_history = Board_History() start_pva = 1 start_pvp = 0 Ai = AI(difficulty) timer = 0 turn = 0 win = 0 win_sequence = []
def reset_pva(): #resets the pva objects and variables global Ai global board global board_history global last_black global last_white global start_pvp global timer global turn global win global win_sequence Ai = AI(difficulty) board = GoBoard() board_history = Board_History() last_black = None last_white = None start_pva = 1 timer = 0 turn = 0 win = 0 win_sequence = []
class GtpConnection(): def __init__(self, go_engine, outfile='/tmp/gtp_log', debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine : GoPlayer a program that is capable of playing go by reading GTP commands komi : float komi used for the current game board: GoBoard SIZExSIZE array representing the current board state """ mode = 'w' self.stdout = sys.stdout #sys.stdout = outfile self._debug_mode = debug_mode self.file = open(outfile, mode) #self.stderr = sys.stderr sys.stdout = self self.go_engine = go_engine self.komi = 0 self.board = GoBoard(7) self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w,b}'), "play": (2, 'Usage: play {b,w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w,b}') } def __del__(self): sys.stdout = self.stdout self.file.close() def write(self, data): self.file.write(data) self.stdout.write(data) def flush(self, ): self.stdout.flush() self.file.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0] args = elements[1:] if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format( traceback.format_exc())) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker funciton for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] > argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg=''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg) sys.stderr.flush() def error(self, error_msg=''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)) sys.stdout.flush() def respond(self, response=''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)) sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.komi = float(args[0]) self.respond() def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format( move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond(moves) except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color = GoBoardUtil.color_to_int(board_color) if args[1].lower() == 'pass': #GIVES RESPONSE, UNSURE IF ENFORCED AS IN TURN CHANGE=?? self.debug_msg("Player {} is passing\n".format(args[0])) self.respond("Illegal Move: {} is passing".format(args[0])) return move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) # move == None on pass else: self.error( "Error in executing the move %s, check given move: %s" % (move, args[1])) return if not self.board.move(move, color): self.respond("Illegal Move: {}".format(board_move)) return else: self.debug_msg("Move: {}\nBoard:\n{}\n".format( board_move, str(self.board.get_twoD_board()))) self.respond() #CHECKS VALID MOVES OF OPPONENT, IF EMPTY WINNING if GoBoardUtil.generate_legal_moves(self.board, color) == '': if args[0].lower() == "b": self.respond("Black Wins!!") if args[0].lower() == "w": self.respond("White Wins!!") self.respond("Board has been cleared.") self.reset(self.board.size) except Exception as e: self.respond('Error: {}'.format(str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) self.debug_msg("Board:\n{}\nko: {}\n".format( str(self.board.get_twoD_board()), self.board.ko_constraint)) move = self.go_engine.get_move(self.board, color) if move is None: if args[0].lower() == "b": self.respond("White Wins!!") if args[0].lower() == "w": self.respond("Black Wins!!") #self.respond("pass") self.respond("Board has been cleared.") self.reset(self.board.size) return if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e)))
def __init__( self, parent, id=-1, title="围棋打谱 UJS GO", pos=wx.DefaultPosition, size=(1200, 700), style=wx.DEFAULT_FRAME_STYLE | wx.SYSTEM_MENU, ): wx.Frame.__init__(self, parent, id, title, pos, size, style) self._mgr = aui.AuiManager() # notify AUI which frame to use self._mgr.SetManagedWindow(self) # 创建设置 self.mode = mine # self.createIcon() # 创建定时器 self.clktime = 2000 self.timer = wx.Timer(self) # 创建菜单 self.createMenuBar() #创建状态条 self.createStatusBar() # 创建面板 self.history = wx.ListBox(self, -1, choices=self.mode.titles, size=wx.Size(550, 700)) self.board = GoBoard(wx.Image("back.png"), dataBoard, parent=self, size=(600, 600)) #style=wx.FULL_REPAINT_ON_RESIZE) self.stones = wx.ListBox(self, -1, choices=dataBoard.strnodes, size=wx.Size(50, 700)) # add the panes to the manager #self._mgr.AddPane(self.toolbar, aui.AuiPaneInfo().Top()) self._mgr.AddPane( self.history, aui.AuiPaneInfo().Left().Caption("历史记录").Name('history')) self._mgr.AddPane( self.stones, aui.AuiPaneInfo().Right().Caption("下棋位置").Name('stone')) self._mgr.AddPane(self.board, aui.AuiPaneInfo().CenterPane().Name('board')) #self._mgr.AddPane(self.toolbar, aui.AuiPaneInfo().Top()) # tell the manager to "commit" all the changes just made self._mgr.Update() #Bind event self.stones.Bind(wx.EVT_LISTBOX, self.OnStones) self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer) self.Bind(wx.EVT_CLOSE, self.OnClose) # self.timer2 = wx.Timer(self) self.timer2.Start(100) self.Bind(wx.EVT_TIMER, self.OnTimer2, self.timer2)
class MyFrame(wx.Frame): def __init__( self, parent, id=-1, title="围棋打谱 UJS GO", pos=wx.DefaultPosition, size=(1200, 700), style=wx.DEFAULT_FRAME_STYLE | wx.SYSTEM_MENU, ): wx.Frame.__init__(self, parent, id, title, pos, size, style) self._mgr = aui.AuiManager() # notify AUI which frame to use self._mgr.SetManagedWindow(self) # 创建设置 self.mode = mine # self.createIcon() # 创建定时器 self.clktime = 2000 self.timer = wx.Timer(self) # 创建菜单 self.createMenuBar() #创建状态条 self.createStatusBar() # 创建面板 self.history = wx.ListBox(self, -1, choices=self.mode.titles, size=wx.Size(550, 700)) self.board = GoBoard(wx.Image("back.png"), dataBoard, parent=self, size=(600, 600)) #style=wx.FULL_REPAINT_ON_RESIZE) self.stones = wx.ListBox(self, -1, choices=dataBoard.strnodes, size=wx.Size(50, 700)) # add the panes to the manager #self._mgr.AddPane(self.toolbar, aui.AuiPaneInfo().Top()) self._mgr.AddPane( self.history, aui.AuiPaneInfo().Left().Caption("历史记录").Name('history')) self._mgr.AddPane( self.stones, aui.AuiPaneInfo().Right().Caption("下棋位置").Name('stone')) self._mgr.AddPane(self.board, aui.AuiPaneInfo().CenterPane().Name('board')) #self._mgr.AddPane(self.toolbar, aui.AuiPaneInfo().Top()) # tell the manager to "commit" all the changes just made self._mgr.Update() #Bind event self.stones.Bind(wx.EVT_LISTBOX, self.OnStones) self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer) self.Bind(wx.EVT_CLOSE, self.OnClose) # self.timer2 = wx.Timer(self) self.timer2.Start(100) self.Bind(wx.EVT_TIMER, self.OnTimer2, self.timer2) #定时函数 def OnClk(self, event): '''定时的时间设置事件处理''' clktime = wx.GetNumberFromUser(message='ms为单位:', prompt='', caption="定时器的间隔时间", value=self.clktime, min=0, max=60000) if clktime >= 0: self.clktime = clktime if self.timer.IsRunning(): self.timer.Start(self.clktime) def OnQuk(self, event): '''快速''' self.putstone(-1) def OnMan(self, event): '''手动''' self.timer.Stop() def OnAut(self, event): '''自动''' self.timer.Start(self.clktime) def OnTimer(self, event): self.putstone() def OnTimer2(self, event): self.board.Refresh(False) #所有的创建函数 def createMenuBar(self): menuMode = wx.Menu() mine = menuMode.AppendRadioItem(-1, "我的棋谱") expert = menuMode.AppendRadioItem(-1, "职业棋谱") dingsi = menuMode.AppendRadioItem(-1, "定式题") sihuo = menuMode.AppendRadioItem(-1, "死活题") self.Bind(wx.EVT_MENU, self.OnMine, mine) self.Bind(wx.EVT_MENU, self.OnExpert, expert) self.Bind(wx.EVT_MENU, self.OnDingsi, dingsi) self.Bind(wx.EVT_MENU, self.OnSihuo, sihuo) menuEdit = wx.Menu() newb = menuEdit.Append(-1, "新建") daka = menuEdit.Append(-1, "打开") dele = menuEdit.Append(-1, "删除") clea = menuEdit.Append(-1, "重新") save = menuEdit.Append(me_save, "保存") saveAs = menuEdit.Append(me_saveAs, "另存为") self.Bind(wx.EVT_MENU, self.OnNewb, newb) self.Bind(wx.EVT_MENU, self.OnSave, save) self.Bind(wx.EVT_MENU, self.OnSaveAs, saveAs) self.Bind(wx.EVT_MENU, self.OnDaka, daka) self.Bind(wx.EVT_MENU, self.OnDele, dele) self.Bind(wx.EVT_MENU, self.OnClea, clea) menuClok = wx.Menu() man = menuClok.Append(-1, "手动") aut = menuClok.Append(-1, "自动") quk = menuClok.Append(-1, "快速") clk = menuClok.Append(-1, "定时的时间") self.Bind(wx.EVT_MENU, self.OnQuk, quk) self.Bind(wx.EVT_MENU, self.OnMan, man) self.Bind(wx.EVT_MENU, self.OnAut, aut) self.Bind(wx.EVT_MENU, self.OnClk, clk) menuSets = wx.Menu() num = menuSets.AppendCheckItem(-1, "显示数字") num.Check(True) self.enableEdit = menuSets.AppendCheckItem(-1, "可写入") self.enableEdit.Check(True) resetHistory = menuSets.Append(-1, "显示历史记录") resetStones = menuSets.Append(-1, "显示下棋位置") self.Bind(wx.EVT_MENU, self.OnNum, num) self.Bind(wx.EVT_MENU, self.OnEnableEdit, self.enableEdit) self.Bind(wx.EVT_MENU, self.OnResetHistory, resetHistory) self.Bind(wx.EVT_MENU, self.OnResetStones, resetStones) menuOutIn = wx.Menu() imag = menuOutIn.Append(-1, "导出图片") outsgf = menuOutIn.Append(-1, "导出sgf文件") insgf = menuOutIn.Append(-1, "导入sgf文件") insgfs = menuOutIn.Append(-1, "导入sgf文件目录") self.Bind(wx.EVT_MENU, self.OnImag, imag) self.Bind(wx.EVT_MENU, self.OnOutsgf, outsgf) self.Bind(wx.EVT_MENU, self.OnInsgf, insgf) self.Bind(wx.EVT_MENU, self.OnInsgfs, insgfs) menuOthers = wx.Menu() tip = menuOthers.Append(-1, "提示") daan = menuOthers.Append(me_daan, "插入断点") self.Bind(wx.EVT_MENU, self.OnTip, tip) self.Bind(wx.EVT_MENU, self.OnPos, daan) menuAbout = wx.Menu() author = menuAbout.Append(-1, "联系作者") bangzhu = menuAbout.Append(-1, "在线使用帮助") self.Bind(wx.EVT_MENU, self.OnAuthor, author) self.Bind(wx.EVT_MENU, self.OnBangzhu, bangzhu) menuBar = wx.MenuBar() menuBar.Append(menuMode, "模式") menuBar.Append(menuEdit, "编辑") menuBar.Append(menuClok, "定时") menuBar.Append(menuSets, "设置") menuBar.Append(menuOutIn, "导入导出") menuBar.Append(menuOthers, "其他") menuBar.Append(menuAbout, "关于") self.SetMenuBar(menuBar) def createIcon(self): '''设置图标''' icon = wx.Icon(name='图标.jpg', type=wx.BITMAP_TYPE_JPEG) self.SetIcon(icon) def createStatusBar(self): self.statusBar = self.CreateStatusBar() self.statusBar.SetFieldsCount(4) self.statusBar.SetStatusWidths([-1, -1, -3, -3]) self.statusBar.SetStatusText("编辑状态:", 0) self.statusBar.SetStatusText(str(self.enableEdit.IsChecked()), 1) #所有的模式函数 def OnMine(self, event): self._change_mode(mine) def OnExpert(self, event): self._change_mode(expert) def OnDingsi(self, event): self._change_mode(dingsi, False) def OnSihuo(self, event): self._change_mode(sihuo, False) def _change_mode(self, mode, enableClock=True): self.timer.Stop() self.mode = mode menuBar = self.GetMenuBar() menuBar.EnableTop(2, enableClock) self.history.Set(self.mode.titles) #所有的编辑函数 def OnNewb(self, event): '''新建操作处理''' self.clea() self.mode.id = None self.enableEdit.Check(True) self.statusBar.SetStatusText(str(self.enableEdit.IsChecked()), 1) def OnSave(self, event): '''保存事件处理''' self.mode.save(dataBoard.nodes) self.history.Set(self.mode.titles) def OnSaveAs(self, event): self.mode.id = None self.OnSave(event) def OnClea(self, event): '''重新事件处理''' self.clea() self.mode.open() def OnDaka(self, event): '''打开事件处理''' self.clea() self.enableEdit.Check(False) self.statusBar.SetStatusText(str(self.enableEdit.IsChecked()), 1) self.mode.open(self.selectedId) if hasattr(self.mode, 'pos'): self.putstone(self.mode.pos) self.SetTitle(self.mode.title) def OnDele(self, event): '''删除事件处理''' self.mode.delete(self.selectedId) self.history.Set(self.mode.titles) #设置的函数 def OnNum(self, event): '''数字显示''' self.board.setShowNumber(event.IsChecked()) def OnEnableEdit(self, event): '''写入保护''' self.statusBar.SetStatusText(str(self.enableEdit.IsChecked()), 1) def OnResetHistory(self, event): '''重新显示历史记录''' pane = self._mgr.GetPane(self.history) if not pane.IsShown(): pane.Show() self._mgr.Update() def OnResetStones(self, event): '''重新显示下棋位置''' pane = self._mgr.GetPane(self.stones) if not pane.IsShown(): pane.Show() self._mgr.Update() def OnStones(self, event): num = self.stones.GetSelection() + 1 if self.mode.id is None: self.mode.nodes = dataBoard.nodes[:num] else: self.mode.open() dataBoard.clear() self.putstone(num) @property def selectedId(self): num = self.history.GetSelection() id = self.history.GetString(num).strip('()').split(',')[0] return id #导入导出的函数 def OnImag(self, event): self.board.saveImage() def OnInsgf(self, event): '''导入sgf文件''' file_wildcard = '*.sgf' dlg = wx.FileDialog(self, "选择sgf棋谱文件", os.getcwd(), wildcard=file_wildcard) if dlg.ShowModal() == wx.ID_OK: self.filename = dlg.GetPath() sgf.read(self.filename, self.mode) self.history.Set(self.mode.titles) dlg.Destroy() def OnInsgfs(self, event): '''导入sgf文件夹''' dlg = wx.DirDialog(self, "选择文件夹", style=wx.DD_DEFAULT_STYLE) if dlg.ShowModal() == wx.ID_OK: sgf.readdir(dlg.GetPath(), self.mode) self.history.Set(self.mode.titles) dlg.Destroy() def OnOutsgf(self, event): '''导出sgf文件''' sgf.write(self.mode) #其他 def OnTip(self, event): s = [node_str(*node) for node in self.mode.nodes] wx.MessageBox(str(s), caption="围棋记录", style=wx.OK) def OnPos(self, event): num = wx.GetNumberFromUser(message='', prompt='', caption="插入的断点", value=0, min=0, max=len(dataBoard.nodes)) if num != -1: self.mode.pos = num #关于 def OnAuthor(self, event): wx.MessageBox("*****@*****.**", caption="作者邮箱", style=wx.OK) def OnBangzhu(self, event): webbrowser.open('https://sooheng.github.io') ## def OnLeftDown(self): if self.enableEdit.IsChecked( ) and self.board.xy and dataBoard.canPlace(*self.board.xy): #编辑写入 dataBoard.place(*self.board.xy) self.stones.Set(dataBoard.strnodes) self.board.Refresh(False) statusText = str(self.board.xy) self.board.xy = None else: #只可以读取 if self.mode in (mine, expert): self.putstone() statusText = str(dataBoard.hands) else: if self.mode.curentxy == self.board.xy: if self.mode is dingsi: self.putstone() else: self.putstone(2) statusText = "正确的位置" else: statusText = "错误的位置" self.statusBar.SetStatusText(statusText, 2) def OnClose(self, event): # deinitialize the frame manager self._mgr.UnInit() event.Skip() def clea(self): '''清空棋盘''' dataBoard.clear() self.board.Refresh(False) self.stones.Set(dataBoard.strnodes) def putstone(self, num=1): '''num 落子的数目,负数表示全部下完''' if num < 0: while self.mode.nodes: node = self.mode.nodes.pop(0) dataBoard.place(*node) else: for i in range(num): if self.mode.nodes: node = self.mode.nodes.pop(0) dataBoard.place(*node) else: break self.board.Refresh(False) self.stones.Set(dataBoard.strnodes) if not self.mode.nodes: wx.MessageBox("已经完成", caption="UjsGo", style=wx.OK)
def test_size_2_play_move(self): size = 2 goboard = GoBoard(size) goboard.play_move(goboard.pt(1, 1), BLACK) count = count_colors(goboard) self.assertEqual(count, [size * size - 1, 1, 0, 3 * (size + 1)])
font = pygame.font.SysFont("Crimson-Roman.ttf", 125) title = font.render(text, True, title_color) game_menu.blit(title, (150, 25)) #Global Variables mode = 0 #The different displays win = 0 #who won back = 0 #which display to back button goes to hover_pos = (-1, -1) #For the example display start_pvp = 0 #Did pvp start start_pva = 0 #Did pvai start difficulty = 0 #what difficulty ai turn = 0 #whos turn is it timer = 0 #delay for AI board = GoBoard() #The board the game is played on win_sequence = [] #The sequence of the winning tiles Ai = None #The Ai object board_history = None #The board history object last_black = None #Location of the latest black tile last_white = None #Location of the latest white tile is_crashed = False #Did the program crash def init_pvp(): #Initiates the pvp objects and variables global board global board_history global start_pva global start_pvp global turn
def __init__(self, go_engine, debug_mode = False): """ Play Go over a GTP connection Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands komi : float komi used for the current game board: GoBoard SIZExSIZE array representing the current board state """ self.stdout = sys.stdout self._debug_mode = debug_mode sys.stdout = self self.go_engine = go_engine self.go_engine.komi = 6.5 self.go_engine.selfatari = 1 self.go_engine.pattern = 1 self.board = GoBoard(7) self.mm_file_name = "features_mm_training.dat" self.init_mm_file = False self.num_game = 0 self.skip_counter = 0 self.param_options = { "selfatari" : self.go_engine.selfatari, "pattern" : self.go_engine.pattern } self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "policy_moves": self.policy_moves_cmd, "random_moves": self.random_moves_cmd, "go_param": self.go_param_cmd, "gogui-analyze_commands": self.gogui_analyze_cmd, "num_sim": self.num_sim_cmd, "showoptions": self.showoptions_cmd, "feature_move": self.feature_move_cmd, "features_mm_file": self.feature_mm_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (0, 'Usage: legal_moves does not have arguments'), "go_param": (2,'Usage: goparam {{{0}}} {{0,1}}'.format(' '.join(list(self.param_options.keys())))), "num_sim":(1,'Usage: num_sim #(e.g. num_sim 100 )'), "showoptions":(0,'Usage: showoptions does not have arguments'), "feature_move":(1,'Usage: feature_move move') }
def p_verse_p(): """ Game logic for the pvp mode, also the logic for the buttons and board for displaying. """ global back global board global hover_pos global last_black global last_white global mode global start_pvp global win if start_pvp == 0: init_pvp() start_pvp = 1 pygame.display.set_caption('Versus a Friend.') draw_board() pygame.display.update() clock.tick(60) # Frames per second. for event in pygame.event.get( ): # Creates a list of events that the user does with cursor. coord = pygame.mouse.get_pos() # Grabs the position of the mouse. if event.type == pygame.QUIT: crashed = True pygame.quit() quit() #on mouse releae if event.type == pygame.MOUSEBUTTONUP: if undo_button.hover(coord): if win == 0: undo() draw_board() elif play_help_button.hover(coord): back = 2 mode = 1 elif back_button.hover(coord): kill_pvp() mode = 0 elif reset_button.hover(coord): reset_pvp() click_x = coord[0] click_y = coord[1] #If mouse is close to grid find a position snapped to the grid if 45 < coord[0] < 493 and 45 < coord[1] < 493 and win == 0: if 30 > click_x: click_x = 30 click_x = click_x + 15 click_x = click_x - (click_x % 30) if 30 > click_y: click_y = 30 click_y = click_y + 15 click_y = click_y - (click_y % 30) #play #change it to the index click_x = (click_x - 60) // 30 click_y = (click_y - 60) // 30 else: click_x = -1 click_y = -1 if click_x != -1 and click_y != -1: if board == None: board = GoBoard() if board.set_token(click_x, click_y, turn + 1, get_colour(), board_history): if turn == 0: last_black = board.tokens_placed[ len(board.tokens_placed) - 1] else: last_white = board.tokens_placed[ len(board.tokens_placed) - 1] check_win() change_turn() draw_board() rand_int = random.randint(0, 2) pygame.mixer.music.load('sounds/place_' + str(rand_int) + '.mp3') pygame.mixer.music.set_volume(1.0) pygame.mixer.music.play(0) else: pygame.mixer.music.load('sounds/invalid.mp3') pygame.mixer.music.set_volume(0.2) pygame.mixer.music.play(0) #on mouse movement if event.type == pygame.MOUSEMOTION: if back_button.hover(coord): back_button.color = button_select_color play_help_button.color = button_color undo_button.color = button_color reset_button.color = button_color elif undo_button.hover(coord): undo_button.color = button_select_color back_button.color = button_color play_help_button.color = button_color reset_button.color = button_color elif play_help_button.hover(coord): play_help_button.color = button_select_color back_button.color = button_color undo_button.color = button_color reset_button.color = button_color elif reset_button.hover(coord): reset_button.color = button_select_color back_button.color = button_color play_help_button.color = button_color undo_button.color = button_color else: back_button.color = button_color play_help_button.color = button_color undo_button.color = button_color reset_button.color = button_color #if mouse near grid find a position snapped to the grid #This is saved for draw_board if 45 < coord[0] < 493 and 45 < coord[1] < 493 and win == 0: hov_x = coord[0] hov_y = coord[1] if 30 > hov_x: hov_x = 30 hov_x = hov_x + 15 hov_x = hov_x - (hov_x % 30) if 30 > hov_y: hov_y = 30 hov_y = hov_y + 15 hov_y = hov_y - (hov_y % 30) hover_pos = (hov_x - 13, hov_y - 13) else: hover_pos = (-1, -1)
class GtpConnection(): def __init__(self, go_engine, debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands debug_mode: prints debug messages """ self.stdout = sys.stdout sys.stdout = self self._debug_mode = debug_mode self.go_engine = go_engine self.komi = 0 self.board = GoBoard(7) self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, ### "timelimit": self.timelimit_cmd, "solve": self.solve_cmd, } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w, b}'), "timelimit": (1, 'Usage: timelimit seconds') } def __del__(self): sys.stdout = self.stdout def write(self, data): self.stdout.write(data) def flush(self): self.stdout.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0] args = elements[1:] if command_name == "play" and self.argmap[command_name][0] != len( args): self.respond('illegal move: {} wrong number of arguments'.format( args[0])) return if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format( traceback.format_exc())) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker funciton for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] > argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg=''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg) sys.stderr.flush() def error(self, error_msg=''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)) sys.stdout.flush() def respond(self, response=''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)) sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.komi = float(args[0]) self.respond() def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format( move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond(moves) except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color = GoBoardUtil.color_to_int(board_color) move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: return if not self.board.move(move, color): return self.respond() except Exception as e: self.respond("illegal move: {} {} {}".format( board_color, board_move, str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) # First try to solve the state and generate a best move to_play_bkp = self.board.to_play self.board.to_play = color score = self.board.call_search() if score == 1: # The player can win, make a move _, move = self.board.tree_cache[self.board] coord = GoBoardUtil.move_to_coord(move, self.board.size) point = self.board._coord_to_point(coord[0], coord[1]) self.board.move(point, color) self.respond(GoBoardUtil.format_point(coord)) return # Opponent can win or timeout, use the existing code to generate # a random move self.board.to_play = to_play_bkp move = self.go_engine.get_move(self.board, color) if move is None: # self.respond("pass") self.respond("resign") return if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e))) def timelimit_cmd(self, args): self.board.timelimit = int(args[0]) self.respond() def solve_cmd(self, args): self.board.hit = 0 score = self.board.call_search() # print('hit=', self.board.hit) if score == 0: # Timeout self.respond('unknown') elif score == 1: # The player can win _, move = self.board.tree_cache[self.board] self.respond('{} {}'.format( GoBoardUtil.int_to_color(self.board.to_play), move)) else: # The opponent can win self.respond( GoBoardUtil.int_to_color( GoBoardUtil.opponent(self.board.to_play))) sys.stderr.write('{} sec\n'.format(self.board.duration)) sys.stderr.flush()
def run(): """ start the gtp connection and wait for commands. """ board = GoBoard(7)
class GtpConnection(): def __init__(self, go_engine, debug_mode = False): """ Play Go over a GTP connection Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands komi : float komi used for the current game board: GoBoard SIZExSIZE array representing the current board state """ self.stdout = sys.stdout self._debug_mode = debug_mode sys.stdout = self self.go_engine = go_engine self.go_engine.komi = 6.5 self.go_engine.selfatari = 1 self.go_engine.pattern = 1 self.board = GoBoard(7) self.mm_file_name = "features_mm_training.dat" self.init_mm_file = False self.num_game = 0 self.skip_counter = 0 self.param_options = { "selfatari" : self.go_engine.selfatari, "pattern" : self.go_engine.pattern } self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "policy_moves": self.policy_moves_cmd, "random_moves": self.random_moves_cmd, "go_param": self.go_param_cmd, "gogui-analyze_commands": self.gogui_analyze_cmd, "num_sim": self.num_sim_cmd, "showoptions": self.showoptions_cmd, "feature_move": self.feature_move_cmd, "features_mm_file": self.feature_mm_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (0, 'Usage: legal_moves does not have arguments'), "go_param": (2,'Usage: goparam {{{0}}} {{0,1}}'.format(' '.join(list(self.param_options.keys())))), "num_sim":(1,'Usage: num_sim #(e.g. num_sim 100 )'), "showoptions":(0,'Usage: showoptions does not have arguments'), "feature_move":(1,'Usage: feature_move move') } def __del__(self): sys.stdout = self.stdout def write(self, data): self.stdout.write(data) def flush(self): self.stdout.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0]; args = elements[1:] if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format(traceback.format_exc())) traceback.print_exc(file=sys.stdout) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker function for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] != argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg = ''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg); sys.stderr.flush() def error(self, error_msg = ''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)); sys.stdout.flush() def respond(self, response = ''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)); sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) self.go_engine.reset() def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def showoptions_cmd(self,args): options = dict() options['komi'] = self.go_engine.komi options['pattern'] = self.go_engine.pattern options['selfatari'] = self.go_engine.selfatari options['num_sim'] = self.go_engine.num_simulation self.respond(options) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.go_engine.komi = float(args[0]) self.respond() def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format(move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for current player """ color = self.board.current_player legal_moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond(GoBoardUtil.sorted_point_string(legal_moves, self.board.NS)) def num_sim_cmd(self, args): self.go_engine.num_simulation = int(args[0]) self.respond() def go_param_cmd(self, args): valid_values = [0,1] valid_params = ['selfatari','pattern'] param = args[0] param_value = int(args[1]) if param not in valid_params: self.error('Unkown parameters: {}'.format(param)) if param_value not in valid_values: self.error('Argument 2 ({}) must be of type bool'.format(param_value)) if param ==valid_params[1]: self.go_engine.pattern = param_value elif param == valid_params[0]: self.go_engine.selfatari = param_value self.param_options[param] = param_value self.respond() def policy_moves_cmd(self, args): """ Return list of policy moves for the current_player of the board """ # Assignment4 - policy moves # ========================================= move_prob_tuples = self.get_move_prob() response = ' '.join([' '.join([t[0], '{:.5f}'.format(t[1])]) for t in move_prob_tuples]) self.respond(response) # ========================================= def random_moves_cmd(self, args): """ Return list of random moves (legal, but not eye-filling) """ moves = GoBoardUtil.generate_random_moves(self.board) if len(moves) == 0: self.respond("Pass") else: self.respond(GoBoardUtil.sorted_point_string(moves, self.board.NS)) def feature_move_cmd(self, args): move = None if args[0]=='PASS': move = 'PASS' else: move = GoBoardUtil.move_to_coord(args[0], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: self.error("Error in executing the move %s, check given move: %s"%(move,args[1])) return assert move != None response = [] features = Feature.find_move_feature(self.board, move) if features == None: self.respond(response) return for f in features: fn = Feature.find_feature_name(f) if fn != None: response.append(Feature.find_feature_name(f)) else: response.append(self.board.neighborhood_33_pattern_shape(move)) r = '\n'.join(response) self.respond(r) def init_mm_file_header(self): with open(self.mm_file_name ,'w') as header_writer: header_writer.write('! 1080\n') header_writer.write('8\n') header_writer.write('2 Feature_Pass\n') header_writer.write('1 Feature_Capture\n') header_writer.write('2 Feature_Atari\n') header_writer.write('1 Feature_SelfAtari\n') header_writer.write('3 Feature_DistanceLine\n') header_writer.write('8 Feature_DistancePrev\n') header_writer.write('9 Feature_DistancePrevOwn\n') header_writer.write('1054 Feature_Pattern\n') header_writer.write('!\n') header_writer.close() self.init_mm_file = True def feature_mm_cmd(self, args): if self.init_mm_file == False: self.init_mm_file_header() assert self.init_mm_file == True if len(self.board.moves) == 0: with open('game_num.txt', 'a') as file: self.num_game = self.num_game + 1 file.write('{}\n'.format(self.num_game)) file.close() self.respond() self.skip_counter = 0 return # skip the first five moves in the game records, since they are randomly selected if self.skip_counter <= 5: self.skip_counter += 1 self.respond() return chosenMove = self.board.last_move bd = self.board.copy() if chosenMove != -1: if chosenMove == None: chosenMove = 'PASS' bd.partial_undo_move() Feature.write_mm_file(bd, chosenMove, self.mm_file_name) if chosenMove == 'PASS': bd.move(None, bd.current_player) else: bd.move(chosenMove, bd.current_player) self.respond() def gogui_analyze_cmd(self, args): try: self.respond("pstring/Legal Moves/legal_moves\n" "pstring/Policy Moves/policy_moves\n" "pstring/Random Moves/random_moves\n" "none/Feature Move/feature_move %p\n" "none/Features MM File/features_mm_file\n" ) except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color= GoBoardUtil.color_to_int(board_color) if args[1].lower()=='pass': self.debug_msg("Player {} is passing\n".format(args[0])) self.go_engine.update('pass') #self.board.current_player = GoBoardUtil.opponent(color) self.board.move(None, color) self.respond() return move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: self.error("Error in executing the move %s, check given move: %s"%(move,args[1])) return if not self.board.move(move, color): self.respond("Illegal Move: {}".format(board_move)) return else: self.debug_msg("Move: {}\nBoard:\n{}\n".format(board_move, str(self.board.get_twoD_board()))) self.go_engine.update(move) self.respond() except Exception as e: self.respond("illegal move: {} {} {}".format(board_color, board_move, str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.go_engine.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) self.debug_msg("Board:\n{}\nko: {}\n".format(str(self.board.get_twoD_board()), self.board.ko_constraint)) # Assignment4 - policy probabilistic player # ========================================= if color != self.board.current_player: self.respond("Opponent's turn") return move_prob_tuples = self.get_move_prob() if move_prob_tuples[0][0] == 'pass': self.respond("pass") self.go_engine.update('pass') self.board.move(None, color) return # based on # https://docs.python.org/3.5/library/random.html population = [val for val, cnt in move_prob_tuples for _ in range(int(cnt*1e5))] move = random.choice(population) move = GoBoardUtil.move_to_coord(move, self.board.size) move = self.board._coord_to_point(move[0], move[1]) # ========================================= if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) traceback.print_exc(file=sys.stdout) self.respond('Error: {}'.format(str(e))) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format(move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e))) # Assignment4 # ========================================= def get_move_prob(self): moves = GoBoardUtil.generate_random_moves(self.board) # legal and not eye-filling features = Feature.find_all_features(self.board) gammas_sum = 0 move_gammas = dict() if len(Features_weight) != 0: for move in moves: move_gammas[move] = Feature.compute_move_gamma(Features_weight, features[move]) gammas_sum += move_gammas[move] # normalize to get probability if gammas_sum: for move in move_gammas.keys(): move_gammas[move] /= gammas_sum if move_gammas and gammas_sum: move_prob_tuples = [(self.board.point_to_string(k), v) for (k, v) in move_gammas.items()] # sort list by probability and alphabetic order # based on # http://stackoverflow.com/questions/5212870/sorting-a-python-list-by-two-criteria # answered by jaap on Stack Overflow http://stackoverflow.com/users/1186954/jaap move_prob_tuples = sorted(move_prob_tuples, key=lambda k:(-k[1], k[0][0], k[0][1])) else: move_prob_tuples = list() move_prob_tuples.append(('pass', 1)) return move_prob_tuples
def __init__(self): empty_board = GoBoard() self.boards = [empty_board]
class GtpConnection(): def __init__(self, go_engine, debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands debug_mode: prints debug messages """ self.stdout = sys.stdout sys.stdout = self self._debug_mode = debug_mode self.go_engine = go_engine self.komi = 0 self.board = GoBoard(7) self.notdone = False self.timelimit = 1 self.starttime = 0 self.winMoves = [] self.genCall = False self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "timelimit": self.timelimit_cmd, "solve": self.solve_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w, b}'), "timelimit": (1, 'Usage: timelimit seconds (1 <= seconds <= 100)') } def __del__(self): sys.stdout = self.stdout def write(self, data): self.stdout.write(data) def flush(self): self.stdout.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0] args = elements[1:] if command_name == "play" and self.argmap[command_name][0] != len( args): self.respond('illegal move: {} wrong number of arguments'.format( args[0])) return if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format( traceback.format_exc())) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker funciton for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] > argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg=''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg) sys.stderr.flush() def error(self, error_msg=''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)) sys.stdout.flush() def respond(self, response=''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)) sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.komi = float(args[0]) self.respond() def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format( move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond(moves) except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color = GoBoardUtil.color_to_int(board_color) move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: return if not self.board.move(move, color): return self.respond() except Exception as e: self.respond("illegal move: {} {} {}".format( board_color, board_move, str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: self.notdone = False board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) #TODO if self.board.get_winner() != None: self.respond("resign") return self.winMoves = [] self.genCall = True if args[0] != None: if args[0] == 'b': self.board.to_play = BLACK else: self.board.to_play = WHITE self.solve_cmd(args) self.genCall = False if len(self.winMoves) != 0: row, col = GoBoardUtil.move_to_coord(self.winMoves[0], self.board.size) move = self.board._coord_to_point(row, col) #self.respond(self.winMoves[0]) else: move = GoBoardUtil.generate_random_move(self.board, color) move = self.board._point_to_coord(move) move = GoBoardUtil.format_point(move) row, col = GoBoardUtil.move_to_coord(move, self.board.size) move = self.board._coord_to_point(row, col) #self.respond(move) if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e))) def timelimit_cmd(self, args): #TODO self.timelimit = int(args[0]) self.respond() def solve_cmd(self, args): #TODO self.winMoves = [] self.notdone = False state = self.board self.starttime = time.process_time() #win = self.negamaxBoolean(state,0) win = self.alphabeta(state, -100000, 100000, 0) stone = ['', 'b', 'w'] i = 1 if not self.genCall: if len(self.winMoves) != 0: s = stone[state.to_play] self.respond("{} {}".format(s, self.winMoves[0])) else: if self.notdone: self.respond("unknown") else: s = stone[GoBoardUtil.opponent(state.to_play)] self.respond(s) # helper function for solve # Success means: either a win, or toPlay is the DRAW_WINNER when its a draw def negamaxBoolean(self, state, depth): result = False duration = time.process_time() - self.starttime #if duration > self.timelimit: #self.notdone = True #print("[Unknown]\n") #return if state.get_winner() != None: return (state.get_winner() == state.to_play) for m in (GoBoardUtil.generate_legal_moves(state, state.to_play).split(' ')): point = GoBoardUtil.move_to_coord(m, state.size) point = state._coord_to_point(point[0], point[1]) state.move(point, state.to_play) success = not self.negamaxBoolean(state, depth + 1) state.board[point] = EMPTY state.to_play = GoBoardUtil.opponent(state.to_play) if success: if depth == 0: self.winMoves.append(m) result = True #if self.notdone: #return result return result def alphabeta(self, state, alpha, beta, d): duration = time.process_time() - self.starttime if self.notdone or self.winMoves != []: return 'a' if duration > self.timelimit: self.notdone = True #print("[Unknown]\n") return 'a' if state.get_winner() != None: return state.staticallyEvaluateForToPlay() for m in (GoBoardUtil.generate_legal_moves(state, state.to_play).split(' ')): point = GoBoardUtil.move_to_coord(m, state.size) point = state._coord_to_point(point[0], point[1]) state.move(point, state.to_play) try: value = -int(self.alphabeta(state, -beta, -alpha, d + 1)) except: state.board[point] = EMPTY state.to_play = GoBoardUtil.opponent(state.to_play) return 'a' state.board[point] = EMPTY state.to_play = GoBoardUtil.opponent(state.to_play) if value > alpha: alpha = value if d == 0 and value >= 0: self.winMoves.append(m) return 'a' if self.notdone or self.winMoves != []: return 'a' if value >= beta: return beta # or value in failsoft (later) return alpha
class GtpConnection(): def __init__(self, go_engine, debug_mode=False): """ object that plays Go using GTP Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands debug_mode: prints debug messages """ self.stdout = sys.stdout sys.stdout = self self._debug_mode = debug_mode self.go_engine = go_engine self.komi = 0 self.board = GoBoard(7) #added timelimit default here self.timelimit = 1 self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "timelimit": self.time_limit_cmd, "solve": self.solve_cmd, "legal_moves": self.legal_moves_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (1, 'Usage: legal_moves {w, b}') } def __del__(self): sys.stdout = self.stdout def write(self, data): self.stdout.write(data) def flush(self): self.stdout.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0] args = elements[1:] if command_name == "play" and self.argmap[command_name][0] != len( args): self.respond('illegal move: {} wrong number of arguments'.format( args[0])) return if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format( traceback.format_exc())) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker funciton for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] > argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg=''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg) sys.stderr.flush() def error(self, error_msg=''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)) sys.stdout.flush() def respond(self, response=''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)) sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.komi = float(args[0]) self.respond() def handler(signum, frame): print("Alarm went off, too slow") #JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJASON & DAVID NEW CODE STARTS HEREEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE #adding solve command, going to be using the signals def solve_cmd(self, args): try: signal.signal(signal.SIGALRM, self.handler) signal.alarm(self.timelimit) #get playmove colour somehow, pass it into solution function state, moves = self.board.negamaxBoolean() signal.alarm(0) if state == True: if self.board.to_play == 1: winner = "w" else: winner = "b" else: if self.board.to_play == 1: winner = "w" else: winner = "b" if moves != -1: moves = self.board._point_to_coord(moves) boob = self.format_point(moves) self.respond(winner + " " + boob) else: self.respond(winner) except (RuntimeError, TypeError, ValueError): self.respond("unknown") #adding timelimit set command, pretty self explanitory(done) def time_limit_cmd(self, args): self.timelimit = int(args[0]) #print("time set",args[0]) self.respond() def format_point(self, move): """ Return coordinates as a string like 'a1', or 'pass'. Arguments --------- move : (row, col), or None for pass Returns ------- The move converted from a tuple to a Go position (e.g. d4) """ column_letters = "abcdefghjklmnopqrstuvwxyz" if move is None: return "pass" row, col = move if not 0 <= row < 25 or not 0 <= col < 25: raise ValueError return column_letters[col - 1] + str(row) def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format( move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond(moves) except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color = GoBoardUtil.color_to_int(board_color) move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: return if not self.board.move(move, color): return self.respond() except Exception as e: self.respond("illegal move: {} {} {}".format( board_color, board_move, str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) move = self.go_engine.get_move(self.board, color) if move is None: #resign here self.respond("resign") return if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e)))
#!/usr/bin/python3 from board import GoBoard from board_util import GoBoardUtil, BLACK, WHITE, EMPTY, BORDER, FLOODFILL import numpy as np from Go5 import Go5Player import time board = GoBoard(4) player = Go5Player(num_simulation=200, limit=100, exploration=np.sqrt(2)) player.MCTS.komi = 6.5 player.num_nodes = 5 cboard = board.copy() print("\nrunning playout 200 times\n") player.run(cboard, BLACK, print_info=True) #time.sleep(30) # sleeping player.num_simulation = 300 print("\nrunning it 300 more times\n") cboard = board.copy() player.run(cboard, BLACK, print_info=True) #time.sleep(30) print("\nrunning it 300 more times\n") cboard = board.copy() player.run(cboard, BLACK, print_info=True) #time.sleep(30) print("\nrunning it 300 more times\n") cboard = board.copy() player.run(cboard, BLACK, print_info=True)
def pop(self): if len(self.boards) > 1: return self.boards.pop() else: return GoBoard()
class GtpConnection(): def __init__(self, go_engine, debug_mode=False): """ Play Go over a GTP connection Parameters ---------- go_engine: GoPlayer a program that is capable of playing go by reading GTP commands komi : float komi used for the current game board: GoBoard SIZExSIZE array representing the current board state """ self.stdout = sys.stdout self._debug_mode = debug_mode sys.stdout = self self.go_engine = go_engine self.go_engine.komi = 0 self.go_engine.selfatari = 1 self.go_engine.pattern = 1 self.board = GoBoard(7) self.param_options = { "selfatari": self.go_engine.selfatari, "pattern": self.go_engine.pattern } self.commands = { "protocol_version": self.protocol_version_cmd, "quit": self.quit_cmd, "name": self.name_cmd, "boardsize": self.boardsize_cmd, "showboard": self.showboard_cmd, "clear_board": self.clear_board_cmd, "komi": self.komi_cmd, "version": self.version_cmd, "known_command": self.known_command_cmd, "set_free_handicap": self.set_free_handicap, "genmove": self.genmove_cmd, "list_commands": self.list_commands_cmd, "play": self.play_cmd, "final_score": self.final_score_cmd, "legal_moves": self.legal_moves_cmd, "policy_moves": self.policy_moves_cmd, "random_moves": self.random_moves_cmd, "go_param": self.go_param_cmd, "gogui-analyze_commands": self.gogui_analyze_cmd, "num_sim": self.num_sim_cmd, "showoptions": self.showoptions_cmd } # used for argument checking # values: (required number or arguments, error message on argnum failure) self.argmap = { "boardsize": (1, 'Usage: boardsize INT'), "komi": (1, 'Usage: komi FLOAT'), "known_command": (1, 'Usage: known_command CMD_NAME'), "set_free_handicap": (1, 'Usage: set_free_handicap MOVE (e.g. A4)'), "genmove": (1, 'Usage: genmove {w, b}'), "play": (2, 'Usage: play {b, w} MOVE'), "legal_moves": (0, 'Usage: legal_moves does not have arguments'), "go_param": (2, 'Usage: goparam {{{0}}} {{0,1}}'.format(' '.join( list(self.param_options.keys())))), "num_sim": (1, 'Usage: num_sim #(e.g. num_sim 100 )'), "showoptions": (0, 'Usage: showoptions does not have arguments') } def __del__(self): sys.stdout = self.stdout def write(self, data): self.stdout.write(data) def flush(self): self.stdout.flush() def start_connection(self): """ start a GTP connection. This function is what continuously monitors the user's input of commands. """ self.debug_msg("Start up successful...\n\n") line = sys.stdin.readline() while line: self.get_cmd(line) line = sys.stdin.readline() def get_cmd(self, command): """ parse the command and execute it Arguments --------- command : str the raw command to parse/execute """ if len(command.strip(' \r\t')) == 0: return if command[0] == '#': return # Strip leading numbers from regression tests if command[0].isdigit(): command = re.sub("^\d+", "", command).lstrip() elements = command.split() if not elements: return command_name = elements[0] args = elements[1:] if self.arg_error(command_name, len(args)): return if command_name in self.commands: try: self.commands[command_name](args) except Exception as e: self.debug_msg("Error executing command {}\n".format(str(e))) self.debug_msg("Stack Trace:\n{}\n".format( traceback.format_exc())) raise e else: self.debug_msg("Unknown command: {}\n".format(command_name)) self.error('Unknown command') sys.stdout.flush() def arg_error(self, cmd, argnum): """ checker function for the number of arguments given to a command Arguments --------- cmd : str the command name argnum : int number of parsed argument Returns ------- True if there was an argument error False otherwise """ if cmd in self.argmap and self.argmap[cmd][0] != argnum: self.error(self.argmap[cmd][1]) return True return False def debug_msg(self, msg=''): """ Write a msg to the debug stream """ if self._debug_mode: sys.stderr.write(msg) sys.stderr.flush() def error(self, error_msg=''): """ Send error msg to stdout and through the GTP connection. """ sys.stdout.write('? {}\n\n'.format(error_msg)) sys.stdout.flush() def respond(self, response=''): """ Send msg to stdout """ sys.stdout.write('= {}\n\n'.format(response)) sys.stdout.flush() def reset(self, size): """ Resets the state of the GTP to a starting board Arguments --------- size : int the boardsize to reinitialize the state to """ self.board.reset(size) def protocol_version_cmd(self, args): """ Return the GTP protocol version being used (always 2) """ self.respond('2') def quit_cmd(self, args): """ Quit game and exit the GTP interface """ self.respond() exit() def name_cmd(self, args): """ Return the name of the player """ self.respond(self.go_engine.name) def version_cmd(self, args): """ Return the version of the player """ self.respond(self.go_engine.version) def clear_board_cmd(self, args): """ clear the board """ self.reset(self.board.size) self.respond() def boardsize_cmd(self, args): """ Reset the game and initialize with a new boardsize Arguments --------- args[0] : int size of reinitialized board """ self.reset(int(args[0])) self.respond() def showboard_cmd(self, args): self.respond('\n' + str(self.board.get_twoD_board())) def showoptions_cmd(self, args): options = dict() options['komi'] = self.go_engine.komi options['pattern'] = self.go_engine.pattern options['selfatari'] = self.go_engine.selfatari options['num_sim'] = self.go_engine.num_simulation self.respond(options) def komi_cmd(self, args): """ Set the komi for the game Arguments --------- args[0] : float komi value """ self.go_engine.komi = float(args[0]) self.respond() def known_command_cmd(self, args): """ Check if a command is known to the GTP interface Arguments --------- args[0] : str the command name to check for """ if args[0] in self.commands: self.respond("true") else: self.respond("false") def list_commands_cmd(self, args): """ list all supported GTP commands """ self.respond(' '.join(list(self.commands.keys()))) def set_free_handicap(self, args): """ clear the board and set free handicap for the game Arguments --------- args[0] : str the move to handicap (e.g. B2) """ self.board.reset(self.board.size) for point in args: move = GoBoardUtil.move_to_coord(point, self.board.size) point = self.board._coord_to_point(*move) if not self.board.move(point, BLACK): self.debug_msg("Illegal Move: {}\nBoard:\n{}\n".format( move, str(self.board.get_twoD_board()))) self.respond() def legal_moves_cmd(self, args): """ list legal moves for current player """ color = self.board.current_player legal_moves = GoBoardUtil.generate_legal_moves(self.board, color) self.respond( GoBoardUtil.sorted_point_string(legal_moves, self.board.NS)) def num_sim_cmd(self, args): self.go_engine.num_simulation = int(args[0]) self.respond() def go_param_cmd(self, args): valid_values = [0, 1] valid_params = ['selfatari', 'pattern'] param = args[0] param_value = int(args[1]) if param not in valid_params: self.error('Unkown parameters: {}'.format(param)) if param_value not in valid_values: self.error( 'Argument 2 ({}) must be of type bool'.format(param_value)) if param == valid_params[1]: self.go_engine.pattern = param_value elif param == valid_params[0]: self.go_engine.selfatari = param_value self.param_options[param] = param_value self.respond() def policy_moves_cmd(self, args): """ Return list of policy moves for the current_player of the board """ policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves( self.board, self.go_engine.pattern, self.go_engine.selfatari) if len(policy_moves) == 0: self.respond("Pass") else: response = type_of_move + " " + GoBoardUtil.sorted_point_string( policy_moves, self.board.NS) self.respond(response) def random_moves_cmd(self, args): """ Return list of random moves (legal, but not eye-filling) """ moves = GoBoardUtil.generate_random_moves(self.board) if len(moves) == 0: self.respond("Pass") else: self.respond(GoBoardUtil.sorted_point_string(moves, self.board.NS)) def gogui_analyze_cmd(self, args): try: self.respond("pstring/Legal Moves/legal_moves\n" "pstring/Policy Moves/policy_moves\n" "pstring/Random Moves/random_moves\n") except Exception as e: self.respond('Error: {}'.format(str(e))) def play_cmd(self, args): """ play a move as the given color Arguments --------- args[0] : {'b','w'} the color to play the move as it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} args[1] : str the move to play (e.g. A5) """ try: board_color = args[0].lower() board_move = args[1] color = GoBoardUtil.color_to_int(board_color) if args[1].lower() == 'pass': self.debug_msg("Player {} is passing\n".format(args[0])) self.board.current_player = GoBoardUtil.opponent(color) self.respond() return move = GoBoardUtil.move_to_coord(args[1], self.board.size) if move: move = self.board._coord_to_point(move[0], move[1]) else: self.error( "Error in executing the move %s, check given move: %s" % (move, args[1])) return if not self.board.move(move, color): self.respond("Illegal Move: {}".format(board_move)) return else: self.debug_msg("Move: {}\nBoard:\n{}\n".format( board_move, str(self.board.get_twoD_board()))) self.respond() except Exception as e: self.respond("illegal move: {} {} {}".format( board_color, board_move, str(e))) def final_score_cmd(self, args): self.respond(self.board.final_score(self.go_engine.komi)) def genmove_cmd(self, args): """ generate a move for the specified color Arguments --------- args[0] : {'b','w'} the color to generate a move for it gets converted to Black --> 1 White --> 2 color : {0,1} board_color : {'b','w'} """ try: board_color = args[0].lower() color = GoBoardUtil.color_to_int(board_color) self.debug_msg("Board:\n{}\nko: {}\n".format( str(self.board.get_twoD_board()), self.board.ko_constraint)) #move = self.go_engine.get_move(self.board, color) policy_moves, type_of_move = GoBoardUtil.generate_all_policy_moves( self.board, self.go_engine.pattern, self.go_engine.selfatari, color) if len(policy_moves) == 0: self.respond("Pass") else: #print(policy_moves) move = policy_moves[randint(0, len(policy_moves) - 1)] #print(move) #move = GoBoardUtil.point_to_coord(move) #move = GoBoardUtil.sorted_point_string(policy_moves[randint(0,len(policy_moves)-1)], self.board.NS) #print(move) #print(move) #response = type_of_move + " " + GoBoardUtil.sorted_point_string(policy_moves, self.board.NS) #self.respond(response) if move is None: self.respond("pass") return if not self.board.check_legal(move, color): move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond("Illegal move: {}".format(board_move)) raise RuntimeError("Illegal move given by engine") # move is legal; play it self.board.move(move, color) self.debug_msg("Move: {}\nBoard: \n{}\n".format( move, str(self.board.get_twoD_board()))) move = self.board._point_to_coord(move) board_move = GoBoardUtil.format_point(move) self.respond(board_move) except Exception as e: self.respond('Error: {}'.format(str(e)))
def boardData(self, depth, board, m): # Store the {depth:{state: (winner, move), ...}, ...} self.boarddic[depth][board.get_twoD_board().tostring()] = ( board.to_play, m) # optimize 2 boardarr = board.get_twoD_board() blist = [] blist.append(boardarr.tostring()) for i in range(0, 7): emptyboard = GoBoard(board.size) emptyboard.move(m, 1) if i == 0: b = np.rot90(boardarr) if b.tostring() in blist: continue empty_move = np.rot90(emptyboard.get_twoD_board()) elif i == 1: b = np.rot90(boardarr, 2) if b.tostring() in blist: continue empty_move = np.rot90(emptyboard.get_twoD_board(), 2) elif i == 2: b = np.rot90(boardarr, 3) if b.tostring() in blist: continue empty_move = np.rot90(emptyboard.get_twoD_board(), 3) elif i == 3: b = np.fliplr(boardarr) if b.tostring() in blist: continue empty_move = np.fliplr(emptyboard.get_twoD_board()) elif i == 4: b = np.flipud(boardarr) if b.tostring() in blist: continue empty_move = np.flipud(emptyboard.get_twoD_board()) elif i == 5: b = np.fliplr(np.rot90(boardarr)) if b.tostring() in blist: continue empty_move = np.fliplr(np.rot90(emptyboard.get_twoD_board())) else: b = np.flipud(np.rot90(boardarr)) if b.tostring() in blist: continue empty_move = np.flipud(np.rot90(emptyboard.get_twoD_board())) blist.append(b.tostring()) index = np.where(empty_move == 1) r, c = index[0][0] + 1, index[1][0] + 1 new_move = board._coord_to_point(r, c) self.boarddic[depth][b.tostring()] = (board.to_play, new_move)