示例#1
0
    def test_mortgage_property_action(self):
        bsmt_phase = BSMT()
        mortgage_property_phase = MortgageProperty()
        turn_end_phase = TurnEnd()
        phases = {
            'MortgageProperty': mortgage_property_phase,
            'BSMT': bsmt_phase,
            'TurnEnd': turn_end_phase,
        }
        board = Board()
        agent_1 = Agent()
        agent_2 = Agent()
        player_1 = Player(1, position=board.property_at(0), agent=agent_1)
        player_2 = Player(2, position=board.property_at(1), agent=agent_2)
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.build(2)
        mediterranean_avenue.own(player_2)
        agent_1.bsmt_decision = MagicMock(return_value=(None, None))
        agent_2_mock = Mock()
        agent_2_mock.side_effect = iter([(Action.MORTGAGE_PROPERTY,
                                          mediterranean_avenue), (None, None)])
        agent_2.bsmt_decision = agent_2_mock
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = bsmt_phase
        context = Context(phases, game_state, game_phase)
        mortgage_property_phase.apply = MagicMock(return_value=(context, None))

        context.apply()

        mortgage_property_phase.apply.assert_called_once()
    def test_chance_3_unowned(self):
        special_property_phase = SpecialProperty()
        buy_property_phase = BuyProperty()
        phases = {
            'SpecialProperty': special_property_phase,
            'BuyProperty': buy_property_phase
        }
        board = Board()
        board.next_chance = MagicMock(return_value=3)
        electric_company = board.property_at(12)
        board.nearest_utility = MagicMock(return_value=electric_company)
        player_1 = Player(1, amount=100, position=board.property_at(0))
        player_2 = Player(2, amount=300, position=board.property_at(36))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = special_property_phase
        context = Context(phases, game_state, game_phase)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is buy_property_phase)
        self.assertTrue(player_2.position is electric_company)
        self.assertEqual(player_2.amount, 300)
        self.assertEqual(player_1.amount, 100)
示例#3
0
    def test_sell_house_action(self):
        bsmt_phase = BSMT()
        sell_house_phase = SellHouse()
        turn_end_phase = TurnEnd()
        phases = {
            'SellHouse': sell_house_phase,
            'BSMT': bsmt_phase,
            'TurnEnd': turn_end_phase,
        }
        board = Board()
        agent_1 = Agent()
        agent_1.bsmt_decision = MagicMock(return_value=(None, None))
        agent_2 = Agent()
        sell_action = [1, 1]
        agent_2_mock = Mock()
        agent_2_mock.side_effect = iter([(Action.SELL_HOUSE, sell_action),
                                         (None, None)])
        agent_2.bsmt_decision = agent_2_mock
        player_1 = Player(1, position=board.property_at(0), agent=agent_1)
        player_2 = Player(2, position=board.property_at(1), agent=agent_2)
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.build(2)
        mediterranean_avenue.own(player_2)
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = bsmt_phase
        context = Context(phases, game_state, game_phase)
        sell_house_phase.apply = MagicMock(return_value=(context, None))

        context.apply()

        sell_house_phase.apply.assert_called_once()
示例#4
0
    def test_player_buys_property(self):
        buy_property_phase = BuyProperty()
        bsmt_phase = BSMT()
        phases = {
            'BuyProperty': buy_property_phase,
            'BSMT': bsmt_phase,
        }
        board = Board()
        agent = Agent()
        agent.buy_property = MagicMock(return_value=True)
        current_position = board.property_at(1)
        current_position.cost = 100
        player_1 = Player(1, amount=20, position=current_position, agent=agent)
        player_2 = Player(2)
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_phase = buy_property_phase
        context = Context(phases, game_state, game_phase)
        bsmt_phase.apply = self.fake_bsmt_cycle(100)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is bsmt_phase)
        self.assertTrue(
            new_context.state.current_player.position.owned_by is player_1)
        self.assertEqual(new_context.state.current_player.amount, 20)
        self.assertEqual(new_context.state.current_player._debt['bank'], 0)
    def test_chance_4_5_owned(self):
        dice = utils.Dice()
        dice.roll = MagicMock(return_value=(1, 2))
        special_property_phase = SpecialProperty(dice)
        bsmt_phase = BSMT()
        phases = {
            'SpecialProperty': special_property_phase,
            'BSMT': bsmt_phase
        }
        board = Board()
        board.next_chance = MagicMock(return_value=4)
        reading_railroad = board.property_at(5)
        board.nearest_railroad = MagicMock(return_value=reading_railroad)
        player_1 = Player(1, amount=100, position=board.property_at(0))
        player_2 = Player(2, amount=300, position=board.property_at(36))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = special_property_phase
        context = Context(phases, game_state, game_phase)
        reading_railroad.own(player_1)
        reading_railroad.rent = MagicMock(return_value=15)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is bsmt_phase)
        self.assertTrue(player_2.position is reading_railroad)
        self.assertEqual(player_2.amount, 300 - 10 * 15)
        self.assertEqual(player_1.amount, 100 + 10 * 15)
    def test_chance_2(self):
        bsmt_phase = BSMT()
        special_property_phase = SpecialProperty()
        phases = {
            'BSMT': bsmt_phase,
            'SpecialProperty': special_property_phase,
        }
        board = Board()
        board.next_chance = MagicMock(return_value=2)
        board.passes_go = MagicMock(return_value=True)
        player_1 = Player(1, amount=100, position=board.property_at(1))
        player_2 = Player(2, amount=300, position=board.property_at(36))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = special_property_phase
        context = Context(phases, game_state, game_phase)
        st_charles_place = board.property_at(11)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is bsmt_phase)
        self.assertTrue(player_2.position is st_charles_place)
        self.assertEqual(player_2.amount, 500)
        self.assertEqual(player_1.amount, 100)
