def test_slide_multiple(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[W, B, W, B],
[W],
[B],
[B],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
g1 = g.move(tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, 1, 1, 1)))
assert g1[0, 0] == []
assert g1[1, 0] == [B, W]
assert g1[2, 0] == [W, B]
assert g1[3, 0] == [B, B]
assert g1[4, 0] == [W, W]
def test_initial_special(self):
g = tak.Position.from_config(tak.Config(size=5))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.PLACE_CAPSTONE))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.PLACE_STANDING))
def test_basic_slide(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
g1 = g.move(tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, )))
assert g1[0, 0] == []
assert g1[1, 0] == [W]
def test_place_flat(self):
g = tak.Position.from_config(tak.Config(size=5))
g1 = g.move(tak.Move(
x=0,
y=0,
))
assert g.ply == 0
assert g[0, 0] == []
assert g1[0, 0] == [tak.Piece(tak.Color.BLACK, tak.Kind.FLAT)]
assert g1.ply == 1
assert g1.stones[1].caps == 1
assert g1.stones[1].stones == 20
g2 = g1.move(tak.Move(
x=4,
y=4,
))
assert g2[0, 0] == [tak.Piece(tak.Color.BLACK, tak.Kind.FLAT)]
assert g2[4, 4] == [tak.Piece(tak.Color.WHITE, tak.Kind.FLAT)]
assert g2.stones[0].stones == 20
assert g2.stones[1].stones == 20
g3 = g2.move(tak.Move(
x=2,
y=2,
))
assert g3[2, 2] == [tak.Piece(tak.Color.WHITE, tak.Kind.FLAT)]
def test_initial_slide(self):
g = tak.Position.from_config(tak.Config(size=5))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, )))
g = g.move(tak.Move(0, 0))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, )))
def test_new():
g = tak.Position.from_config(tak.Config(size=5))
assert g.size == 5
assert g.ply == 0
assert g.stones[0].stones == 21
assert g.stones[1].stones == 21
assert g.stones[0].caps == 1
assert g.stones[1].caps == 1
assert g.to_move() == tak.Color.WHITE
def test_illegal_slide(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[W, B, W, B, W, W, W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(1, 1, tak.MoveType.SLIDE_RIGHT, (1, )))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.SLIDE_UP, (6, )))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.SLIDE_UP, ()))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(0, 0, tak.MoveType.SLIDE_LEFT, (1, )))
with pytest.raises(tak.IllegalMove):
g.move(tak.Move(4, 4, tak.MoveType.SLIDE_LEFT, (1, )))
def transform_position(sym, pos):
ix = np.stack([
np.repeat(np.arange(pos.size), pos.size),
np.tile(np.arange(pos.size), pos.size),
(pos.size - 1) * np.ones(pos.size * pos.size)
],
axis=-1)
ix = np.transpose(np.matmul(sym, np.transpose(ix))).astype(np.int)
ix = ix.reshape((pos.size, pos.size, 3))
sqs = list(pos.board)
for i in range(pos.size):
for j in range(pos.size):
oi, oj, _ = ix[i, j]
sqs[oi + oj * pos.size] = pos[i, j]
return tak.Position.from_squares(
tak.Config(size=pos.size),
sqs,
pos.ply,
)
def test_place_special(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
g1 = g.move(tak.Move(2, 2, tak.MoveType.PLACE_CAPSTONE))
assert g1[2, 2] == [WC]
assert g1.stones[tak.Color.WHITE.value].caps == 0
g2 = g1.move(tak.Move(1, 2, tak.MoveType.PLACE_STANDING))
assert g2[1, 2] == [BS]
with pytest.raises(tak.IllegalMove):
g2.move(tak.Move(2, 3, tak.MoveType.PLACE_CAPSTONE))
with pytest.raises(tak.IllegalMove):
g2.move(tak.Move(2, 2, tak.MoveType.PLACE_FLAT))
def test_smash(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[WC, W],
[BS, W],
[],
[],
[],
[],
[W],
[],
[],
[],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
for m in [
tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (2, )),
tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, 1)),
tak.Move(1, 1, tak.MoveType.SLIDE_DOWN, (1, ))
]:
with pytest.raises(tak.IllegalMove) as exc:
g.move(m)
assert 'standing stone' in str(exc.value)
g1 = g.move(tak.Move(0, 0, tak.MoveType.SLIDE_RIGHT, (1, )))
assert g1[1, 0] == [WC, B, W]
def parse_tps(tps):
bits = tps.split(' ')
if len(bits) != 3:
raise IllegalTPS("need three components")
board, who, move = bits
if not who in '12':
raise IllegalTPS("Current player must be either 1 or 2")
try:
ply = 2 * (int(move) - 1) + int(who) - 1
except ValueError:
raise IllegalTPS("Bad move number: " + move)
squares = []
rows = board.split("/")
for row in reversed(rows):
rsq = parse_row(row)
if len(rsq) != len(rows):
raise IllegalTPS("inconsistent size")
squares += rsq
return tak.Position.from_squares(tak.Config(size=len(rows)), squares, ply)
def test_cap_slide(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[WC, W],
[BS, W],
[],
[],
[],
[BC],
[W],
[],
[],
[],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
], 2)
for m in [
tak.Move(0, 0, tak.MoveType.SLIDE_UP, (2, )),
tak.Move(0, 0, tak.MoveType.SLIDE_UP, (1, 1)),
tak.Move(0, 0, tak.MoveType.SLIDE_UP, (1, )),
tak.Move(1, 1, tak.MoveType.SLIDE_LEFT, (1, ))
]:
with pytest.raises(tak.IllegalMove) as exc:
g.move(m)
assert 'capstone' in str(exc.value)
def main(args):
model = tak.model.load_model(FLAGS.model, eval_symmetries=FLAGS.symmetries)
pos = tak.Position.from_config(tak.Config(size=FLAGS.size))
with open(FLAGS.out, 'w') as ptn:
ptn.write('[Size "{0}"]\n'.format(pos.size))
while True:
if pos.ply % 2 == 0:
ptn.write("\n{0}. ".format(1 + int(pos.ply / 2)))
if pos.ply == 0:
m = tak.ptn.parse_move('a1')
pos = pos.move(m)
elif pos.ply == 1:
m = tak.ptn.parse_move('a{}'.format(FLAGS.size))
pos = pos.move(m)
else:
m, pos = model.get_move(pos)
ptn.write(tak.ptn.format_move(m))
ptn.write(" ")
who, why = pos.winner()
if why is not None:
break
ptn.write("\n")
def test_from_stones(self):
g = tak.Position.from_squares(tak.Config(size=5), [
[W],
[W],
[B],
[W],
[W],
[],
[],
[BC],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
[B],
[B],
[WS],
[],
], 5)
assert g[0, 0] == [W]
assert g[2, 1] == [BC]
assert g.stones[tak.Color.WHITE.value].stones == 16
assert g.stones[tak.Color.WHITE.value].caps == 1
assert g.stones[tak.Color.BLACK.value].stones == 17
assert g.stones[tak.Color.BLACK.value].caps == 0
assert g.ply == 5
def initial_position(self):
if 'TPS' in self.tags:
return tps.parse_tps(self.tags['TPS'])
return tak.Position.from_config(
tak.Config(size=int(self.tags['Size'])))
def test_game_over_road(self):
cases = [
([
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
], (None, None)),
([
[W],
[W],
[W],
[W],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
], (tak.Color.WHITE, tak.WinReason.ROAD)),
([
[W] * 21,
[],
[],
[],
[],
[],
[WC],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
[B],
], (tak.Color.BLACK, tak.WinReason.FLATS)),
([
[W] * 21,
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[B],
[B],
], (None, None)),
([
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
], (tak.Color.WHITE, tak.WinReason.FLATS)),
([
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[WS],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
[B],
[W],
], (None, tak.WinReason.FLATS)),
]
for i, tc in enumerate(cases):
sq, want = tc
g = tak.Position.from_squares(tak.Config(size=5), sq, 4)
has = g.winner()
assert has == want, "{0}: got winner={1} expect {2}".format(
i, has, want)
def test_has_road(self):
cases = [
([
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
], None),
([
[W],
[W],
[W],
[W],
[W],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
], tak.Color.WHITE),
([
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
], tak.Color.BLACK),
([
[],
[B],
[],
[],
[],
[],
[B],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[B],
[],
[],
[],
[],
[B],
[],
], tak.Color.BLACK),
([
[],
[B],
[W],
[],
[],
[],
[B],
[W],
[],
[],
[],
[B],
[W],
[],
[],
[],
[B],
[W],
[],
[],
[],
[B],
[W],
[],
[],
], tak.Color.BLACK),
([
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[BS],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
], None),
([
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[B],
[],
[],
[],
[],
[BC],
[],
[],
[],
[],
[B],
[],
[],
[],
], tak.Color.BLACK),
]
for i, tc in enumerate(cases):
sq, color = tc
g = tak.Position.from_squares(tak.Config(size=5), sq, 4)
has = g.has_road()
assert has == color, "{0}: got road={1} expect {2}".format(
i, has, color)
