def test_simulate_draws(self):
hand = set([Tile(1, 1), Tile(1, 2), Tile(1, 4), Tile(1, 5)])
boneyard_size = 14
all_other_tiles = set([
Tile(0, 0),
Tile(0, 1),
Tile(0, 2),
Tile(0, 3),
Tile(0, 4),
Tile(0, 5),
Tile(1, 3),
Tile(1, 6),
Tile(2, 2),
Tile(2, 3),
Tile(2, 4),
Tile(2, 5),
Tile(2, 6),
Tile(3, 4),
Tile(3, 5),
Tile(4, 4),
Tile(5, 5)
])
# num not playable tiles: 5
# num playable tiles: 9
# approximate expected num draws: 1.5
num_simulations = 100
sum_draws = 0
for i in range(num_simulations):
extra_tiles = algos.simulate_draws(self.board, hand, boneyard_size)
self.assertGreaterEqual(len(extra_tiles), 0)
self.assertLessEqual(len(extra_tiles), 6)
sum_draws += len(extra_tiles)
for tile in extra_tiles[:-1]:
self.assertIn(tile, all_other_tiles)
for direction in all_dirs():
self.assertFalse(self.board.valid_move(tile, direction))
last_tile = extra_tiles[-1]
self.assertIn(last_tile, all_other_tiles)
tile_has_valid_move = False
for direction in all_dirs():
if self.board.valid_move(last_tile, direction):
tile_has_valid_move = True
self.assertTrue(tile_has_valid_move)
avg_num_draws = 1.0 * sum_draws / num_simulations
self.assertLess(avg_num_draws, 1.7)
self.assertGreater(avg_num_draws, 1.2)
def test_get_valid_moves_and_extra_tiles_when_no_valid_moves(self):
# With no valid moves
hand = set([Tile(1, 1), Tile(1, 2), Tile(1, 4), Tile(1, 5)])
valid_moves_and_extra_tiles = algos.get_valid_moves_and_extra_tiles(
self.board, hand, 3, sims=100)
self.assertGreaterEqual(len(valid_moves_and_extra_tiles), 100)
for valid_move, extra_tiles in valid_moves_and_extra_tiles:
self.assertTrue(valid_move[0])
self.assertTrue(self.board.valid_move(*valid_move))
self.assertGreaterEqual(len(extra_tiles), 1)
num_playable_extra_tiles = 0
for tile in extra_tiles:
for direction in all_dirs():
if self.board.valid_move(tile, direction):
num_playable_extra_tiles += 1
break
self.assertEquals(tile, valid_move[0])
self.assertEqual(num_playable_extra_tiles, 1)
def test_simulate_draws_until_knock(self):
# Test case where could draw all tiles
board = Board()
moves = [
(Tile(6, 6), Dir.RIGHT),
(Tile(6, 0), Dir.RIGHT),
(Tile(1, 0), Dir.RIGHT),
(Tile(1, 6), Dir.RIGHT),
(Tile(6, 2), Dir.RIGHT),
(Tile(2, 3), Dir.RIGHT),
(Tile(6, 3), Dir.RIGHT),
(Tile(6, 4), Dir.LEFT),
(Tile(5, 4), Dir.LEFT),
(Tile(5, 5), Dir.LEFT),
(Tile(5, 3), Dir.LEFT),
(Tile(3, 0), Dir.LEFT),
(Tile(0, 5), Dir.LEFT),
(Tile(5, 1), Dir.LEFT),
(Tile(1, 2), Dir.LEFT),
(Tile(2, 5), Dir.LEFT),
]
# The only playable tile after this is (5,6)
for tile, direction in moves:
board.make_move(tile, direction)
# 16 tiles out, 12 left over, 4 in each hand, 4 in boneyard
hand = set([Tile(1, 1), Tile(2, 2), Tile(3, 3), Tile(4, 4)])
boneyard_size = 4
# 50 / 50 chance of drawing it
num_knocks = 0
for i in range(100):
extra_tiles = algos.simulate_draws(board, hand, boneyard_size)
can_play = False
for direction in all_dirs():
if board.valid_move(extra_tiles[-1], direction):
can_play = True
if can_play:
self.assertEquals(extra_tiles[-1], Tile(5, 6))
self.assertLessEqual(len(extra_tiles), 4)
else:
num_knocks += 1
self.assertEquals(len(extra_tiles), 4)
self.assertGreater(num_knocks, 38)
self.assertLess(num_knocks, 62)
def can_play(self, board):
for tile in self.hand:
for direction in all_dirs():
if board.valid_move(tile, direction):
return True
return False
def playable_moves(board, tile):
playable_moves = []
for direction in all_dirs():
if board.valid_move(tile, direction):
playable_moves.append((tile, direction))
return playable_moves
def can_play_tile(self, tile):
for direction in all_dirs():
if self.valid_move(tile, direction):
return True
return False