Esempio n. 1
0
    def test_pon(self):
        self.current_kyoku.deal()

        # change tile in hand to test pon
        pon_tile = Tile(Suit.JIHAI.value, Jihai.CHUN.value)
        pon_tile.owner = self.players[0].seating_position
        to_discard_tile = Tile(Suit.JIHAI.value, Jihai.HAKU.value)

        self.current_kyoku.players[0].hand = defaultdict(int)
        self.current_kyoku.players[0].hand[pon_tile.index] = 1
        self.current_kyoku.players[0].hand[Tile(2, 1).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand = defaultdict(int)
        self.current_kyoku.players[1].hand[pon_tile.index] = 2
        self.current_kyoku.players[1].hand[to_discard_tile.index] = 1
        self.current_kyoku.players[1].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 4).index] += 1
        self.current_kyoku.players[2].hand = defaultdict(int)
        self.current_kyoku.players[2].hand[Tile(2, 5).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 6).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 7).index] += 1
        self.current_kyoku.players[3].hand = defaultdict(int)
        self.current_kyoku.players[3].hand[Tile(2, 7).index] += 1
        self.current_kyoku.players[3].hand[Tile(2, 8).index] += 1
        self.current_kyoku.players[3].hand[Tile(2, 9).index] += 1

        pyinput.inputNum = MagicMock(side_effect=[1, 0, 0])
        pyinput.inputChoice = MagicMock(return_value=2)

        turn = Turn(
            self.current_kyoku.players,
            self.current_kyoku.tile_stack,
            Jihai.TON,
            self.logger,
        )

        mock_draw_flow = MagicMock(
            return_value=(0, pon_tile, self.players[0].seating_position))
        state, discard_tile, discard_pos = mock_draw_flow(
            self.current_kyoku.oya_player)

        state, discard_tile, discard_pos, act = turn.discard_flow(
            discard_tile, discard_pos)

        pon_in_kabe = Huro(Naki.PON, pon_tile, [pon_tile, pon_tile, pon_tile])

        # Raw input: 1, 2, 0, 0

        self.assertEqual(state, 0)
        self.assertEqual(discard_tile, to_discard_tile)
        self.assertEqual(discard_pos, self.players[1].seating_position)
        self.assertEqual(pon_in_kabe.naki_type,
                         self.players[1].kabe[0].naki_type)
        self.assertEqual(pon_in_kabe.naki_tile,
                         self.players[1].kabe[0].naki_tile)
        # test remove_huro_tiles()
        self.assertEqual(self.players[1].hand[pon_tile.index], 0)
        self.assertEqual(pon_in_kabe.tiles, self.players[1].kabe[0].tiles)
Esempio n. 2
0
    def setUp(self):
        self.player_1 = Player('player 1', 0)
        self.player_2 = Player('player 2', 1)
        self.player_3 = Player('player 3', 2)
        self.player_4 = Player('player 4', 3)
        self.players = [
            self.player_1, self.player_2, self.player_3, self.player_4
        ]
        self.tile_stack = Stack()
        self.logger = KyokuLogger()
        for player in self.players:
            for i in range(13):
                player.hand[self.tile_stack.draw().index] += 1

        self.turn = Turn(self.players, self.tile_stack, Jihai.TON, self.logger)
Esempio n. 3
0
    def test_no_haiteihai_pon(self):
        self.current_kyoku.deal()

        # change tile in hand to test pon
        pon_tile = Tile(Suit.JIHAI.value, Jihai.CHUN.value)
        pon_tile.owner = self.players[0].seating_position

        self.current_kyoku.players[0].hand = defaultdict(int)
        self.current_kyoku.players[0].hand[pon_tile.index] = 1
        self.current_kyoku.players[0].hand[Tile(2, 1).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 3).index] += 2
        self.current_kyoku.players[1].hand = defaultdict(int)
        self.current_kyoku.players[1].hand[pon_tile.index] = 2
        self.current_kyoku.players[1].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 4).index] += 2
        self.current_kyoku.players[2].hand = defaultdict(int)
        self.current_kyoku.players[2].hand[Tile(2, 5).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 6).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 7).index] += 2
        self.current_kyoku.players[3].hand = defaultdict(int)
        self.current_kyoku.players[3].hand[Tile(2, 7).index] += 1
        self.current_kyoku.players[3].hand[Tile(2, 8).index] += 1
        self.current_kyoku.players[3].hand[Tile(2, 9).index] += 2

        # pyinput.inputNum = MagicMock(side_effect=[1, 0, 0])
        # pyinput.inputChoice = MagicMock(return_value=2)

        turn = Turn(self.current_kyoku.players, self.current_kyoku.tile_stack,
                    Jihai.TON, self.logger)

        mock_draw_flow = MagicMock(
            return_value=(0, pon_tile, self.players[0].seating_position))
        state, discard_tile, discard_pos = mock_draw_flow(
            self.current_kyoku.oya_player)

        turn.stack.playing_wall = []

        state, discard_tile, discard_pos, act = turn.discard_flow(
            discard_tile, discard_pos)

        self.assertEqual(state, -1)
        self.assertEqual(discard_tile, pon_tile)
        self.assertEqual(discard_pos, self.players[0].seating_position)
        self.assertEqual(act, Action.NOACT)
