410 lines
15 KiB
Python
410 lines
15 KiB
Python
'''
|
|
A board is a NxN numpy array.
|
|
A Coordinate is a tuple index into the board.
|
|
A Move is a (Coordinate c | None).
|
|
A PlayerMove is a (Color, Move) tuple
|
|
(0, 0) is considered to be the upper left corner of the board, and (18, 0) is the lower left.
|
|
'''
|
|
from collections import namedtuple
|
|
import copy
|
|
import itertools
|
|
|
|
import numpy as np
|
|
|
|
# Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white.
|
|
# This means that swapping colors is as simple as multiplying array by -1.
|
|
WHITE, EMPTY, BLACK, FILL, KO, UNKNOWN = range(-1, 5)
|
|
|
|
class PlayerMove(namedtuple('PlayerMove', ['color', 'move'])): pass
|
|
|
|
# Represents "group not found" in the LibertyTracker object
|
|
MISSING_GROUP_ID = -1
|
|
|
|
class IllegalMove(Exception): pass
|
|
|
|
# these are initialized by set_board_size
|
|
N = None
|
|
ALL_COORDS = []
|
|
EMPTY_BOARD = None
|
|
NEIGHBORS = {}
|
|
DIAGONALS = {}
|
|
|
|
def set_board_size(n):
|
|
'''
|
|
Hopefully nobody tries to run both 9x9 and 19x19 game instances at once.
|
|
Also, never do "from go import N, W, ALL_COORDS, EMPTY_BOARD".
|
|
'''
|
|
global N, ALL_COORDS, EMPTY_BOARD, NEIGHBORS, DIAGONALS
|
|
if N == n: return
|
|
N = n
|
|
ALL_COORDS = [(i, j) for i in range(n) for j in range(n)]
|
|
EMPTY_BOARD = np.zeros([n, n], dtype=np.int8)
|
|
def check_bounds(c):
|
|
return c[0] % n == c[0] and c[1] % n == c[1]
|
|
|
|
NEIGHBORS = {(x, y): list(filter(check_bounds, [(x+1, y), (x-1, y), (x, y+1), (x, y-1)])) for x, y in ALL_COORDS}
|
|
DIAGONALS = {(x, y): list(filter(check_bounds, [(x+1, y+1), (x+1, y-1), (x-1, y+1), (x-1, y-1)])) for x, y in ALL_COORDS}
|
|
|
|
def place_stones(board, color, stones):
|
|
for s in stones:
|
|
board[s] = color
|
|
|
|
def find_reached(board, c):
|
|
color = board[c]
|
|
chain = set([c])
|
|
reached = set()
|
|
frontier = [c]
|
|
while frontier:
|
|
current = frontier.pop()
|
|
chain.add(current)
|
|
for n in NEIGHBORS[current]:
|
|
if board[n] == color and not n in chain:
|
|
frontier.append(n)
|
|
elif board[n] != color:
|
|
reached.add(n)
|
|
return chain, reached
|
|
|
|
def is_koish(board, c):
|
|
'Check if c is surrounded on all sides by 1 color, and return that color'
|
|
if board[c] != EMPTY: return None
|
|
neighbors = {board[n] for n in NEIGHBORS[c]}
|
|
if len(neighbors) == 1 and not EMPTY in neighbors:
|
|
return list(neighbors)[0]
|
|
else:
|
|
return None
|
|
|
|
def is_eyeish(board, c):
|
|
'Check if c is an eye, for the purpose of restricting MC rollouts.'
|
|
color = is_koish(board, c)
|
|
if color is None:
|
|
return None
|
|
diagonal_faults = 0
|
|
diagonals = DIAGONALS[c]
|
|
if len(diagonals) < 4:
|
|
diagonal_faults += 1
|
|
for d in diagonals:
|
|
if not board[d] in (color, EMPTY):
|
|
diagonal_faults += 1
|
|
if diagonal_faults > 1:
|
|
return None
|
|
else:
|
|
return color
|
|
|
|
class Group(namedtuple('Group', ['id', 'stones', 'liberties', 'color'])):
|
|
'''
|
|
stones: a set of Coordinates belonging to this group
|
|
liberties: a set of Coordinates that are empty and adjacent to this group.
|
|
color: color of this group
|
|
'''
|
|
def __eq__(self, other):
|
|
return self.stones == other.stones and self.liberties == other.liberties and self.color == other.color
|
|
|
|
|
|
class LibertyTracker():
|
|
@staticmethod
|
|
def from_board(board):
|
|
board = np.copy(board)
|
|
curr_group_id = 0
|
|
lib_tracker = LibertyTracker()
|
|
for color in (WHITE, BLACK):
|
|
while color in board:
|
|
curr_group_id += 1
|
|
found_color = np.where(board == color)
|
|
coord = found_color[0][0], found_color[1][0]
|
|
chain, reached = find_reached(board, coord)
|
|
liberties = set(r for r in reached if board[r] == EMPTY)
|
|
new_group = Group(curr_group_id, chain, liberties, color)
|
|
lib_tracker.groups[curr_group_id] = new_group
|
|
for s in chain:
|
|
lib_tracker.group_index[s] = curr_group_id
|
|
place_stones(board, FILL, chain)
|
|
|
|
lib_tracker.max_group_id = curr_group_id
|
|
|
|
liberty_counts = np.zeros([N, N], dtype=np.uint8)
|
|
for group in lib_tracker.groups.values():
|
|
num_libs = len(group.liberties)
|
|
for s in group.stones:
|
|
liberty_counts[s] = num_libs
|
|
lib_tracker.liberty_cache = liberty_counts
|
|
|
|
return lib_tracker
|
|
|
|
def __init__(self, group_index=None, groups=None, liberty_cache=None, max_group_id=1):
|
|
# group_index: a NxN numpy array of group_ids. -1 means no group
|
|
# groups: a dict of group_id to groups
|
|
# liberty_cache: a NxN numpy array of liberty counts
|
|
self.group_index = group_index if group_index is not None else -np.ones([N, N], dtype=np.int32)
|
|
self.groups = groups or {}
|
|
self.liberty_cache = liberty_cache if liberty_cache is not None else np.zeros([N, N], dtype=np.uint8)
|
|
self.max_group_id = max_group_id
|
|
|
|
def __deepcopy__(self, memodict={}):
|
|
new_group_index = np.copy(self.group_index)
|
|
new_lib_cache = np.copy(self.liberty_cache)
|
|
new_groups = {
|
|
group.id: Group(group.id, set(group.stones), set(group.liberties), group.color)
|
|
for group in self.groups.values()
|
|
}
|
|
return LibertyTracker(new_group_index, new_groups, liberty_cache=new_lib_cache, max_group_id=self.max_group_id)
|
|
|
|
def add_stone(self, color, c):
|
|
assert self.group_index[c] == MISSING_GROUP_ID
|
|
captured_stones = set()
|
|
opponent_neighboring_group_ids = set()
|
|
friendly_neighboring_group_ids = set()
|
|
empty_neighbors = set()
|
|
|
|
for n in NEIGHBORS[c]:
|
|
neighbor_group_id = self.group_index[n]
|
|
if neighbor_group_id != MISSING_GROUP_ID:
|
|
neighbor_group = self.groups[neighbor_group_id]
|
|
if neighbor_group.color == color:
|
|
friendly_neighboring_group_ids.add(neighbor_group_id)
|
|
else:
|
|
opponent_neighboring_group_ids.add(neighbor_group_id)
|
|
else:
|
|
empty_neighbors.add(n)
|
|
|
|
new_group = self._create_group(color, c, empty_neighbors)
|
|
|
|
for group_id in friendly_neighboring_group_ids:
|
|
new_group = self._merge_groups(group_id, new_group.id)
|
|
|
|
for group_id in opponent_neighboring_group_ids:
|
|
neighbor_group = self.groups[group_id]
|
|
if len(neighbor_group.liberties) == 1:
|
|
captured = self._capture_group(group_id)
|
|
captured_stones.update(captured)
|
|
else:
|
|
self._update_liberties(group_id, remove={c})
|
|
|
|
self._handle_captures(captured_stones)
|
|
|
|
# suicide is illegal
|
|
if len(new_group.liberties) == 0:
|
|
raise IllegalMove("Move at {} would commit suicide!\n".format(c))
|
|
|
|
return captured_stones
|
|
|
|
def _create_group(self, color, c, liberties):
|
|
self.max_group_id += 1
|
|
new_group = Group(self.max_group_id, set([c]), liberties, color)
|
|
self.groups[new_group.id] = new_group
|
|
self.group_index[c] = new_group.id
|
|
self.liberty_cache[c] = len(liberties)
|
|
return new_group
|
|
|
|
def _merge_groups(self, group1_id, group2_id):
|
|
group1 = self.groups[group1_id]
|
|
group2 = self.groups[group2_id]
|
|
group1.stones.update(group2.stones)
|
|
del self.groups[group2_id]
|
|
for s in group2.stones:
|
|
self.group_index[s] = group1_id
|
|
|
|
self._update_liberties(group1_id, add=group2.liberties, remove=(group2.stones | group1.stones))
|
|
|
|
return group1
|
|
|
|
def _capture_group(self, group_id):
|
|
dead_group = self.groups[group_id]
|
|
del self.groups[group_id]
|
|
for s in dead_group.stones:
|
|
self.group_index[s] = MISSING_GROUP_ID
|
|
self.liberty_cache[s] = 0
|
|
return dead_group.stones
|
|
|
|
def _update_liberties(self, group_id, add=None, remove=None):
|
|
group = self.groups[group_id]
|
|
if add:
|
|
group.liberties.update(add)
|
|
if remove:
|
|
group.liberties.difference_update(remove)
|
|
|
|
new_lib_count = len(group.liberties)
|
|
for s in group.stones:
|
|
self.liberty_cache[s] = new_lib_count
|
|
|
|
def _handle_captures(self, captured_stones):
|
|
for s in captured_stones:
|
|
for n in NEIGHBORS[s]:
|
|
group_id = self.group_index[n]
|
|
if group_id != MISSING_GROUP_ID:
|
|
self._update_liberties(group_id, add={s})
|
|
|
|
class Position():
|
|
def __init__(self, board=None, n=0, komi=7.5, caps=(0, 0), lib_tracker=None, ko=None, recent=tuple(), to_play=BLACK):
|
|
'''
|
|
board: a numpy array
|
|
n: an int representing moves played so far
|
|
komi: a float, representing points given to the second player.
|
|
caps: a (int, int) tuple of captures for B, W.
|
|
lib_tracker: a LibertyTracker object
|
|
ko: a Move
|
|
recent: a tuple of PlayerMoves, such that recent[-1] is the last move.
|
|
to_play: BLACK or WHITE
|
|
'''
|
|
self.board = board if board is not None else np.copy(EMPTY_BOARD)
|
|
self.n = n
|
|
self.komi = komi
|
|
self.caps = caps
|
|
self.lib_tracker = lib_tracker or LibertyTracker.from_board(self.board)
|
|
self.ko = ko
|
|
self.recent = recent
|
|
self.to_play = to_play
|
|
|
|
def __deepcopy__(self, memodict={}):
|
|
new_board = np.copy(self.board)
|
|
new_lib_tracker = copy.deepcopy(self.lib_tracker)
|
|
return Position(new_board, self.n, self.komi, self.caps, new_lib_tracker, self.ko, self.recent, self.to_play)
|
|
|
|
def __str__(self):
|
|
pretty_print_map = {
|
|
WHITE: '\x1b[0;31;47mO',
|
|
EMPTY: '\x1b[0;31;43m.',
|
|
BLACK: '\x1b[0;31;40mX',
|
|
FILL: '#',
|
|
KO: '*',
|
|
}
|
|
board = np.copy(self.board)
|
|
captures = self.caps
|
|
if self.ko is not None:
|
|
place_stones(board, KO, [self.ko])
|
|
raw_board_contents = []
|
|
for i in range(N):
|
|
row = []
|
|
for j in range(N):
|
|
appended = '<' if (self.recent and (i, j) == self.recent[-1].move) else ' '
|
|
row.append(pretty_print_map[board[i,j]] + appended)
|
|
row.append('\x1b[0m')
|
|
raw_board_contents.append(''.join(row))
|
|
|
|
row_labels = ['%2d ' % i for i in range(N, 0, -1)]
|
|
annotated_board_contents = [''.join(r) for r in zip(row_labels, raw_board_contents, row_labels)]
|
|
header_footer_rows = [' ' + ' '.join('ABCDEFGHJKLMNOPQRST'[:N]) + ' ']
|
|
annotated_board = '\n'.join(itertools.chain(header_footer_rows, annotated_board_contents, header_footer_rows))
|
|
details = "\nMove: {}. Captures X: {} O: {}\n".format(self.n, *captures)
|
|
return annotated_board + details
|
|
|
|
def is_move_suicidal(self, move):
|
|
potential_libs = set()
|
|
for n in NEIGHBORS[move]:
|
|
neighbor_group_id = self.lib_tracker.group_index[n]
|
|
if neighbor_group_id == MISSING_GROUP_ID:
|
|
# at least one liberty after playing here, so not a suicide
|
|
return False
|
|
neighbor_group = self.lib_tracker.groups[neighbor_group_id]
|
|
if neighbor_group.color == self.to_play:
|
|
potential_libs |= neighbor_group.liberties
|
|
elif len(neighbor_group.liberties) == 1:
|
|
# would capture an opponent group if they only had one lib.
|
|
return False
|
|
# it's possible to suicide by connecting several friendly groups
|
|
# each of which had one liberty.
|
|
potential_libs -= set([move])
|
|
return not potential_libs
|
|
|
|
def is_move_legal(self, move):
|
|
'Checks that a move is on an empty space, not on ko, and not suicide'
|
|
if move is None:
|
|
return True
|
|
if self.board[move] != EMPTY:
|
|
return False
|
|
if move == self.ko:
|
|
return False
|
|
if self.is_move_suicidal(move):
|
|
return False
|
|
|
|
return True
|
|
|
|
def pass_move(self, mutate=False):
|
|
pos = self if mutate else copy.deepcopy(self)
|
|
pos.n += 1
|
|
pos.recent += (PlayerMove(pos.to_play, None),)
|
|
pos.to_play *= -1
|
|
pos.ko = None
|
|
return pos
|
|
|
|
def flip_playerturn(self, mutate=False):
|
|
pos = self if mutate else copy.deepcopy(self)
|
|
pos.ko = None
|
|
pos.to_play *= -1
|
|
return pos
|
|
|
|
def get_liberties(self):
|
|
return self.lib_tracker.liberty_cache
|
|
|
|
def play_move(self, c, color=None, mutate=False):
|
|
# Obeys CGOS Rules of Play. In short:
|
|
# No suicides
|
|
# Chinese/area scoring
|
|
# Positional superko (this is very crudely approximate at the moment.)
|
|
if color is None:
|
|
color = self.to_play
|
|
|
|
pos = self if mutate else copy.deepcopy(self)
|
|
|
|
if c is None:
|
|
pos = pos.pass_move(mutate=mutate)
|
|
return pos
|
|
|
|
if not self.is_move_legal(c):
|
|
raise IllegalMove("Move at {} is illegal: \n{}".format(c, self))
|
|
|
|
# check must be done before potentially mutating the board
|
|
potential_ko = is_koish(self.board, c)
|
|
|
|
place_stones(pos.board, color, [c])
|
|
captured_stones = pos.lib_tracker.add_stone(color, c)
|
|
place_stones(pos.board, EMPTY, captured_stones)
|
|
|
|
opp_color = color * -1
|
|
|
|
if len(captured_stones) == 1 and potential_ko == opp_color:
|
|
new_ko = list(captured_stones)[0]
|
|
else:
|
|
new_ko = None
|
|
|
|
if pos.to_play == BLACK:
|
|
new_caps = (pos.caps[0] + len(captured_stones), pos.caps[1])
|
|
else:
|
|
new_caps = (pos.caps[0], pos.caps[1] + len(captured_stones))
|
|
|
|
pos.n += 1
|
|
pos.caps = new_caps
|
|
pos.ko = new_ko
|
|
pos.recent += (PlayerMove(color, c),)
|
|
pos.to_play *= -1
|
|
return pos
|
|
|
|
def score(self):
|
|
'Return score from B perspective. If W is winning, score is negative.'
|
|
working_board = np.copy(self.board)
|
|
while EMPTY in working_board:
|
|
unassigned_spaces = np.where(working_board == EMPTY)
|
|
c = unassigned_spaces[0][0], unassigned_spaces[1][0]
|
|
territory, borders = find_reached(working_board, c)
|
|
border_colors = set(working_board[b] for b in borders)
|
|
X_border = BLACK in border_colors
|
|
O_border = WHITE in border_colors
|
|
if X_border and not O_border:
|
|
territory_color = BLACK
|
|
elif O_border and not X_border:
|
|
territory_color = WHITE
|
|
else:
|
|
territory_color = UNKNOWN # dame, or seki
|
|
place_stones(working_board, territory_color, territory)
|
|
|
|
return np.count_nonzero(working_board == BLACK) - np.count_nonzero(working_board == WHITE) - self.komi
|
|
|
|
def result(self):
|
|
score = self.score()
|
|
if score > 0:
|
|
return 'B+' + '%.1f' % score
|
|
elif score < 0:
|
|
return 'W+' + '%.1f' % abs(score)
|
|
else:
|
|
return 'DRAW'
|
|
|
|
set_board_size(19) |