def test_encoding(tc):
g1 = sgf.Sgf_game(19)
tc.assertEqual(g1.get_charset(), "UTF-8")
root = g1.get_root()
tc.assertEqual(root.get_encoding(), "UTF-8")
root.set("C", "£")
tc.assertEqual(root.get("C"), "£")
tc.assertEqual(root.get_raw("C"), "£".encode("utf-8"))
tc.assertEqual(
g1.serialise(),
dedent("""\
(;FF[4]C[£]CA[UTF-8]GM[1]SZ[19])
""".encode("utf-8")))
g2 = sgf.Sgf_game(19, encoding="iso-8859-1")
tc.assertEqual(g2.get_charset(), "ISO-8859-1")
root = g2.get_root()
tc.assertEqual(root.get_encoding(), "ISO-8859-1")
root.set("C", "£")
tc.assertEqual(root.get("C"), "£")
tc.assertEqual(root.get_raw("C"), b"\xa3")
tc.assertEqual(
g2.serialise(),
dedent(b"""\
(;FF[4]C[\xa3]CA[ISO-8859-1]GM[1]SZ[19])
"""))
tc.assertRaisesRegex(ValueError, "unknown encoding: unknownencoding",
sgf.Sgf_game, 19, "unknownencoding")
tc.assertRaisesRegex(ValueError, "encoding names must be ascii",
sgf.Sgf_game, 19, "£")
def save_game_sgf(model_name, game_n, game_data):
game = sgf.Sgf_game(size=SIZE)
modelB_name = game_data['modelB_name']
modelW_name = game_data['modelW_name']
result = game_data['result']
game.root.set_raw("PB", modelB_name.encode('utf-8'))
game.root.set_raw("PW", modelW_name.encode('utf-8'))
game.root.set_raw("KM", str(conf['KOMI']).encode('utf-8'))
game.root.set_raw("RE", result.encode('utf-8'))
for move_data in game_data['moves']:
node = game.extend_main_sequence()
color = 'b' if move_data['player'] == 1 else 'w'
x, y = move_data['move']
move = (SIZE - 1 - y, x) if y != SIZE else None # Different orienation
move_n = move_data['move_n']
next_board = game_data['moves'][(move_n + 1) % len(game_data['moves'])]['board']
comment = "Value %s\nPlayer %s\nMove %s\nMove sgf %s, %s\n %s" % (move_data['value'], move_data['player'], move_data['move'], color, move, get_real_board(next_board))
node.set("C", comment)
node.set_move(color, move)
filename = os.path.join(conf["GAMES_DIR"], model_name, "game_%03d.sgf" % game_n)
with open(filename, "wb") as f:
f.write(game.serialise())
def save_sgf(self, filename=None):
"""Saves recognition results to specified file (SGF)"""
def _add_stone(game, bw, stone):
node = game.extend_main_sequence()
node.set_move(bw, (stone[GR_B] - 1, stone[GR_A] - 1))
if self._res is None:
raise Exception("Recognition results are not available")
if filename is None:
filename = str(Path(self._img_file).with_suffix('.sgf'))
game = sgf.Sgf_game(size=self.board_size)
bs = self.black_stones
ws = self.white_stones
for n in range(max(len(bs), len(ws))):
if n < len(bs):
_add_stone(game, STONE_BLACK.lower(), bs[n])
if n < len(ws):
_add_stone(game, STONE_WHITE.lower(), ws[n])
with open(filename, "wb") as f:
f.write(game.serialise())
f.close()
return filename
def test_add_comment_text(tc):
sgf_game = sgf.Sgf_game(9)
root = sgf_game.get_root()
root.add_comment_text("hello\nworld")
tc.assertEqual(root.get('C'), "hello\nworld")
root.add_comment_text("hello\naga]in")
tc.assertEqual(root.get('C'), "hello\nworld\n\nhello\naga]in")
def test_get_setup_and_moves(tc):
g1 = sgf.Sgf_game.from_string(SAMPLE_SGF)
board1, plays1 = sgf_moves.get_setup_and_moves(g1)
tc.assertBoardEqual(board1, DIAGRAM1)
tc.assertEqual(plays1, [('b', (2, 3)), ('w', (3, 4)), ('b', None),
('w', None)])
g2 = sgf.Sgf_game(size=9)
root = g2.get_root()
root.set("AB", [(1, 2), (3, 4)])
node = g2.extend_main_sequence()
node.set("B", (5, 6))
node = g2.extend_main_sequence()
node.set("W", (5, 7))
board2, plays2 = sgf_moves.get_setup_and_moves(g2)
tc.assertBoardEqual(board2, DIAGRAM2)
tc.assertEqual(plays2, [('b', (5, 6)), ('w', (5, 7))])
g3 = sgf.Sgf_game.from_string("(;AB[ab][ba]AW[aa])")
tc.assertRaisesRegex(ValueError, "setup position not legal",
sgf_moves.get_setup_and_moves, g3)
g4 = sgf.Sgf_game.from_string("(;SZ[9];B[ab];AW[bc])")
tc.assertRaisesRegex(ValueError, "setup properties after the root node",
sgf_moves.get_setup_and_moves, g4)
g5 = sgf.Sgf_game.from_string("(;SZ[26];B[ab];W[bc])")
board5, plays5 = sgf_moves.get_setup_and_moves(g5)
tc.assertEqual(plays5, [('b', (24, 0)), ('w', (23, 1))])
def test_get_winner(tc):
def gw(raw_result):
g = sgf.Sgf_game(19)
g.get_root().set_raw('RE', raw_result)
return g.get_winner()
tc.assertIs(sgf.Sgf_game(19).get_winner(), None)
tc.assertIs(gw(b'0'), None)
tc.assertIs(gw(b''), None)
tc.assertIs(gw(b'Void'), None)
tc.assertIs(gw(b'Draw'), None)
tc.assertIs(gw(b'Jigo'), None)
tc.assertIs(gw(b'?'), None)
tc.assertEqual(gw(b'B+'), 'b')
tc.assertEqual(gw(b'W+'), 'w')
tc.assertEqual(gw(b'B+0.5'), 'b')
tc.assertEqual(gw(b'W+64'), 'w')
tc.assertEqual(gw(b'B+R'), 'b')
tc.assertEqual(gw(b'W+R'), 'w')
tc.assertEqual(gw(b'B+Resign'), 'b')
tc.assertEqual(gw(b'W+Resign'), 'w')
tc.assertEqual(gw(b'B+T'), 'b')
tc.assertEqual(gw(b'W+T'), 'w')
tc.assertEqual(gw(b'B+Time'), 'b')
tc.assertEqual(gw(b'W+Time'), 'w')
tc.assertEqual(gw(b'B+F'), 'b')
tc.assertEqual(gw(b'W+F'), 'w')
tc.assertEqual(gw(b'B+Forfeit'), 'b')
tc.assertEqual(gw(b'W+Forfeit'), 'w')
# Not allowed by spec
tc.assertEqual(gw(b'B'), 'b')
tc.assertEqual(gw(b'W'), 'w')
def create_empty(self, played='w'):
self.game = sgf.Sgf_game(size=self.board_size, encoding="UTF-8")
self.game.set_date()
root_node = self.game.get_root()
root_node.set("KM", self.komi)
self.curr_node = self.game.get_root()
def mat_to_sgf(mat, pathname):
"""Saves matrix of game state as sgf file.
Expects 19x19 numpy matrix with '0' for empty, '1' for black and '2' for
white stones.
"""
mat = np.flipud(mat) # sgf editors start coordinates in lower left
game = sgf.Sgf_game(size=19)
game.set_date()
board = boards.Board(19)
# TODO: determine points from mat
black_points = []
white_points = []
empty_points = []
for row in range(19):
for col in range(19):
stone = mat.item((row, col))
if stone == 1:
black_points.append((row, col))
if stone == 2:
white_points.append((row, col))
if stone == 0:
empty_points.append((row, col))
board.apply_setup(black_points, white_points, empty_points)
sgf_moves.set_initial_position(game, board)
with open(pathname, "wb") as f:
f.write(game.serialise())
print(f'Saved game position as {pathname}\n')
def test_set_initial_position(tc):
board = ascii_boards.interpret_diagram(DIAGRAM1, 9)
sgf_game = sgf.Sgf_game(9)
sgf_moves.set_initial_position(sgf_game, board)
root = sgf_game.get_root()
tc.assertEqual(root.get("AB"), {(0, 0), (1, 1), (4, 4)})
tc.assertEqual(root.get("AW"), {(6, 5), (6, 6)})
tc.assertRaises(KeyError, root.get, 'AE')
def test_set_date(tc):
g = sgf.Sgf_game(19)
g.set_date(datetime.date(1846, 9, 11))
tc.assertEqual(g.get_root().get_raw("DT"), b"1846-09-11")
g.set_date(None)
s = g.get_root().get_raw("DT").decode()
tc.assertEqual(datetime.datetime.strptime(s, "%Y-%m-%d").date(),
datetime.date.today())
def save_sgf(self, path):
game = sgf.Sgf_game(self.board.side)
sgf_moves.set_initial_position(game, self.board)
game_bytes = game.serialise()
with open(path, "wb") as f:
f.write(game_bytes)
f.close()
def __init__(self, size):
# numpy array of GridSquares
self.board = self._init_board(size)
self.board_sz = size
self.sgf_game = sgf.Sgf_game(size=size)
# keeps track of board history for 'ko' rule
self.board_hist = [copy.deepcopy(self.board)]
def test_get_handicap(tc):
def gh(raw_handicap):
g = sgf.Sgf_game(19)
g.get_root().set_raw('HA', raw_handicap)
return g.get_handicap()
tc.assertIs(sgf.Sgf_game(19).get_handicap(), None)
tc.assertEqual(gh(b'9'), 9)
tc.assertEqual(gh(b'2'), 2)
tc.assertRaises(ValueError, gh, b'1')
# Not strictly allowed by spec
tc.assertEqual(gh(b'0'), None)
def test_get_setup_and_moves_move_in_root(tc):
# A move in the root node is allowed (though deprecated) if there are no
# setup stones.
g1 = sgf.Sgf_game(size=9)
root = g1.get_root()
root.set("B", (1, 2))
node = g1.extend_main_sequence()
node.set("W", (3, 4))
board1, plays1 = sgf_moves.get_setup_and_moves(g1)
tc.assertTrue(board1.is_empty())
tc.assertEqual(plays1, [('b', (1, 2)), ('w', (3, 4))])
g2 = sgf.Sgf_game(size=9)
root = g2.get_root()
root.set("B", (1, 2))
root.set("AW", [(3, 3)])
node = g2.extend_main_sequence()
node.set("W", (3, 4))
tc.assertRaisesRegex(ValueError, "mixed setup and moves in root node",
sgf_moves.get_setup_and_moves, g2)
def merge_sgf_collection(pathname, add_wc_c, clean_sgf, sort):
if _sgf_merge_verbose:
print("Asked for verbose output", file=sys.stderr)
# read games collection file
f = open(pathname, "rb")
sgf_src = f.read()
f.close()
dirname, basename = os.path.split(pathname)
root, ext = os.path.splitext(basename)
dstname = os.path.join(dirname, root + "_merged" + ext)
try:
if clean_sgf: # replace fake new lines "\\n" with true ones "\n"!
sgf_src = sgf_src.replace(b"\\n", b"\n")
coarse_games = sgf_grammar.parse_sgf_collection(sgf_src)
except ValueError as e:
raise Exception("error parsing file: %s" % e)
print("Read %d games" % len(coarse_games))
# create a dictionary of pair of players -> list of games
all_pairings = defaultdict(list)
for coarse_game in coarse_games:
sgf_game = sgf.Sgf_game.from_coarse_game_tree(coarse_game)
players_pair = sgf_game.get_player_name('b'), sgf_game.get_player_name(
'w')
all_pairings[players_pair].append(sgf_game)
print("Games grouped in %d player pairs" % len(all_pairings))
with open(dstname, "wb") as f:
for games in all_pairings.values():
print("Merging %d games for players: %s vs %s" %
(len(games), games[0].get_player_name('b'),
games[0].get_player_name('w')))
merged_game = sgf.Sgf_game(games[0].get_size())
for game in games:
_merge_with(merged_game.get_root(), game.get_root(),
game.get_winner())
print("Win counters for merged game: %s" %
merged_game.get_root().get(WC_id))
if sort:
_sort_children(merged_game.get_root())
if add_wc_c:
_add_wincounters_to_comments(merged_game.get_root())
f.write(merged_game.serialise())
def test_extend_main_sequence(tc):
g1 = sgf.Sgf_game(9)
for i in range(6):
g1.extend_main_sequence().set("N", "e%d" % i)
tc.assertEqual(
g1.serialise(),
b"(;FF[4]CA[UTF-8]GM[1]SZ[9];N[e0];N[e1];N[e2];N[e3];N[e4];N[e5])\n")
g2 = sgf.Sgf_game.from_bytes(b"(;SZ[9](;N[n1];N[n3])(;N[n2]))")
for i in range(6):
g2.extend_main_sequence().set("N", "e%d" % i)
tc.assertEqual(
g2.serialise(),
b"(;SZ[9](;N[n1];N[n3];N[e0];N[e1];N[e2];N[e3];N[e4];N[e5])(;N[n2]))\n")
def test_new_sgf_game(tc):
g1 = sgf.Sgf_game(9)
tc.assertEqual(g1.get_size(), 9)
root = g1.get_root()
tc.assertEqual(root.get_raw('FF'), b'4')
tc.assertEqual(root.get_raw('GM'), b'1')
tc.assertEqual(root.get_raw('SZ'), b'9')
tc.assertEqual(root.get_raw_property_map(), {
'FF': [b'4'],
'GM': [b'1'],
'SZ': [b'9'],
'CA': [b'UTF-8'],
})
tc.assertEqual(list(root), [])
tc.assertEqual(root.parent, None)
tc.assertIs(root.owner, g1)
def test_reparent(tc):
g1 = sgf.Sgf_game.from_bytes(b"(;SZ[9](;N[n1];N[n3])(;N[n2]))")
root = g1.get_root()
# Test with unexpanded root
tc.assertRaisesRegex(ValueError, "would create a loop", root.reparent,
root)
n1 = root[0]
n2 = root[1]
n3 = root[0][0]
tc.assertEqual(n1.get("N"), "n1")
tc.assertEqual(n2.get("N"), "n2")
tc.assertEqual(n3.get("N"), "n3")
n3.reparent(n2)
tc.assertEqual(g1.serialise(), b"(;SZ[9](;N[n1])(;N[n2];N[n3]))\n")
n3.reparent(n2)
tc.assertEqual(g1.serialise(), b"(;SZ[9](;N[n1])(;N[n2];N[n3]))\n")
tc.assertRaisesRegex(ValueError, "would create a loop", root.reparent, n3)
tc.assertRaisesRegex(ValueError, "would create a loop", n3.reparent, n3)
g2 = sgf.Sgf_game(9)
tc.assertRaisesRegex(ValueError,
"new parent doesn't belong to the same game",
n3.reparent, g2.get_root())
def __init__(self,
playerBlack=Player.Player(),
playerWhite=Player.Player(),
currentBoard=Board.Board(),
moveCounter=0,
sgfHist=None,
koHashTable={}):
self.playerBlack = playerBlack
self.playerWhite = playerWhite
self.currentBoard = currentBoard
self.moveCounter = moveCounter
self.setKo = None
# Initialize hash table and add starting position
self.koHashTable = koHashTable
self.koHashTable[self.currentBoard.boardHash()] = [self.currentBoard]
# consecutivePa.extend_main_sequence()sses always 0 for new board
self.consecutivePasses = 0
# create empty sgf_game on default
self.sgfHist = sgfHist
if sgfHist is None:
self.sgfHist = sgf.Sgf_game(self.currentBoard.size)
def test_tree_mutation(tc):
sgf_game = sgf.Sgf_game(9)
root = sgf_game.get_root()
n1 = root.new_child()
n1.set("N", "n1")
n2 = root.new_child()
n2.set("N", "n2")
n3 = n1.new_child()
n3.set("N", "n3")
n4 = root.new_child(1)
n4.set("N", "n4")
tc.assertEqual(
sgf_game.serialise(),
b"(;FF[4]CA[UTF-8]GM[1]SZ[9](;N[n1];N[n3])(;N[n4])(;N[n2]))\n")
tc.assertEqual([
node.get_raw_property_map() for node in sgf_game.main_sequence_iter()
], [node.get_raw_property_map() for node in (root, root[0], n3)])
tc.assertIs(sgf_game.get_last_node(), n3)
n1.delete()
tc.assertEqual(sgf_game.serialise(),
b"(;FF[4]CA[UTF-8]GM[1]SZ[9](;N[n4])(;N[n2]))\n")
tc.assertRaises(ValueError, root.delete)
def startPK(num,spendTime):
pbscmd = autopk_config.get("engines", "blackdir") \
+autopk_config.get("engines", "blackengine")+' -w' \
+autopk_config.get("engines", "blackweightdir") \
+autopk_config.get("engines", "blackweight")+' -p 9990000'
pbscmd = pbscmd.replace('\\','\\\\')
pbcwdstr = autopk_config.get("engines", "blackdir")
pbcwdstr = pbcwdstr.replace('\\','\\\\')
#print(pbscmd,pbcwdstr)
pbcommand = pbscmd.split(' ')
try:
pb = goEngin(pbcommand, pbcwdstr)
except (Exception) as e:
print("Error found:",e)
return None
processTest = True
while processTest:
#print 'test pb alive',pb.process.poll()
if pb.process.poll() is None:
pass
else:
gotStdStr = pb.readAns_nowait()
while gotStdStr != None:
print(gotStdStr)
gotStdStr = pb.readAns_nowait()
print("process start failed")
return None
sleep(0.001)
gotErrStr = pb.readErr_nowait()
if gotErrStr!=None:
while gotErrStr!=None:
if gotErrStr[:24] == 'Setting max tree size to':
print('pb.1',gotErrStr[:-2])
print('Black is ready.')
processTest = False
else:
#print 'pb.1',gotErrStr[:-2]
pass
if pb.process.poll() is None:
pass
else:
print("process start failed")
return None
gotErrStr = pb.readErr_nowait()
pwscmd = autopk_config.get("engines", "whitedir") \
+autopk_config.get("engines", "whiteengine")+' -w' \
+autopk_config.get("engines", "whiteweightdir") \
+autopk_config.get("engines", "whiteweight")+' -p 9990000'
pwscmd = pwscmd.replace('\\','\\\\')
pwcwdstr = autopk_config.get("engines", "whitedir")
pwcwdstr = pwcwdstr.replace('\\','\\\\')
#print(pwscmd,pwcwdstr)
pwcommand = pwscmd.split(' ')
try:
pw = goEngin(pwcommand, pwcwdstr)
except (Exception) as e:
print("Error found:",e)
return None
#初始化待存储棋谱
weightb = autopk_config.get("engines", "blackweight")
weightw = autopk_config.get("engines", "whiteweight")
g = sgf.Sgf_game(size=19)
g.root.set("KM",'7.5')
g.root.set("PB",weightb)
g.root.set("PW",weightw)
processTest = True
while processTest:
#print 'test pw alive',pw.process.poll()
if pw.process.poll() is None:
pass
else:
gotStdStr = pw.readAns_nowait()
while gotStdStr != None:
print(gotStdStr)
gotStdStr = pw.readAns_nowait()
print("process start failed")
return None
sleep(0.001)
gotErrStr = pw.readErr_nowait()
if gotErrStr!=None:
while gotErrStr!=None:
if gotErrStr[:24] == 'Setting max tree size to':
print('pw.1',gotErrStr[:-2])
print('White is ready.')
processTest = False
else:
#print 'pw.1',gotErrStr[:-2]
pass
if pw.process.poll() is None:
pass
else:
print("process start failed")
return None
gotErrStr = pw.readErr_nowait()
initCmds = ['version','boardsize 19','komi 7.5','time_settings 0 '+str(spendTime+1)+' 1']
for cmd in initCmds:
print('Sending pb[',cmd,']',end=' ')
try:
pb.write(cmd)
except (Exception) as e:
print("Error found:",e)
return None
gotAns = pb.readAns()
print('pb Answer is :', gotAns[:-2])
pb.clearErrQ()
for cmd in initCmds:
print('Sending pw[',cmd,']',end=' ')
try:
pw.write(cmd)
except (Exception) as e:
print("Error found:",e)
return None
gotAns = pw.readAns()
print('pw Answer is :', gotAns[:-2])
pw.clearErrQ()
#开始对战
stepTime1 = datetime.datetime.now()
startTime = stepTime1
resigned = False
black_po = 0 #黑棋po总值
white_po = 0 #白棋po总值
cmdStr = 'genmove b'
pb.write(cmdStr)
gotAns = pb.readAns()
#print 'Black First Move is :', gotAns
sleep(0.01)
#取得对局下一手相关信息：落子点、胜率、预测后几步走法、playouts
errQTime1 = datetime.datetime.now() #记录读取errQ的时长
strInfo = pb.clearErrQ()
errQTime2 = datetime.datetime.now() #记录读取errQ的时长
firstStep,stepWinrate,lcbrate,mightMoves,povalue = getStepInfo(strInfo,gotAns[2:-2])
if (stepWinrate == None or povalue == None) and gotAns[2:-2]!='resign':
print(repr(strInfo))
cmdStr = 'play b ' + gotAns[2:-2]
sgfStr=gotAns[2:-2] #去除末尾的\r\n
node = g.extend_main_sequence()
node.set_move('b', a2num(sgfStr))
if stepWinrate!=None and povalue!=None:
if lcbrate!=None:
node.set("C",stepWinrate+'% lcb:'+lcbrate+'% po:'+povalue)
else:
node.set("C",stepWinrate+'% po:'+povalue)
black_po += int(povalue)
steps = 1
whowins = ''
while not resigned:
pw.write(cmdStr)
stepTime2 = datetime.datetime.now()
print(steps,cmdStr,'WinRate:(',stepWinrate,'%)(lcb:',lcbrate,'%)(po:',povalue,')', \
"{:.2f}".format((stepTime2-stepTime1).total_seconds()),'s', \
"{:.2f}".format((errQTime2-errQTime1).total_seconds()),'s')
steps += 1
gotAns = pw.readAns()
#print 'White answer is :', gotAns
cmdStr = 'genmove w'
pw.write(cmdStr)
gotAns = pw.readAns()
#print 'White answer is :', gotAns
sleep(0.01)
#取得对局下一手相关信息：落子点、胜率、预测后几步走法
errQTime1 = datetime.datetime.now() #记录读取errQ的时长
strInfo = pw.clearErrQ()
errQTime2 = datetime.datetime.now() #记录读取errQ的时长
firstStep,stepWinrate,lcbrate,mightMoves,povalue = getStepInfo(strInfo,gotAns[2:-2])
if (stepWinrate == None or povalue == None) and gotAns[2:-2]!='resign':
print(repr(strInfo))
if gotAns[2:] == u'pass\r\n':
sgfStr += ','+gotAns[2:-2]
node = g.extend_main_sequence()
node.set_move('w', None)
cmdStr = 'play w ' + gotAns[2:-2]
elif gotAns[2:] != u'resign\r\n':
sgfStr += ','+gotAns[2:-2]
node = g.extend_main_sequence()
node.set_move('w', a2num(gotAns[2:-2]))
if stepWinrate!=None and povalue!=None:
if lcbrate!=None:
node.set("C",stepWinrate+'% lcb:'+lcbrate+'% po:'+povalue)
else:
node.set("C",stepWinrate+'% po:'+povalue)
white_po += int(povalue)
cmdStr = 'play w ' + gotAns[2:-2]
else:
print('White resigned!')
node = g.extend_main_sequence()
node.set_move('w', None)
node.set("C", "White resigned!")
g.root.set('RE','B+')
resigned = True
whowins = 'b'
endTime = datetime.datetime.now()
continue
pb.write(cmdStr)
stepTime1 = datetime.datetime.now()
print(steps,cmdStr,'WinRate:(',stepWinrate,'%)(lcb:',lcbrate,'%)(po:',povalue,')', \
"{:.2f}".format((stepTime1-stepTime2).total_seconds()),'s', \
"{:.2f}".format((errQTime2-errQTime1).total_seconds()),'s')
steps += 1
gotAns = pb.readAns()
#print 'Black answer is :', gotAns
cmdStr = 'genmove b'
pb.write(cmdStr)
gotAns = pb.readAns()
#print 'Black answer is :', gotAns
sleep(0.01)
#取得对局下一手相关信息：落子点、胜率、预测后几步走法
errQTime1 = datetime.datetime.now() #记录读取errQ的时长
strInfo = pb.clearErrQ()
errQTime2 = datetime.datetime.now() #记录读取errQ的时长
firstStep,stepWinrate,lcbrate,mightMoves,povalue = getStepInfo(strInfo,gotAns[2:-2])
if (stepWinrate == None or povalue == None) and gotAns[2:-2]!='resign':
print(repr(strInfo))
if gotAns[2:] == u'pass\r\n':
sgfStr += ','+gotAns[2:-2]
node = g.extend_main_sequence()
node.set_move('b', None)
cmdStr = 'play b ' + gotAns[2:-2]
elif gotAns[2:] != u'resign\r\n':
sgfStr += ','+gotAns[2:-2]
node = g.extend_main_sequence()
node.set_move('b', a2num(gotAns[2:-2]))
if stepWinrate!=None and povalue!=None:
if lcbrate!=None:
node.set("C",stepWinrate+'% lcb:'+lcbrate+'% po:'+povalue)
else:
node.set("C",stepWinrate+'% po:'+povalue)
black_po += int(povalue)
cmdStr = 'play b ' + gotAns[2:-2]
else:
print('Black resigned!')
node = g.extend_main_sequence()
node.set_move('b', None)
node.set("C", "Black resigned!")
g.root.set('RE','W+')
resigned = True
whowins = 'w'
endTime = datetime.datetime.now()
continue
if steps >= 500:
print('Too many Moves!')
node.set("C", "Too many Moves!")
resigned = True
whowins = 'x'
endTime = datetime.datetime.now()
continue
#计算黑白平均po值
if steps % 2 == 0: #偶数说明是白投降了
avgBlackPo = int(black_po/(steps/2))
avgWhitePo = int(white_po/(steps/2-1))
else:
avgBlackPo = int(black_po/((steps-1)/2))
avgWhitePo = int(white_po/((steps-1)/2))
print('本局共耗时：',"{:.2f}".format((endTime-startTime).total_seconds()),'s','avgBpo:',avgBlackPo,'avgWpo:',avgWhitePo)
#print sgfStr
sgffile = open(weightb+' B'+"{:.0f}".format(avgBlackPo)+'po vs '+weightw+' W'+"{:.0f}".format(avgWhitePo)+ \
'po-'+str(spendTime)+'s-'+str(num)+'-'+whowins+'+.sgf','w',encoding='utf-8') #python 3
sgffile.write(g.serialise().decode())
sgffile.close()
pb.close()
pw.close()
return whowins
def gw(raw_result):
g = sgf.Sgf_game(19)
g.get_root().set_raw('RE', raw_result)
return g.get_winner()
def gh(raw_handicap):
g = sgf.Sgf_game(19)
g.get_root().set_raw('HA', raw_handicap)
return g.get_handicap()
async def on_message(message):
global game
if message.author == client.user:
return
if len(message.attachments) > 0 and \
message.attachments[0].filename.endswith('.sgf') and \
message.content.startswith(':set sgf'):
bytes = await message.attachments[0].read()
game = sgf.Sgf_game.from_string(bytes.decode('utf-8'))
await message.channel.send('sgf set!')
if message.content.startswith(':play from move'):
# note: from move 0 doesn't work
board_size = game.get_size()
msg = message.content.split(' ')
stop_at_move_no = int(msg[3][:-1])
unparsed_appended_moves = msg[4:]
# unparsed_appended_moves looks like
# unparsed_appended_moves = [
# 'e8',
# 'd7',
# 'd8',
# ]
appended_moves = []
# note: uses 'j' instead of 'i' for the x-axis column name
for ind, x in enumerate(unparsed_appended_moves):
xaxisnumber = ord(x[0]) - 97 if ord(
x[0]) <= 104 else ord(x[0]) - 98 # the j instead of i thingy
appended_moves.append(
('b' if ((stop_at_move_no % 2) + ind) % 2 == 0 else 'w',
(int(x[1:]) - 1, xaxisnumber)))
# appended_moves should look like
# appended_moves = [
# ('b', (0,0)),
# ('w', (1,0)),
# ('b', (2,0)), # note that first number represents y-axis, grows from bottom-left from 0,0
# ]
copied_game = sgf.Sgf_game(size=board_size)
count = 0
# now we copy moves up till given stop_at_move_no
for node in game.get_main_sequence():
if count > stop_at_move_no:
break
move = node.get_move()
# print(count, move)
# print(move[0], move[1])
if count == 0:
count = count + 1
continue
new_node = copied_game.extend_main_sequence()
new_node.set_move(move[0], move[1])
count = count + 1
# now we copy over appended moves
for move in appended_moves:
new_node = copied_game.extend_main_sequence()
new_node.set_move(move[0], move[1])
# render to gif
with open('output.sgf', "wb") as f:
f.write(copied_game.serialise())
subprocess.run([
'./sgf_to_gif', '-d', '100', '-t',
str(stop_at_move_no), 'output.sgf'
])
output_gif_filename = 'output.' + str(stop_at_move_no +
len(appended_moves)) + '.gif'
await message.channel.send(file=discord.File(output_gif_filename))
subprocess.run('rm output*', shell=True)
if message.content.startswith(':play all moves'):
with open('output.sgf', "wb") as f:
f.write(game.serialise())
subprocess.run(['./sgf_to_gif', '-d', '100', 'output.sgf'])
await message.channel.send(file=discord.File('output.gif'))
subprocess.run('rm output*', shell=True)
if message.content.startswith(':play moves') and 'to' in message.content:
msg = message.content.split(' ')
starting_move = str(int(msg[2]) - 1)
ending_move = msg[4]
with open('output.sgf', "wb") as f:
f.write(game.serialise())
subprocess.run(
f'./sgf_to_gif -d 100 -t "{starting_move} {ending_move}" output.sgf',
shell=True)
await message.channel.send(file=discord.File('output.' + ending_move +
'.gif'))
subprocess.run('rm output*', shell=True)
def create_empty(self, size, komi):
self.game = sgf.Sgf_game(size=size, encoding="UTF-8")
self.board_size = size
self.komi = komi
root_node = self.game.get_root()
root_node.set("KM", komi)
