def __init__(self, players):
# Initialise Board
number_of_players = 4
self.game_board = Board(number_of_players)
# Start off robber on desert tile
for index, hex in enumerate(self.game_board.hexes):
if hex.resource_index == -1:
self.robber_location = index
"""
Initialise development cards:
- self.development_cards is deck of development cards
- Indices refer to: [Knight, Take 2 Resources, Construct 2 Roads, Monopoly, Victory Point]
"""
number_of_development_cards = [20, 3, 3, 3, 5]
self.development_cards = []
for development_card_index in range(5):
for i in range(
number_of_development_cards[development_card_index]):
self.development_cards.append(development_card_index)
random.shuffle(self.development_cards)
# Initialise player states
self.players = players
self.player_turn = 0
self.starting_player = 0
self.points = [0, 0, 0, 0]
self.road_network = [None] * 4
self.road_lengths = [0, 0, 0, 0]
self.longest_road_player_index = 0
self.settlements = [0, 0, 0, 0]
self.cities = [0, 0, 0, 0]
self.knights = [0, 0, 0, 0]
self.largest_army_index = 0
for index, player in enumerate(self.players):
player.player_index = index
player.game_manager = self
# Initialise player road network
self.road_network[index] = RoadNetwork(self.game_board, index)
# self.action_functions is a dictionary storing references to the functions to perform actions
self.action_functions = {
'Settlements': self.buildSettlement,
'Cities': self.buildCity,
'Roads': self.buildRoad,
'TradeWithGame': self.tradeWithGame,
'BuyDevelopmentCard': self.buyDevelopmentCard,
'Knight': self.useKnightCard
}
def test_value(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
self.assertEquals(110, bi.get_value(1))
bi.downgrade("red", 1)
self.assertEquals(60, bi.get_value(1))
def test_can_purchase(self):
bi = Board(["red", "blue"])
self.assertTrue(bi.can_purchase(6))
self.assertTrue(bi.can_purchase(8))
self.assertTrue(bi.can_purchase(9))
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertFalse(bi.can_purchase(6))
self.assertFalse(bi.can_purchase(8))
self.assertFalse(bi.can_purchase(9))
def test_rent(self):
bi = Board(["red", "blue"])
self.assertEquals(0, bi.get_rent(6, 7))
self.assertEquals(0, bi.get_rent(8, 7))
self.assertEquals(0, bi.get_rent(9, 7))
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(6, bi.get_rent(6, 7))
self.assertEquals(6, bi.get_rent(8, 7))
self.assertEquals(8, bi.get_rent(9, 7))
def test_level(self):
bi = Board(["red", "blue"])
self.assertEquals(0, bi.get_level(6))
self.assertEquals(0, bi.get_level(8))
self.assertEquals(0, bi.get_level(9))
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(1, bi.get_level(6))
self.assertEquals(1, bi.get_level(8))
self.assertEquals(1, bi.get_level(9))
def test_value(self):
bi = Board(["red", "blue"])
self.assertEquals(0, bi.get_value(6))
self.assertEquals(0, bi.get_value(8))
self.assertEquals(0, bi.get_value(9))
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(100, bi.get_value(6))
self.assertEquals(100, bi.get_value(8))
self.assertEquals(120, bi.get_value(9))
def test_can_mortgage_other_props_of_same_color(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
self.assertFalse(bi.can_mortgage("red", 1))
self.assertFalse(bi.can_mortgage("red", 3))
bi.downgrade("red", 1)
self.assertTrue(bi.can_mortgage("red", 1))
def test_can_unmortgage(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
bi.downgrade("red", 1)
self.assertFalse(bi.can_unmortgage("red", 1))
self.assertFalse(bi.can_unmortgage("red", 3))
def test_can_downgrade_non_max(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
bi.upgrade("red", 1)
bi.downgrade("red", 1)
self.assertTrue(bi.can_downgrade("red", 1))
def test_ConnectedNodesBuiltOn(self):
"""
Test function to check connected nodes not built on
"""
# Initialise board
board = Board(4)
# Place settlement on node 31
board.nodes[31].settlement = [1, 0, 0, 0]
# Test node 32 returns false as it is connected to 31
self.assertEqual(board.connectedNodesBuiltOn(32), False)
# Test node 33 returns True as it isn't connected to 31
self.assertEqual(board.connectedNodesBuiltOn(33), True)
def test_houses_decline(self):
bi = Board(["red", "blue"],
10000,
available_houses=20,
available_hotels=4)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(20, bi.available_houses)
bi.upgrade("red", 1)
self.assertEquals(19, bi.available_houses)
bi.upgrade("red", 1)
self.assertEquals(18, bi.available_houses)
bi.upgrade("red", 1)
self.assertEquals(17, bi.available_houses)
def test_can_upgrade_no_hotels(self):
bi = Board(["red", "blue"],
10000,
available_houses=20,
available_hotels=0)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
bi.upgrade("red", 1)
bi.upgrade("red", 1)
bi.upgrade("red", 1)
self.assertFalse(bi.can_upgrade("red", 1))
self.assertTrue(bi.can_upgrade("red", 3))
def test_can_downgrade_monopoly_mortgaged(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.mortgage("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
self.assertFalse(bi.can_downgrade("blue", 1))
def test_unmortgage_without_mortgaging(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 6))
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 8))
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 9))
def test_level(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(1, bi.get_level(1))
bi.mortgage("red", 1)
self.assertEquals(0, bi.get_level(1))
def test_game_won_with_downwards_diagonal_of_reds():
validator = BVD.BoardValidatorDiagonals()
board_empty = Board.Board()
assert not (validator.connected_4_in_diagonal(board_empty.columns))
board_won = BoardMaker.make_board_won_with_diagonal_downwards_of_reds()
assert (validator.connected_4_in_diagonal(board_won.columns))
def test_NodeHasRoad(self):
"""
Test Board nodeHasRoad function
"""
# Initialise board
board = Board(4)
# Test node 30 with no connected edges built on
self.assertEqual(board.nodeHasRoad(30, 2), False)
# Test node 30 with one connected built on but wrong player
board.nodes[30].connected_edges[0].road = [1, 0, 0, 0]
self.assertEqual(board.nodeHasRoad(30, 2), False)
# Test node 30 with one connected built on but correct player
board.nodes[30].connected_edges[0].road = [1, 0, 0, 0]
self.assertEqual(board.nodeHasRoad(30, 0), True)
def test_rent(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(2, bi.get_rent(1, dice_roll=7))
bi.mortgage("red", 1)
self.assertEquals(0, bi.get_rent(1, dice_roll=7))
def test_can_purchase(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertFalse(bi.can_purchase(1))
bi.mortgage("red", 1)
self.assertFalse(bi.can_purchase(1))
def test_value(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(60, bi.get_value(1))
bi.mortgage("red", 1)
self.assertEquals(30, bi.get_value(1))
def test_non_player(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertRaises(BoardError, lambda: bi.unmortgage("reed", 6))
def make_board_won_with_diagonal_downwards_of_reds():
board = Board.Board()
board.columns[0] = make_column(["RED", "YELLOW", "", "", "", ""])
board.columns[1] = make_column(["YELLOW", "", "", "", "", ""])
board.columns[2] = make_column(["YELLOW", "YELLOW", "RED", "RED", "", ""])
board.columns[3] = make_column(["RED", "YELLOW", "RED", "", "", ""])
board.columns[4] = make_column(["RED", "RED", "", "", "", ""])
board.columns[5] = make_column(["RED", "", "", "", "", ""])
return board
def make_board_won_with_row_of_yellows():
board = Board.Board()
board.columns[0] = make_column(["RED", "RED", "YELLOW", "RED", "", ""])
board.columns[1] = make_column(["YELLOW", "RED", "RED", "RED", "", ""])
board.columns[2] = make_column(["YELLOW", "YELLOW", "YELLOW", "", "", ""])
board.columns[3] = make_column(["RED", "YELLOW", "YELLOW", "", "", ""])
board.columns[4] = make_column(["RED", "RED", "YELLOW", "RED", "", ""])
board.columns[5] = make_column(["RED", "RED", "YELLOW", "RED", "", ""])
return board
def test_other_props_cant_upgrade(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertTrue(bi.can_upgrade("red", 1))
bi.mortgage("red", 1)
self.assertRaises(BoardError, lambda: bi.upgrade("red", 3))
self.assertRaises(BoardError, lambda: bi.upgrade("red", 1))
def test_can_downgrade_level_1(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertFalse(bi.can_downgrade("red", 1))
self.assertFalse(bi.can_downgrade("blue", 1))
self.assertFalse(bi.can_downgrade("red", 3))
self.assertFalse(bi.can_downgrade("blue", 3))
def test_can_upgrade_monopoly(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertTrue(bi.can_upgrade("red", 1))
self.assertFalse(bi.can_upgrade("blue", 1))
self.assertTrue(bi.can_upgrade("red", 3))
self.assertFalse(bi.can_upgrade("blue", 3))
def make_board_almost_won_both():
board = Board.Board()
board.columns[0] = make_column(["RED", "RED", "RED", "", "", ""])
board.columns[1] = make_column(["YELLOW", "", "", "", "", ""])
board.columns[2] = make_column(["YELLOW", "", "", "", "", ""])
board.columns[3] = make_column(["YELLOW", "", "", "", "", ""])
board.columns[4] = make_column(["", "", "", "", "", ""])
board.columns[5] = make_column(["", "", "", "", "", ""])
board.columns[6] = make_column(["", "", "", "", "", ""])
return board
def test_EdgeHasRoadOrSettlement(self):
"""
Test edgeHasRoadOrSettlement function of board
"""
# Initialise board
board = Board(4)
# Test unconnected edge
self.assertEqual(board.edgeHasRoadOrSettlement(24, 2), False)
"""
Test by road connectivity:
Edge 20 connects nodes 11 and 21
- node 11: connected to edges: 13, 14, 20
- node 21: connected to edges: 20, 27, 28
"""
# Place road on edge 20
board.edges[20].road = [1, 0, 0, 0]
# Test edge 13 (connected to node 11) for player 0
self.assertEqual(board.edgeHasRoadOrSettlement(13, 0), True)
# Test edge 13 (connected to node 11) for player 2
self.assertEqual(board.edgeHasRoadOrSettlement(13, 2), False)
"""
Test by settlement and city connectivity:
Edge 48 connects nodes 36 and 37
"""
# Place settlement on node 36
board.nodes[36].settlement = [1, 0, 0, 0]
# Test edge 48 for player 0
self.assertEqual(board.edgeHasRoadOrSettlement(48, 0), True)
# Test edge 48 for player 2
self.assertEqual(board.edgeHasRoadOrSettlement(48, 2), False)
# Remove settlement and build city
board.nodes[36].settlement = [0, 0, 0, 0]
board.nodes[36].city = [1, 0, 0, 0]
# Test edge 48 for player 0
self.assertEqual(board.edgeHasRoadOrSettlement(48, 0), True)
# Test edge 48 for player 2
self.assertEqual(board.edgeHasRoadOrSettlement(48, 2), False)
def test_non_player(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertRaises(BoardError, lambda: bi.mortgage("reed", 3))
with self.assertRaises(BoardError):
bi.mortgage("reed", 3)
def test_unowned_property(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertRaises(BoardError, lambda: bi.mortgage("red", 6))
with self.assertRaises(BoardError):
bi.mortgage("red", 6)