Esempio n. 4
0
    def test_ankan(self):
        self.current_kyoku.deal()

        kan_tile = Tile(Suit.JIHAI.value, Jihai.CHUN.value)
        to_discard_tile = Tile(Suit.JIHAI.value, Jihai.HAKU.value)

        self.current_kyoku.players[0].hand = defaultdict(int)
        self.current_kyoku.players[0].hand[Tile(2, 1).index] += 2
        self.current_kyoku.players[0].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand = defaultdict(int)
        self.current_kyoku.players[1].hand[kan_tile.index] = 3
        self.current_kyoku.players[1].hand[to_discard_tile.index] = 1
        self.current_kyoku.players[1].hand[Tile(2, 2).index] += 2
        self.current_kyoku.players[1].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 4).index] += 1
        self.current_kyoku.players[2].hand = defaultdict(int)
        self.current_kyoku.players[2].hand[Tile(2, 5).index] += 2
        self.current_kyoku.players[2].hand[Tile(2, 6).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 7).index] += 1
        self.current_kyoku.players[3].hand = defaultdict(int)
        self.current_kyoku.players[3].hand[Tile(2, 7).index] += 2
        self.current_kyoku.players[3].hand[Tile(2, 8).index] += 1
        self.current_kyoku.players[3].hand[Tile(2, 9).index] += 1

        pyinput.inputNum = MagicMock(side_effect=[1, 0, 0])
        pyinput.inputChoice = MagicMock(return_value=5)

        turn = Turn(
            self.current_kyoku.players,
            self.current_kyoku.tile_stack,
            Jihai.TON,
            self.logger,
        )

        mock_draw_flow = MagicMock(
            return_value=(0, Tile(Suit.JIHAI.value, Jihai.TON.value),
                          self.players[0].seating_position))
        state, discard_tile, discard_pos = mock_draw_flow(
            self.current_kyoku.oya_player)

        ankan_tile = kan_tile
        with patch('mahjong.components.Stack.draw') as mock_func:

            def f(from_rinshan):
                if from_rinshan:
                    return Tile(Suit.SOUZU.value, 9)
                else:
                    return ankan_tile

            mock_func.side_effect = f
            state, discard_tile, discard_pos, act = turn.discard_flow(
                discard_tile, discard_pos)

        kan_in_kabe = Huro(Naki.ANKAN, ankan_tile,
                           [kan_tile, kan_tile, kan_tile, kan_tile])

        self.assertEqual(state, 0)
        self.assertEqual(discard_tile, to_discard_tile)
        self.assertEqual(discard_pos, self.players[1].seating_position)
        self.assertEqual(kan_in_kabe.naki_type,
                         self.players[1].kabe[0].naki_type)
        self.assertEqual(kan_in_kabe.naki_tile,
                         self.players[1].kabe[0].naki_tile)
        self.assertEqual(self.players[1].hand[ankan_tile.index], 0)
        self.assertEqual(kan_in_kabe.tiles, self.players[1].kabe[0].tiles)
Esempio n. 5
0
    def test_chii(self):
        self.current_kyoku.deal()

        # change tile in hand to test chii
        chii_tile = Tile(Suit.MANZU.value, 5)
        chii_tile.owner = self.players[0].seating_position
        to_discard_tile = Tile(Suit.PINZU.value, 9)

        self.current_kyoku.players[0].hand = defaultdict(int)
        self.current_kyoku.players[0].hand[chii_tile.index] = 1
        self.current_kyoku.players[0].hand[Tile(2, 1).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 2).index] += 1
        self.current_kyoku.players[0].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand = defaultdict(int)
        self.current_kyoku.players[1].hand[chii_tile.index - 1] = 1
        self.current_kyoku.players[1].hand[chii_tile.index + 1] = 1
        self.current_kyoku.players[1].hand[to_discard_tile.index] = 1
        self.current_kyoku.players[1].hand[Tile(2, 2).index] += 2
        self.current_kyoku.players[1].hand[Tile(2, 3).index] += 1
        self.current_kyoku.players[1].hand[Tile(2, 4).index] += 1
        self.current_kyoku.players[2].hand = defaultdict(int)
        self.current_kyoku.players[2].hand[Tile(2, 5).index] += 2
        self.current_kyoku.players[2].hand[Tile(2, 6).index] += 1
        self.current_kyoku.players[2].hand[Tile(2, 7).index] += 1
        self.current_kyoku.players[3].hand = defaultdict(int)
        self.current_kyoku.players[3].hand[Tile(3, 7).index] += 2
        self.current_kyoku.players[3].hand[Tile(3, 8).index] += 1
        self.current_kyoku.players[3].hand[Tile(3, 9).index] += 1

        pyinput.inputNum = MagicMock(side_effect=[1, 0, 4])
        pyinput.inputChoice = MagicMock(return_value=1)

        turn = Turn(
            self.current_kyoku.players,
            self.current_kyoku.tile_stack,
            Jihai.TON,
            self.logger,
        )

        mock_draw_flow = MagicMock(
            return_value=(0, chii_tile, self.players[0].seating_position))
        state, discard_tile, discard_pos = mock_draw_flow(
            self.current_kyoku.oya_player)

        state, discard_tile, discard_pos, act = turn.discard_flow(
            discard_tile, discard_pos)

        chii_in_kabe = Huro(
            Naki.CHII, chii_tile,
            [chii_tile.prev_tile(), chii_tile,
             chii_tile.next_tile()])

        self.assertEqual(state, 0)
        self.assertEqual(discard_tile, to_discard_tile)
        self.assertEqual(discard_pos, self.players[1].seating_position)
        self.assertEqual(chii_in_kabe.naki_type,
                         self.players[1].kabe[0].naki_type)
        self.assertEqual(chii_in_kabe.naki_tile,
                         self.players[1].kabe[0].naki_tile)
        # test remove_huro_tiles()
        self.assertEqual(self.players[1].hand[chii_tile.index - 1], 0)
        self.assertEqual(self.players[1].hand[chii_tile.index + 1], 0)
        self.assertEqual(chii_in_kabe.tiles, self.players[1].kabe[0].tiles)