示例#1
0
    def test_demolish_house(self):
        state = GameState(1)

        # Set up a player to own a property with 1 house
        player = state.players[0]
        park_place = state.squares[INDEX[PARK_PLACE]]
        boardwalk = state.squares[INDEX[BOARDWALK]]
        state.apply(
            GroupOfChanges(
                [GameStateChange.buy_property(park_place, player,
                                              state.bank)]))
        state.apply(
            GroupOfChanges(
                [GameStateChange.buy_property(boardwalk, player, state.bank)]))
        state.apply(GroupOfChanges([GameStateChange.build(boardwalk, state)]))

        # Test applying the changes by comparing differences in their string
        # encodings. Ensure that no additional changes were made to the state.
        str_before = str(state)
        state.apply(
            GroupOfChanges([GameStateChange.demolish(boardwalk, state)]))
        str_after = str(state)
        expected_diff = [
            ('Cash: 550', 'Cash: 650'),  # player cash
            ('Cash: 950', 'Cash: 850'),  # bank cash
            ('Num houses: 1', 'Num houses: 0'),
            ('Houses remaining: 31', 'Houses remaining: 32')
        ]
        self.assertDiffGameStates(
            str_before,
            str_after,
            expected_diff,
            msg='House demolition was not applied correctly')
	def test_demolish_house(self):
		state = GameState(1)

		# Set up a player to own a property with 1 house
		player = state.players[0]
		park_place = state.squares[INDEX[PARK_PLACE]]
		boardwalk = state.squares[INDEX[BOARDWALK]]
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(park_place, player, state.bank)]))
		state.apply(GroupOfChanges([
			GameStateChange.buy_property(boardwalk, player, state.bank)]))
		state.apply(GroupOfChanges([
			GameStateChange.build(boardwalk, state)]))

		# Test applying the changes by comparing differences in their string
		# encodings. Ensure that no additional changes were made to the state.
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.demolish(boardwalk, state)]))
		str_after = str(state)
		expected_diff = [
			('Cash: 550', 'Cash: 650'),  # player cash
			('Cash: 950', 'Cash: 850'),  # bank cash
			('Num houses: 1', 'Num houses: 0'),
			('Houses remaining: 31', 'Houses remaining: 32')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='House demolition was not applied correctly')
 def bid_hotel_demolitions(self, player, highest_bid, props_to_demolish_on,
                           state):
     bid = player.cash / 2
     prop_to_demolish_on = props_to_demolish_on[0]
     hotel_demolition = GameStateChange.demolish(prop, state)
     house_builds = [GameStateChange.build(prop, state)
                     ] * NUM_HOUSES_BEFORE_HOTEL
     return GroupOfChanges([hotel_demolition] + house_builds)
    def _demolish_from_property_group(prop, state):
        max_houses = 0
        max_houses_prop = None
        for prop in state.get_property_group(prop.property_group):
            if prop.num_houses > max_houses:
                max_houses = prop.num_houses
                max_houses_prop = prop

        if max_houses_prop != None:
            return GameStateChange.demolish(max_houses_prop, state)
        else:
            return None
	def _demolish_from_property_group(prop, state):
		max_houses = 0
		max_houses_prop = None
		for prop in state.get_property_group(prop.property_group):
			if prop.num_houses > max_houses:
				max_houses = prop.num_houses
				max_houses_prop = prop

		if max_houses_prop != None:
			return GameStateChange.demolish(max_houses_prop, state)
		else:
			return None
示例#6
0
    def test_demolish_hotel(self):
        state = GameState(1)

        # Set up a player to own a property group with hotels on all properties
        player = state.players[0]
        state.apply(
            GroupOfChanges([
                GameStateChange.transfer_money(state.bank, player, 440)
            ]))  # Needs 440 more to buy everything
        pinks = [ST_CHARLES_PLACE, STATES_AVENUE, VIRGINIA_AVENUE]
        changes = []
        for prop_name in pinks:
            changes.append(
                GameStateChange.buy_property(state.squares[INDEX[prop_name]],
                                             player, state.bank))

        state.apply(GroupOfChanges(changes))

        for i in range(0, 5):
            for prop_name in pinks:
                state.apply(
                    GroupOfChanges([
                        GameStateChange.build(state.squares[INDEX[prop_name]],
                                              state)
                    ]))

        # Test demolition
        str_before = str(state)
        state.apply(
            GroupOfChanges([
                GameStateChange.demolish(
                    state.squares[INDEX[ST_CHARLES_PLACE]], state)
            ]))
        str_after = str(state)
        expected_diff = [
            ('Cash: 0', 'Cash: 50'),  # player cash
            ('Cash: 1500', 'Cash: 1450'),  # bank cash
            ('Num houses: 5', 'Num houses: 4'),  # st charles place
            ('Houses remaining: 32', 'Houses remaining: 28'),
            ('Hotels remaining: 9', 'Hotels remaining: 10')
        ]
        self.assertDiffGameStates(
            str_before,
            str_after,
            expected_diff,
            msg='Hotel demolition was not applied correctly')
	def test_demolish_hotel(self):
		state = GameState(1)

		# Set up a player to own a property group with hotels on all properties
		player = state.players[0]
		state.apply(GroupOfChanges([
			GameStateChange.transfer_money(state.bank, player, 440)])) # Needs 440 more to buy everything
		pinks = [ST_CHARLES_PLACE, STATES_AVENUE, VIRGINIA_AVENUE]
		changes = []
		for prop_name in pinks:
			changes.append(GameStateChange.buy_property(state.squares[INDEX[prop_name]],
				player, state.bank))

		state.apply(GroupOfChanges(changes))

		for i in range(0, 5):
			for prop_name in pinks:
				state.apply(GroupOfChanges([
					GameStateChange.build(state.squares[INDEX[prop_name]], state)
				]))

		# Test demolition
		str_before = str(state)
		state.apply(GroupOfChanges([
			GameStateChange.demolish(state.squares[INDEX[ST_CHARLES_PLACE]], state)
		]))
		str_after = str(state)
		expected_diff = [
			('Cash: 0', 'Cash: 50'),            # player cash
			('Cash: 1500', 'Cash: 1450'),       # bank cash
			('Num houses: 5', 'Num houses: 4'), # st charles place
			('Houses remaining: 32', 'Houses remaining: 28'),
			('Hotels remaining: 9', 'Hotels remaining: 10')
		]
		self.assertDiffGameStates(str_before, str_after, expected_diff,
			msg='Hotel demolition was not applied correctly')
	def bid_hotel_demolitions(self, player, highest_bid, props_to_demolish_on, state):
		bid = player.cash / 2
		prop_to_demolish_on = props_to_demolish_on[0]
		hotel_demolition = GameStateChange.demolish(prop, state)
		house_builds = [GameStateChange.build(prop, state)] * NUM_HOUSES_BEFORE_HOTEL
		return GroupOfChanges([hotel_demolition] + house_builds)