Esempio n. 1
0
    def build_second_settlement(self, player: Player, vertex: Vertex):
        new_settlement = Settlement(player=player)
        vertex.assign_building(new_settlement)

        for hex in self.board.hexes:
            if vertex in hex.vertices and hex.resource_type:
                self.player_hand[player].add(resource_type=hex.resource_type, count=1)
Esempio n. 2
0
 def build_settlement(self, player: Player, vertex: Vertex):
     self.player_hand[player].remove(resource_type=Wood, count=1)
     self.player_hand[player].remove(resource_type=Clay, count=1)
     self.player_hand[player].remove(resource_type=Wheat, count=1)
     self.player_hand[player].remove(resource_type=Sheep, count=1)
     new_settlement = Settlement(player=player)
     vertex.assign_building(building=new_settlement)
    def test_can_build_settlement_returns_nothing_if_no_vertices_available(
            self):
        player = Player()
        state = State(players=[player])

        for vertex in state.board.vertices:
            vertex.building = Settlement(player=player)

        assert state.can_build_settlement(player=player) == []
    def test_is_game_over_player_has_won(self):
        state = State(players=["p1", "p2"])

        state.board.vertices[0].building = City(player="p1")
        state.board.vertices[1].building = Settlement(player="p1")
        state.bonus_victory_points["p1"]["victory_point_development_cards"] = 3
        state.bonus_victory_points["p1"]["longest_road"] = True
        state.bonus_victory_points["p1"]["largest_army"] = True

        assert state.is_game_over() == "p1"
Esempio n. 5
0
    def test_can_place_road_retruns_true_if_adjacent_building_for_player(self):
        player = Player()

        edge = Edge(id=0)
        vertex = Vertex(id=0)

        edge.vertices = [vertex]
        vertex.edges = [edge]
        vertex.assign_building(building=Settlement(player=player))

        assert edge.can_place_road(player=player)
Esempio n. 6
0
    def test_can_place_building_returns_false_if_building_exists(self):
        player = Player()
        vertex = Vertex(id=0)
        edge = Edge(id=0)

        edge.vertices = [vertex]
        edge.road = Road(player)
        vertex.edges = [edge]
        vertex.assign_building(building=Settlement(player=player))

        assert not vertex.can_place_building(player=player)
    def test_can_build_second_settlement(self):
        player = Player()
        other_player = Player()
        state = State(players=[player, other_player])

        state.board.vertices[-1].assign_building(building=Settlement(
            player=other_player))

        assert len(state.can_build_second_settlement(player=player)) == 51
        assert state.can_build_second_settlement(player=player)[0] == Action(
            name="build_second_settlement",
            kwargs={"vertex": state.board.vertices[0]})
Esempio n. 8
0
    def test_can_place_building_Returns_false_if_building_is_nearby(self):
        player = Player()
        vertex = Vertex(id=0)
        neighbour_vertex = Vertex(id=1)
        edge = Edge(id=0)

        vertex.edges = [edge]
        neighbour_vertex.edges = [edge]
        neighbour_vertex.building = Settlement(player=player)
        edge.vertices = [vertex, neighbour_vertex]
        edge.road = Road(player=player)

        assert not vertex.can_place_building(player=player)
    def test_can_build_starting_road(self):
        player = Player()
        state = State(players=[player])

        state.board.vertices[0].assign_building(building=Settlement(
            player=player))

        assert state.can_build_starting_road(player=player) == [
            Action(name="build_starting_road",
                   kwargs={"edge": state.board.edges[0]}),
            Action(name="build_starting_road",
                   kwargs={"edge": state.board.edges[6]}),
        ]
Esempio n. 10
0
 def build_first_settlement(self, player: Player, vertex: Vertex):
     new_settlement = Settlement(player=player)
     vertex.assign_building(new_settlement)
Esempio n. 11
0
    def test_victory_points_for_player_with_buildings(self):
        building = Settlement(player="p1")
        board = Board()
        board.vertices[0].building = building

        assert board.victory_points_for_player("p1") == 1