示例#7
0
    def test_player_declines_buying_property(self):
        buy_property_phase = BuyProperty()
        bsmt_phase = BSMT()
        auction_phase = Auction()
        phases = {
            'BuyProperty': buy_property_phase,
            'BSMT': bsmt_phase,
            'Auction': auction_phase,
        }
        board = Board()
        agent = Agent()
        agent.buy_property = MagicMock(return_value=False)
        player_1 = Player(1,
                          amount=900,
                          position=board.property_at(1),
                          agent=agent)
        player_2 = Player(2, position=board.property_at(0))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_phase = buy_property_phase
        context = Context(phases, game_state, game_phase)
        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is auction_phase)
        self.assertEqual(new_context.state.current_player.amount, 900)
示例#8
0
def setup(agent_1, agent_2):
    dice = utils.Dice()
    roll_mock = Mock()
    roll_mock.side_effect = cycle([(1, 2), (2, 2)])
    dice.roll = roll_mock
    dice_roll_phase = DiceRoll(dice)
    square_effect_phase = SquareEffect()
    bsmt_phase = BSMT()
    buy_property_phase = BuyProperty()
    pay_rent_phase = PayRent()
    auction_phase = Auction()
    phases = {
        'DiceRoll': dice_roll_phase,
        'SquareEffect': square_effect_phase,
        'BSMT': bsmt_phase,
        'BuyProperty': buy_property_phase,
        'PayRent': pay_rent_phase,
        'Auction': auction_phase,
    }
    board = Board()
    player_1 = Player(1, position=board.property_at(0), agent=agent_1)
    player_2 = Player(2, position=board.property_at(0), agent=agent_2)
    players = [player_1, player_2]
    game_state = GameState(players, board)
    start_phase = dice_roll_phase
    context = Context(phases, game_state, start_phase)
    return context
示例#9
0
    def test_apply_player_bankrupt(self):
        bsmt_phase = BSMT()
        pay_rent_phase = PayRent()
        turn_end_phase = TurnEnd()
        phases = {
            'BSMT': bsmt_phase,
            'PayRent': pay_rent_phase,
            'TurnEnd': turn_end_phase,
        }
        board = Board()
        player_1 = Player(1, position=board.property_at(0))
        player_2 = Player(2, amount=10, position=board.property_at(1))
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.own(player_1)
        rent = 100
        mediterranean_avenue.rent = MagicMock(return_value=rent)
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = pay_rent_phase
        context = Context(phases, game_state, game_phase)
        bsmt_phase.apply = self.fake_bsmt_cycle(rent - 20)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is turn_end_phase)
        self.assertEqual(new_context.state.current_player.amount, 90)
示例#10
0
    def test_unmortgage_property(self):
        mortgage_property_phase = MortgageProperty()
        bsmt_phase = BSMT()
        phases = {
            'MortgagePropertyHouse': mortgage_property_phase,
            'BSMT': bsmt_phase,
        }
        board = Board()
        player_1 = Player(1, amount=500, position=board.property_at(1))
        player_2 = Player(2, amount=500, position=board.property_at(0))
        players = [player_1, player_2]
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.mortgage_value = 200
        mediterranean_avenue.own(player_1)
        mediterranean_avenue.mortgage()
        bank = Bank()
        game_state = GameState(players, board, bank=bank)
        game_phase = mortgage_property_phase
        context = Context(phases, game_state, game_phase)
        action = mediterranean_avenue

        context.apply(action)

        self.assertTrue(mediterranean_avenue.type is PropertyType.OWNED)
        self.assertEqual(player_1.amount, 280)
        self.assertEqual(player_2.amount, 500)
