def test_get_legal_moves(self):
game = dnbpy.Game((1, 1), ['player1', 'player2'])
self.assertEqual([0, 1, 2, 3], game.get_legal_moves())
game = dnbpy.Game((1, 1), ['player1', 'player2'], board_state=[0, 1, 1, 0])
self.assertEqual([0, 3], game.get_legal_moves())
game.select_edge(0, 'player1')
self.assertEqual([3], game.get_legal_moves())
game.select_edge(3, 'player2')
self.assertEqual([], game.get_legal_moves())
def test_get_strings_and_coins_1x1_edges_selected(self):
game = dnbpy.Game((1, 1), ['p1', 'p2'])
game.select_edge(0, 'p1')
game.select_edge(2, 'p2')
"""
*---------*
|
1 |
|
* 3 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-1-2-3',
'ground-1',
'ground-2',
'ground-0',
'ground-3',
])
self.assertEqual(strings_and_coins.edges, [('ground-1', '0-1-2-3'),
('ground-3', '0-1-2-3')])
self.assertEqual(0, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-3'))
self.assertEqual(2, strings_and_coins.get_node_degree('0-1-2-3'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 0, 0, 1], [1, 0, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0], [1, 0, 0, 0, 0]])
def test_get_long_chains_3x3_multiple(self):
game = dnbpy.Game((3, 3), ['p1', 'p2'])
game.select_edge(3, 'p1')
game.select_edge(10, 'p2')
game.select_edge(17, 'p1')
game.select_edge(4, 'p2')
game.select_edge(11, 'p1')
game.select_edge(18, 'p2')
game.select_edge(5, 'p1')
game.select_edge(12, 'p2')
game.select_edge(19, 'p1')
game.select_edge(6, 'p2')
game.select_edge(13, 'p1')
game.select_edge(20, 'p2')
"""
This board contains 3 chains (i.e. a string of at least 3 non-ground nodes):
* 0 * 1 * 2 *
| | | |
| | | |
| | | |
* 7 * 8 * 9 *
| | | |
| | | |
| | | |
* 14 * 15 * 16 *
| | | |
| | | |
| | | |
* 21 * 22 * 23 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
chains = strings_and_coins.get_long_chains()
self.assertEqual([['0-3-4-7', '7-10-11-14', '14-17-18-21'],
['1-4-5-8', '8-11-12-15', '15-18-19-22'],
['2-5-6-9', '9-12-13-16', '16-19-20-23']], chains)
def test_get_strings_and_coins_1x1(self):
game = dnbpy.Game((1, 1), ['p1', 'p2'])
"""
* 0 *
1 2
* 3 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-1-2-3',
'ground-1',
'ground-2',
'ground-0',
'ground-3',
])
self.assertEqual(strings_and_coins.edges, [('ground-1', '0-1-2-3'),
('ground-2', '0-1-2-3'),
('ground-0', '0-1-2-3'),
('ground-3', '0-1-2-3')])
self.assertEqual(1, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-3'))
self.assertEqual(4, strings_and_coins.get_node_degree('0-1-2-3'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 1, 1, 1], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0],
[1, 0, 0, 0, 0], [1, 0, 0, 0, 0]])
def test_get_board_state_3x3(self):
game = dnbpy.Game((3, 3), ['player1', 'player2'])
board_state = game.get_board_state()
self.assertEqual(board_state, [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0
])
def test_policy_with_heuristic(self):
board_size = (3, 3)
def heuristic(board_state, max_score, min_score, is_max):
return -min_score
players = {
"p1":
dnbpy.Level3MinimaxPolicy(board_size,
3,
random_state=0,
heuristic=heuristic),
"p2":
dnbpy.Level2HeuristicPolicy(board_size, random_state=0)
}
game = dnbpy.Game(board_size, ["p1", "p2"])
while not game.is_finished():
current_player = game.get_current_player()
opp_player = "p2" if current_player == "p1" else "p1"
edge = players[current_player].select_edge(
game.get_board_state(), game.get_score(current_player),
game.get_score(opp_player))
game.select_edge(edge, current_player)
self.assertEqual(5, game.get_score("p1"))
self.assertEqual(4, game.get_score("p2"))
def test_to_string_3x3(self):
game = dnbpy.Game((3, 3), ['p1', 'p2'])
game.select_edge(0, 'p1')
game.select_edge(9, 'p2')
game.select_edge(10, 'p1')
game.select_edge(13, 'p2')
game.select_edge(2, 'p1')
game.select_edge(6, 'p2')
game.select_edge(5, 'p1')
game.select_edge(12, 'p1')
game.select_edge(16, 'p2')
expected = ("*---------* 1 *---------* \n"
" | | \n"
"3 4 | p1 | \n"
" | | \n"
"* 7 * 8 *---------* \n"
"| | | \n"
"| 11 | p2 | \n"
"| | | \n"
"* 14 * 15 *---------* \n"
" \n"
"17 18 19 20 \n"
" \n"
"* 21 * 22 * 23 * \n"
"\n"
"p1: 1, p2: 1")
self.assertEqual(str(game), expected)
def test_get_long_chains_3x3(self):
game = dnbpy.Game((3, 3), ['p1', 'p2'])
game.select_edge(4, 'p1')
game.select_edge(12, 'p2')
game.select_edge(9, 'p1')
game.select_edge(1, 'p2')
game.select_edge(11, 'p1')
game.select_edge(3, 'p2')
game.select_edge(10, 'p1')
game.select_edge(2, 'p2')
"""
This board contains a single chain (i.e. a string of at least 3 non-ground nodes):
* 0 *---------*---------*
| |
| | 5 6
| |
* 7 * 8 *---------*
| | |
| | | 13
| | |
* 14 * 15 * 16 *
17 18 19 20
* 21 * 22 * 23 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
chains = strings_and_coins.get_long_chains()
self.assertEqual([['2-5-6-9', '1-4-5-8', '8-11-12-15']], chains)
def test_get_all_boxes_2x2(self):
game = dnbpy.Game((2, 2), ['player1', 'player2'])
boxes = game.get_all_boxes()
self.assertTrue(len(boxes) == 4)
self.assertEqual(str(boxes[0]), '0-2-3-5')
self.assertEqual(str(boxes[1]), '1-3-4-6')
self.assertEqual(str(boxes[2]), '5-7-8-10')
self.assertEqual(str(boxes[3]), '6-8-9-11')
def test_get_all_boxes_2x3(self):
game = dnbpy.Game((2, 3), ['player1', 'player2'])
boxes = game.get_all_boxes()
self.assertTrue(len(boxes) == 6)
self.assertEqual(str(boxes[0]), '0-3-4-7')
self.assertEqual(str(boxes[1]), '1-4-5-8')
self.assertEqual(str(boxes[2]), '2-5-6-9')
self.assertEqual(str(boxes[3]), '7-10-11-14')
self.assertEqual(str(boxes[4]), '8-11-12-15')
self.assertEqual(str(boxes[5]), '9-12-13-16')
def test_get_current_player(self):
game = dnbpy.Game((1, 1), ['player1', 'player2'])
self.assertEqual(game.get_current_player(), 'player1')
game.select_edge(0, 'player1')
self.assertEqual(game.get_current_player(), 'player2')
game.select_edge(1, 'player2')
self.assertEqual(game.get_current_player(), 'player1')
game.select_edge(2, 'player1')
self.assertEqual(game.get_current_player(), 'player2')
game.select_edge(3, 'player2')
self.assertIsNone(game.get_current_player())
def test_get_boxes_2x2(self):
game = dnbpy.Game((2, 2), ['player1', 'player2'])
game.select_edge(0, 'player1')
game.select_edge(2, 'player2')
game.select_edge(3, 'player1')
game.select_edge(5, 'player2')
boxes = game.get_boxes('player1')
self.assertEqual(len(boxes), 0)
boxes = game.get_boxes('player2')
self.assertEqual(len(boxes), 1)
self.assertEqual(str(boxes[0]), '0-2-3-5')
def test_to_string_1x1(self):
game = dnbpy.Game((1, 1), ['p1', 'p2'])
game.select_edge(0, 'p1')
game.select_edge(1, 'p2')
expected = ("*---------* \n"
"| \n"
"| 2 \n"
"| \n"
"* 3 * \n"
"\n"
"p1: 0, p2: 0")
self.assertEqual(str(game), expected)
def test_select_edge_2x2(self):
game = dnbpy.Game((2, 2), ['player1', 'player2'])
next_player, boxes_made = game.select_edge(2, 'player1')
self.assertEqual(next_player, 'player2')
self.assertEqual(boxes_made, 0)
board_state = game.get_board_state()
self.assertEqual(board_state, [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
next_player, boxes_made = game.select_edge(5, 'player2')
self.assertEqual(next_player, 'player1')
self.assertEqual(boxes_made, 0)
board_state = game.get_board_state()
self.assertEqual(board_state, [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0])
def test_get_all_boxes_3x3(self):
game = dnbpy.Game((3, 3), ['player1', 'player2'])
boxes = game.get_all_boxes()
self.assertTrue(len(boxes) == 9)
self.assertEqual(str(boxes[0]), '0-3-4-7')
self.assertEqual(str(boxes[1]), '1-4-5-8')
self.assertEqual(str(boxes[2]), '2-5-6-9')
self.assertEqual(str(boxes[3]), '7-10-11-14')
self.assertEqual(str(boxes[4]), '8-11-12-15')
self.assertEqual(str(boxes[5]), '9-12-13-16')
self.assertEqual(str(boxes[6]), '14-17-18-21')
self.assertEqual(str(boxes[7]), '15-18-19-22')
self.assertEqual(str(boxes[8]), '16-19-20-23')
def test_to_string_1x2(self):
game = dnbpy.Game((1, 2), ['p1', 'p2'])
game.select_edge(1, 'p1')
game.select_edge(3, 'p2')
game.select_edge(6, 'p1')
expected = ("* 0 *---------* \n"
" | \n"
"2 | 4 \n"
" | \n"
"* 5 *---------* \n"
"\n"
"p1: 0, p2: 0")
self.assertEqual(str(game), expected)
def test_select_edge_returns_next_player(self):
game = dnbpy.Game((1, 1), ['player1', 'player2'])
next_player, boxes_made = game.select_edge(0, 'player1')
self.assertEqual(next_player, 'player2')
self.assertEqual(boxes_made, 0)
next_player, boxes_made = game.select_edge(1, 'player2')
self.assertEqual(next_player, 'player1')
self.assertEqual(boxes_made, 0)
next_player, boxes_made = game.select_edge(2, 'player1')
self.assertEqual(next_player, 'player2')
self.assertEqual(boxes_made, 0)
next_player, boxes_made = game.select_edge(3, 'player2')
self.assertEqual(boxes_made, 1)
self.assertIsNone(next_player)
self.assertEqual(game.get_score('player1'), 0)
self.assertEqual(game.get_score('player2'), 1)
with self.assertRaises(Exception) as e:
game.select_edge(1, 'player1')
self.assertTrue(("game is finished" in str(e.exception)))
def test_get_score_2x2(self):
game = dnbpy.Game((2, 2), ['player1', 'player2'])
game.select_edge(0, 'player1')
game.select_edge(2, 'player2')
game.select_edge(3, 'player1')
game.select_edge(5, 'player2')
score = game.get_score('player1')
self.assertEqual(score, 0)
score = game.get_score('player2')
self.assertEqual(score, 1)
self.assertFalse(game.is_finished())
game.select_edge(11, 'player2')
game.select_edge(6, 'player1')
game.select_edge(10, 'player2')
game.select_edge(8, 'player1')
score = game.get_score('player1')
self.assertEqual(score, 0)
score = game.get_score('player2')
self.assertEqual(score, 1)
game.select_edge(9, 'player2')
game.select_edge(7, 'player2')
score = game.get_score('player1')
self.assertEqual(score, 0)
score = game.get_score('player2')
self.assertEqual(score, 3)
game.select_edge(4, 'player2')
game.select_edge(1, 'player1')
score = game.get_score('player1')
self.assertEqual(score, 1)
score = game.get_score('player2')
self.assertEqual(score, 3)
self.assertTrue(game.is_finished())
with self.assertRaises(Exception) as e:
game.select_edge(1, 'player1')
self.assertTrue(("game is finished" in str(e.exception)))
boxes = game.get_boxes('player1')
self.assertEqual(len(boxes), 1)
self.assertEqual(str(boxes[0]), '1-3-4-6')
boxes = game.get_boxes('player2')
self.assertEqual(len(boxes), 3)
self.assertEqual(str(boxes[0]), '5-7-8-10')
self.assertEqual(str(boxes[1]), '0-2-3-5')
self.assertEqual(str(boxes[2]), '6-8-9-11')
def test_to_string_2x2(self):
game = dnbpy.Game((2, 2), ['p1', 'p2'])
game.select_edge(1, 'p1')
game.select_edge(3, 'p2')
game.select_edge(4, 'p1')
game.select_edge(6, 'p2')
game.select_edge(11, 'p2')
expected = ("* 0 *---------* \n"
" | | \n"
"2 | p2 | \n"
" | | \n"
"* 5 *---------* \n"
" \n"
"7 8 9 \n"
" \n"
"* 10 *---------* \n"
"\n"
"p1: 0, p2: 1")
self.assertEqual(str(game), expected)
def test_policy_with_no_depth(self):
board_size = (3, 3)
players = {
"p1": dnbpy.Level3MinimaxPolicy(board_size, random_state=0),
"p2": dnbpy.Level2HeuristicPolicy(board_size, random_state=0)
}
game = dnbpy.Game(board_size, ["p1", "p2"])
while not game.is_finished():
current_player = game.get_current_player()
opp_player = "p2" if current_player == "p1" else "p1"
edge = players[current_player].select_edge(
game.get_board_state(), game.get_score(current_player),
game.get_score(opp_player))
game.select_edge(edge, current_player)
self.assertEqual(7, game.get_score("p1"))
self.assertEqual(2, game.get_score("p2"))
def test_policy(self):
board_size = (3, 3)
players = {
"p1":
dnbpy.Level1HeuristicPolicy(board_size, random_state=0),
"p2":
dnbpy.MCTSPolicy(board_size, 500, reset_tree=True, random_state=0)
}
game = dnbpy.Game(board_size, ["p1", "p2"])
while not game.is_finished():
current_player = game.get_current_player()
opp_player = "p2" if current_player == "p1" else "p1"
edge = players[current_player].select_edge(
game.get_board_state(), game.get_score(current_player),
game.get_score(opp_player))
game.select_edge(edge, current_player)
self.assertEqual(4, game.get_score("p1"))
self.assertEqual(5, game.get_score("p2"))
def test_get_long_chains_2x3_closed(self):
game = dnbpy.Game((2, 3), ['p1', 'p2'])
game.select_edge(7, 'p1')
game.select_edge(8, 'p2')
game.select_edge(9, 'p1')
game.select_edge(10, 'p2')
game.select_edge(13, 'p1')
game.select_edge(14, 'p2')
game.select_edge(15, 'p1')
"""
This board contains a single chain (i.e. a string of at least 3 non-ground nodes):
* 0 * 1 * 2 *
3 4 5 6
*---------*---------*---------*
| |
| 11 12 |
| |
*---------*---------* 16 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
chains = strings_and_coins.get_long_chains()
self.assertEqual([['7-10-11-14', '8-11-12-15', '9-12-13-16']], chains)
def test_get_strings_and_coins_3x2(self):
game = dnbpy.Game((3, 2), ['p1', 'p2'])
"""
* 0 * 1 *
2 3 4
* 5 * 6 *
7 8 9
* 10 * 11 *
12 13 14
* 15 * 16 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-2-3-5', 'ground-2', 'ground-0', '1-3-4-6', 'ground-4',
'ground-1', '5-7-8-10', 'ground-7', '6-8-9-11', 'ground-9',
'10-12-13-15', 'ground-12', 'ground-15', '11-13-14-16',
'ground-14', 'ground-16'
])
self.assertEqual(strings_and_coins.edges,
[('ground-2', '0-2-3-5'), ('ground-0', '0-2-3-5'),
('0-2-3-5', '1-3-4-6'), ('ground-4', '1-3-4-6'),
('ground-1', '1-3-4-6'), ('0-2-3-5', '5-7-8-10'),
('ground-7', '5-7-8-10'), ('1-3-4-6', '6-8-9-11'),
('5-7-8-10', '6-8-9-11'), ('ground-9', '6-8-9-11'),
('5-7-8-10', '10-12-13-15'),
('ground-12', '10-12-13-15'),
('ground-15', '10-12-13-15'),
('6-8-9-11', '11-13-14-16'),
('10-12-13-15', '11-13-14-16'),
('ground-14', '11-13-14-16'),
('ground-16', '11-13-14-16')])
self.assertEqual(4, strings_and_coins.get_node_degree('0-2-3-5'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(4, strings_and_coins.get_node_degree('1-3-4-6'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-4'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(4, strings_and_coins.get_node_degree('5-7-8-10'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-7'))
self.assertEqual(4, strings_and_coins.get_node_degree('6-8-9-11'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-9'))
self.assertEqual(4, strings_and_coins.get_node_degree('10-12-13-15'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-12'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-15'))
self.assertEqual(4, strings_and_coins.get_node_degree('11-13-14-16'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-14'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-16'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]])
def test_get_score_player_not_recognized(self):
with self.assertRaises(Exception) as e:
game = dnbpy.Game((2, 2), ['player1', 'player2'])
game.get_score('player3')
self.assertTrue(("player not recognized: player3" in str(e.exception)))
def test_get_strings_and_coins_2x3(self):
game = dnbpy.Game((2, 3), ['p1', 'p2'])
"""
* 0 * 1 * 2 *
3 4 5 6
* 7 * 8 * 9 *
10 11 12 13
* 14 * 15 * 16 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-3-4-7', 'ground-3', 'ground-0', '1-4-5-8', 'ground-1',
'2-5-6-9', 'ground-6', 'ground-2', '7-10-11-14', 'ground-10',
'ground-14', '8-11-12-15', 'ground-15', '9-12-13-16', 'ground-13',
'ground-16'
])
self.assertEqual(strings_and_coins.edges,
[('ground-3', '0-3-4-7'), ('ground-0', '0-3-4-7'),
('0-3-4-7', '1-4-5-8'), ('ground-1', '1-4-5-8'),
('1-4-5-8', '2-5-6-9'), ('ground-6', '2-5-6-9'),
('ground-2', '2-5-6-9'), ('0-3-4-7', '7-10-11-14'),
('ground-10', '7-10-11-14'),
('ground-14', '7-10-11-14'),
('1-4-5-8', '8-11-12-15'),
('7-10-11-14', '8-11-12-15'),
('ground-15', '8-11-12-15'),
('2-5-6-9', '9-12-13-16'),
('8-11-12-15', '9-12-13-16'),
('ground-13', '9-12-13-16'),
('ground-16', '9-12-13-16')])
self.assertEqual(4, strings_and_coins.get_node_degree('0-3-4-7'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-3'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(4, strings_and_coins.get_node_degree('1-4-5-8'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(4, strings_and_coins.get_node_degree('2-5-6-9'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-6'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(4, strings_and_coins.get_node_degree('7-10-11-14'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-10'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-14'))
self.assertEqual(4, strings_and_coins.get_node_degree('8-11-12-15'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-15'))
self.assertEqual(4, strings_and_coins.get_node_degree('9-12-13-16'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-13'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-16'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]])
def play():
print("DNBPy - Play")
num_players = int(input("How many players?: "))
if num_players < 2:
print("Error: there must be at least two players")
sys.exit(0)
players = []
for n in range(num_players):
player = input("player {} name: ".format(n + 1))
players.append(player)
if len(set(players)) == 1:
print("Error: player names must be unique")
sys.exit(0)
board_rows = int(input("Number of board rows: "))
if board_rows < 1:
print("Error: there must be at least one row")
sys.exit(0)
board_cols = int(input("Number of board columns: "))
if board_cols < 1:
print("Error: there must be at least one column")
sys.exit(0)
minimax_depth = None
if "$L3" in players:
val = input("Minimax depth (leave empty for variable depth): ")
if len(val.strip()) > 0:
minimax_depth = int(val)
if minimax_depth < 1:
print("Error: minimax depth must be greater than 0")
sys.exit(0)
num_playouts = 100
if "$mcts" in players:
num_playouts = int(input("Number of playouts: "))
if num_playouts < 1:
print("Error: number of playouts must be greater than 0")
sys.exit(0)
print("preparing game...")
board_size = (board_rows, board_cols)
game = dnbpy.Game(board_size, players)
print(game)
computer_players = {
"$random":
dnbpy.RandomPolicy(),
"$L1":
dnbpy.Level1HeuristicPolicy(board_size=board_size),
"$L2":
dnbpy.Level2HeuristicPolicy(board_size=board_size),
"$L3":
dnbpy.Level3MinimaxPolicy(board_size=board_size,
depth=minimax_depth,
update_alpha=True),
"$mcts":
dnbpy.MCTSPolicy(board_size=board_size, num_playouts=num_playouts)
}
while not game.is_finished():
current_player = game.get_current_player()
if current_player in computer_players:
# get the first player that isn't the current player
opp_player = [p for p in players if p != current_player][0]
move = computer_players[current_player].select_edge(
game.get_board_state(), game.get_score(current_player),
game.get_score(opp_player))
game.select_edge(move, current_player)
print("player %s selects edge %s" % (current_player, move))
else:
try:
move = int(
input("{} select your move: ".format(current_player)))
game.select_edge(move, current_player)
except Exception:
print("illegal move selection.. select again")
print(game)
def test_select_taken_edge(self):
with self.assertRaises(Exception) as e:
game = dnbpy.Game((2, 2), ['player1', 'player2'])
game.select_edge(2, 'player1')
game.select_edge(2, 'player2')
self.assertTrue(("edge already selected: 2" in str(e.exception)))
def test_get_strings_and_coins_2x3_edges_selected(self):
game = dnbpy.Game((2, 3), ['p1', 'p2'])
game.select_edge(4, 'p1')
game.select_edge(12, 'p2')
game.select_edge(9, 'p1')
game.select_edge(1, 'p2')
"""
* 0 *---------* 2 *
|
3 | 5 6
|
* 7 * 8 *---------*
|
10 11 | 13
|
* 14 * 15 * 16 *
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-3-4-7', 'ground-3', 'ground-0', '1-4-5-8', 'ground-1',
'2-5-6-9', 'ground-6', 'ground-2', '7-10-11-14', 'ground-10',
'ground-14', '8-11-12-15', 'ground-15', '9-12-13-16', 'ground-13',
'ground-16'
])
self.assertEqual(strings_and_coins.edges,
[('ground-3', '0-3-4-7'), ('ground-0', '0-3-4-7'),
('1-4-5-8', '2-5-6-9'), ('ground-6', '2-5-6-9'),
('ground-2', '2-5-6-9'), ('0-3-4-7', '7-10-11-14'),
('ground-10', '7-10-11-14'),
('ground-14', '7-10-11-14'),
('1-4-5-8', '8-11-12-15'),
('7-10-11-14', '8-11-12-15'),
('ground-15', '8-11-12-15'),
('ground-13', '9-12-13-16'),
('ground-16', '9-12-13-16')])
self.assertEqual(3, strings_and_coins.get_node_degree('0-3-4-7'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-3'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(2, strings_and_coins.get_node_degree('1-4-5-8'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(3, strings_and_coins.get_node_degree('2-5-6-9'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-6'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(4, strings_and_coins.get_node_degree('7-10-11-14'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-10'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-14'))
self.assertEqual(3, strings_and_coins.get_node_degree('8-11-12-15'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-15'))
self.assertEqual(2, strings_and_coins.get_node_degree('9-12-13-16'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-13'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-16'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]])
def test_get_all_boxes_1x1(self):
game = dnbpy.Game((1, 1), ['player1', 'player2'])
boxes = game.get_all_boxes()
self.assertTrue(len(boxes) == 1)
self.assertEqual(str(boxes[0]), '0-1-2-3')
def test_get_strings_and_coins_3x2_edges_selected(self):
game = dnbpy.Game((3, 2), ['p1', 'p2'])
game.select_edge(0, 'p1')
game.select_edge(4, 'p2')
game.select_edge(7, 'p1')
game.select_edge(13, 'p2')
game.select_edge(16, 'p1')
"""
*---------* 1 *
|
2 3 |
|
* 5 * 6 *
|
| 8 9
|
* 10 * 11 *
|
12 | 14
|
* 15 *---------*
"""
strings_and_coins = dnbpy.StringsAndCoins(game)
self.assertEqual(strings_and_coins.nodes, [
'0-2-3-5', 'ground-2', 'ground-0', '1-3-4-6', 'ground-4',
'ground-1', '5-7-8-10', 'ground-7', '6-8-9-11', 'ground-9',
'10-12-13-15', 'ground-12', 'ground-15', '11-13-14-16',
'ground-14', 'ground-16'
])
self.assertEqual(strings_and_coins.edges,
[('ground-2', '0-2-3-5'), ('0-2-3-5', '1-3-4-6'),
('ground-1', '1-3-4-6'), ('0-2-3-5', '5-7-8-10'),
('1-3-4-6', '6-8-9-11'), ('5-7-8-10', '6-8-9-11'),
('ground-9', '6-8-9-11'),
('5-7-8-10', '10-12-13-15'),
('ground-12', '10-12-13-15'),
('ground-15', '10-12-13-15'),
('6-8-9-11', '11-13-14-16'),
('ground-14', '11-13-14-16')])
self.assertEqual(3, strings_and_coins.get_node_degree('0-2-3-5'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-2'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-0'))
self.assertEqual(3, strings_and_coins.get_node_degree('1-3-4-6'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-4'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-1'))
self.assertEqual(3, strings_and_coins.get_node_degree('5-7-8-10'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-7'))
self.assertEqual(4, strings_and_coins.get_node_degree('6-8-9-11'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-9'))
self.assertEqual(3, strings_and_coins.get_node_degree('10-12-13-15'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-12'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-15'))
self.assertEqual(2, strings_and_coins.get_node_degree('11-13-14-16'))
self.assertEqual(1, strings_and_coins.get_node_degree('ground-14'))
self.assertEqual(0, strings_and_coins.get_node_degree('ground-16'))
self.assertEqual(strings_and_coins.to_adjacency_matrix(),
[[0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
