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)