示例#11
0
    def test_properties(self):
        board = Board()
        player = Player(4)
        result = adapter.game_state.properties_tuple(board._squares, player)
        expected = tuple([0] * 42)

        self.assertEqual(result, expected)
示例#12
0
    def test_trade_property_action(self):
        bsmt_phase = BSMT()
        trade_property_phase = TradeProperty()
        turn_end_phase = TurnEnd()
        phases = {
            'TradeProperty': trade_property_phase,
            'BSMT': bsmt_phase,
            'TurnEnd': turn_end_phase,
        }
        board = Board()
        agent_1 = Agent()
        agent_2 = Agent()
        player_1 = Player(1, position=board.property_at(0), agent=agent_1)
        player_2 = Player(2, position=board.property_at(1), agent=agent_2)
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.own(player_1)
        baltic_avenue = board.property_at(3)
        baltic_avenue.own(player_1)
        reading_railroad = board.property_at(5)
        reading_railroad.own(player_2)
        oriental_avenue = board.property_at(6)
        oriental_avenue.own(player_2)
        agent_1_mock = Mock()
        agent_1_mock.side_effect = iter([
            (Action.TRADE_PROPERTY,
             (200, [mediterranean_avenue,
                    baltic_avenue], 400, [reading_railroad, oriental_avenue])),
            (None, None)
        ])
        agent_1.bsmt_decision = agent_1_mock
        agent_2.bsmt_decision = MagicMock(return_value=(None, None))
        agent_2.respond_trade = MagicMock(return_value=(True, None))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_state.next_player()
        game_phase = bsmt_phase
        context = Context(phases, game_state, game_phase)
        trade_property_phase.apply = MagicMock(return_value=(context, None))
        expected_trades = [{
            'buyer': player_2,
            'seller': player_1,
            'price': 200,
            'properties': [mediterranean_avenue, baltic_avenue]
        }, {
            'buyer': player_1,
            'seller': player_2,
            'price': 400,
            'properties': [reading_railroad, oriental_avenue]
        }]

        context.apply()

        trade_property_phase.apply.assert_called_once_with(
            context, expected_trades)
示例#13
0
    def test_special_property_community_chest(self):
        square_effect_phase = SquareEffect()
        special_property_phase = SpecialProperty()
        phases = {
            'SpecialProperty': special_property_phase,
        }
        board = Board()
        player_1 = Player(1, position=board.property_at(2))
        player_2 = Player(2, position=board.property_at(1))
        players = [player_1, player_2]
        game_state = GameState(players)
        game_phase = square_effect_phase
        context = Context(phases, game_state, game_phase)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is special_property_phase)
示例#14
0
    def test_apply(self):
        dice = utils.Dice()
        dice.roll = MagicMock(return_value=(1, 2))
        dice_roll_phase = DiceRoll(dice)
        square_effect_phase = SquareEffect()
        phases = {
            'DiceRoll': dice_roll_phase,
            'SquareEffect': square_effect_phase,
        }
        board = Board()
        player_1 = Player(1, position=board.property_at(0))
        player_2 = Player(2, position=board.property_at(0))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_phase = dice_roll_phase
        context = Context(phases, game_state, game_phase)
        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is square_effect_phase)
        self.assertTrue(
            new_context.state.current_player.position is board.property_at(3))
示例#15
0
    def test_unowned_property(self):
        dice_roll_phase = DiceRoll()
        square_effect_phase = SquareEffect()
        buy_property_phase = BuyProperty()
        pay_rent_phase = PayRent()
        phases = {
            'DiceRoll': dice_roll_phase,
            'SquareEffect': square_effect_phase,
            'BuyProperty': buy_property_phase,
            'PayRent': pay_rent_phase,
        }
        board = Board()
        player_1 = Player(1, position=board.property_at(1))
        player_2 = Player(2, position=board.property_at(1))
        players = [player_1, player_2]
        game_state = GameState(players)
        game_phase = square_effect_phase
        context = Context(phases, game_state, game_phase)
        new_context, next_action = context.apply()

        self.assertTrue(isinstance(new_context.phase, BuyProperty))
示例#16
0
    def test_apply(self):
        buy_house_phase = BuyHouse()
        phases = {}
        board = Board()
        player_1 = Player(1, amount=500, position=board.property_at(1))
        player_2 = Player(2, amount=500, position=board.property_at(0))
        players = [player_1, player_2]
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.own(player_1)
        mediterranean_avenue.build_costs = {'House': 100}
        bank = Bank()
        game_state = GameState(players, board, bank=bank)
        game_phase = buy_house_phase
        context = Context(phases, game_state, game_phase)
        action = (mediterranean_avenue, 'House', 2)

        context.apply(action)

        self.assertEqual(mediterranean_avenue.houses, 2)
        self.assertEqual(player_1.amount, 300)
        self.assertEqual(player_2.amount, 500)
示例#17
0
    def test_selling_property(self):
        trade_property_phase = TradeProperty()
        board = Board()
        player_1 = Player(1, amount=500, position=board.property_at(1))
        player_2 = Player(2, amount=500, position=board.property_at(0))
        players = [player_1, player_2]
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.own(player_1)
        baltic_avenue = board.property_at(3)
        baltic_avenue.own(player_1)
        reading_railroad = board.property_at(5)
        reading_railroad.own(player_2)
        oriental_avenue = board.property_at(6)
        oriental_avenue.own(player_2)

        trades = [{
            'buyer': player_2,
            'seller': player_1,
            'price': 200,
            'properties': [mediterranean_avenue, baltic_avenue]
        }, {
            'buyer': player_1,
            'seller': player_2,
            'price': 400,
            'properties': [reading_railroad, oriental_avenue]
        }]

        game_state = GameState(players, board)
        game_phase = trade_property_phase
        context = Context({}, game_state, game_phase)
        action = trades

        context.apply(action)

        self.assertEqual(player_1.amount, 500 + 200 - 400)
        self.assertEqual(player_2.amount, 500 - 200 + 400)
        self.assertTrue(mediterranean_avenue.owned_by is player_2)
        self.assertTrue(baltic_avenue.owned_by is player_2)
        self.assertTrue(reading_railroad.owned_by is player_1)
        self.assertTrue(oriental_avenue.owned_by is player_1)
示例#18
0
    def test_change_player_on_regular_roll(self):
        turn_end_phase = TurnEnd()
        dice_roll_phase = DiceRoll()
        phases = {
            'DiceRoll': dice_roll_phase,
            'TurnEnd': turn_end_phase,
        }
        board = Board()
        regular_roll = ((1, 2), (2, 3))
        player_1 = Player(1,
                          position=board.property_at(1),
                          previous_rolls=regular_roll)
        player_2 = Player(2, position=board.property_at(0))
        players = [player_1, player_2]
        game_state = GameState(players, board)
        game_phase = turn_end_phase
        context = Context(phases, game_state, game_phase)

        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is dice_roll_phase)
        self.assertTrue(new_context.state.current_player is player_2)
示例#19
0
def context_factory(agent_1, agent_2, dice_rolls):
    dice = utils.Dice()
    roll_mock = Mock()
    roll_mock.side_effect = iter(dice_rolls)
    dice.roll = roll_mock
    dice_roll_phase = DiceRoll(dice)
    square_effect_phase = SquareEffect()
    bsmt_phase = BSMT()
    buy_property_phase = BuyProperty()
    pay_rent_phase = PayRent()
    auction_phase = Auction()
    turn_end_phase = TurnEnd()
    mortgage_property_phase = MortgageProperty()
    special_property_phase = SpecialProperty()
    phases = {
        'DiceRoll': dice_roll_phase,
        'SquareEffect': square_effect_phase,
        'BSMT': bsmt_phase,
        'BuyProperty': buy_property_phase,
        'MortgageProperty': mortgage_property_phase,
        'PayRent': pay_rent_phase,
        'Auction': auction_phase,
        'SpecialProperty': special_property_phase,
        'TurnEnd': turn_end_phase,
    }
    board = Board()
    player_1 = Player(1,
                      amount=1500,
                      position=board.property_at(0),
                      agent=agent_1)
    player_2 = Player(2,
                      amount=1500,
                      position=board.property_at(0),
                      agent=agent_2)
    players = [player_1, player_2]
    game_state = GameState(players, board)
    start_phase = dice_roll_phase
    context = Context(phases, game_state, start_phase)
    return context
示例#20
0
    def test_self_owned_property(self):
        bsmt_phase = BSMT()
        square_effect_phase = SquareEffect()
        buy_property_phase = BuyProperty()
        pay_rent_phase = PayRent()
        phases = {
            'BSMT': bsmt_phase,
            'SquareEffect': square_effect_phase,
            'BuyProperty': buy_property_phase,
            'PayRent': pay_rent_phase,
        }
        board = Board()
        player_1 = Player(1, position=board.property_at(1))
        player_2 = Player(2, position=board.property_at(1))
        mediterranean_avenue = board.property_at(1)
        mediterranean_avenue.own(player_1)
        players = [player_1, player_2]
        game_state = GameState(players)
        game_phase = square_effect_phase
        context = Context(phases, game_state, game_phase)
        new_context, next_action = context.apply()

        self.assertTrue(new_context.phase is bsmt_phase)