Merge pull request #113 from MahjongRepository/chankan

Improve logic to call shouminkan sets

Author: Nihisil

project/game/ai/base/main.py

@@ -58,7 +58,7 @@ def should_call_riichi(self):
 
     def should_call_kan(self, tile, is_open_kan, from_riichi=False):
         """
-        When bot can call kan or chankan this method will be called
+        When bot can call kan or shouminkan this method will be called
         :param tile: 136 tile format
         :param is_open_kan: boolean
         :param from_riichi: boolean

project/game/ai/first_version/main.py

@@ -236,71 +236,83 @@ def should_call_kan(self, tile, open_kan, from_riichi=False):
         tiles_34 = TilesConverter.to_34_array(self.player.tiles)
 
         closed_hand_34 = TilesConverter.to_34_array(self.player.closed_hand)
-        pon_melds = [x for x in self.player.meld_34_tiles if is_pon(x)]
-
-        # let's check can we upgrade opened pon to the kan
-        if pon_melds:
-            for meld in pon_melds:
-                # tile is equal to our already opened pon,
-                # so let's call chankan!
-                if tile_34 in meld:
-                    return Meld.CHANKAN
 
         melds_34 = copy.copy(self.player.meld_34_tiles)
         tiles = copy.copy(self.player.tiles)
         closed_hand_tiles = copy.copy(self.player.closed_hand)
 
-        # we can try to call closed meld
-        if closed_hand_34[tile_34] == 3:
+        new_shanten = 0
+        previous_shanten = 0
+        new_waits_count = 0
+        previous_waits_count = 0
+
+        # let's check can we upgrade opened pon to the kan
+        pon_melds = [x for x in self.player.meld_34_tiles if is_pon(x)]
+        has_shouminkan_candidate = False
+        for meld in pon_melds:
+            # tile is equal to our already opened pon
+            if tile_34 in meld:
+                has_shouminkan_candidate = True
+
+                tiles.append(tile)
+                closed_hand_tiles.append(tile)
+
+                previous_shanten, previous_waits_count = self._calculate_shanten_for_kan(
+                    tiles,
+                    closed_hand_tiles,
+                    self.player.melds
+                )
+
+                tiles_34 = TilesConverter.to_34_array(tiles)
+                tiles_34[tile_34] -= 1
+
+                new_waiting, new_shanten = self.hand_builder.calculate_waits(
+                    tiles_34,
+                    self.player.meld_34_tiles
+                )
+                new_waits_count = self.hand_builder.count_tiles(new_waiting, tiles_34)
+
+        if not has_shouminkan_candidate:
+            # we don't have enough tiles in the hand
+            if closed_hand_34[tile_34] != 3:
+                return None
+
             if open_kan or from_riichi:
                 # this 4 tiles can only be used in kan, no other options
                 previous_waiting, previous_shanten = self.hand_builder.calculate_waits(tiles_34, melds_34)
-                previous_waits_cnt = self.hand_builder.count_tiles(previous_waiting, closed_hand_34)
-
-                # shanten calculator doesn't like working with kans, so we pretend it's a pon
-                melds_34 += [[tile_34, tile_34, tile_34]]
-                closed_hand_34[tile_34] = 0
-
-                new_waiting, new_shanten = self.hand_builder.calculate_waits(tiles_34, melds_34)
-                new_waits_cnt = self.hand_builder.count_tiles(new_waiting, closed_hand_34)
+                previous_waits_count = self.hand_builder.count_tiles(previous_waiting, closed_hand_34)
             else:
-                # if we can use or tile in the hand for the forms other than KAN
                 tiles.append(tile)
-
                 closed_hand_tiles.append(tile)
-                closed_hand_34[tile_34] += 1
 
-                previous_results, previous_shanten = self.hand_builder.find_discard_options(
+                previous_shanten, previous_waits_count = self._calculate_shanten_for_kan(
                     tiles,
                     closed_hand_tiles,
                     self.player.melds
                 )
 
-                previous_results = [x for x in previous_results if x.shanten == previous_shanten]
-
-                # it is possible that we don't have results here
-                # when we are in agari state (but without yaku)
-                if not previous_results:
-                    return None
+            # shanten calculator doesn't like working with kans, so we pretend it's a pon
+            melds_34 += [[tile_34, tile_34, tile_34]]
+            new_waiting, new_shanten = self.hand_builder.calculate_waits(tiles_34, melds_34)
 
-                previous_waits_cnt = sorted(previous_results, key=lambda x: -x.ukeire)[0].ukeire
+            closed_hand_34[tile_34] = 4
+            new_waits_count = self.hand_builder.count_tiles(new_waiting, closed_hand_34)
 
-                # shanten calculator doesn't like working with kans, so we pretend it's a pon
-                closed_hand_34[tile_34] = 0
-                melds_34 += [[tile_34, tile_34, tile_34]]
+        # it is possible that we don't have results here
+        # when we are in agari state (but without yaku)
+        if previous_shanten is None:
+            return None
 
-                new_waiting, new_shanten = self.hand_builder.calculate_waits(tiles_34, melds_34)
-                new_waits_cnt = self.hand_builder.count_tiles(new_waiting, closed_hand_34)
+        # it is not possible to reduce number of shanten by calling a kan
+        assert new_shanten >= previous_shanten
 
-            # it is not possible to reduce number of shanten by calling a kan
-            assert new_shanten >= previous_shanten
+        # if shanten number is the same, we should only call kan if ukeire didn't become worse
+        if new_shanten == previous_shanten:
+            # we cannot improve ukeire by calling kan (not considering the tile we drew from the dead wall)
+            assert new_waits_count <= previous_waits_count
 
-            # if shanten number is the same, we should only call kan if ukeire didn't become worse
-            if new_shanten == previous_shanten:
-                # we cannot improve ukeire by calling kan (not considering the tile we drew from the dead wall)
-                assert new_waits_cnt <= previous_waits_cnt
-                if new_waits_cnt == previous_waits_cnt:
-                    return Meld.KAN
+            if new_waits_count == previous_waits_count:
+                return has_shouminkan_candidate and Meld.CHANKAN or Meld.KAN
 
         return None
 
@@ -324,3 +336,21 @@ def enemy_players(self):
         Return list of players except our bot
         """
         return self.player.table.players[1:]
+
+    def _calculate_shanten_for_kan(self, tiles, closed_hand_tiles, melds):
+        previous_results, previous_shanten = self.hand_builder.find_discard_options(
+            tiles,
+            closed_hand_tiles,
+            melds
+        )
+
+        previous_results = [x for x in previous_results if x.shanten == previous_shanten]
+
+        # it is possible that we don't have results here
+        # when we are in agari state (but without yaku)
+        if not previous_results:
+            return None, None
+
+        previous_waits_cnt = sorted(previous_results, key=lambda x: -x.ukeire)[0].ukeire
+
+        return previous_shanten, previous_waits_cnt

project/game/ai/first_version/tests/tests_ai.py

@@ -395,7 +395,7 @@ def test_using_tiles_of_different_suit_for_chi(self):
         meld, _ = player.try_to_call_meld(tile, True)
         self.assertIsNotNone(meld)
 
-    def test_upgrade_opened_pon_to_kan(self):
+    def test_call_upgrade_pon_and_bad_ukeire_after_call(self):
         table = Table()
         table.count_of_remaining_tiles = 10
 
@@ -409,6 +409,57 @@ def test_upgrade_opened_pon_to_kan(self):
 
         self.assertEqual(len(table.player.melds), 1)
         self.assertEqual(len(table.player.tiles), 13)
+        self.assertEqual(table.player.should_call_kan(tile, False), None)
+
+    def test_call_upgrade_pon_and_bad_ukeire_after_call_second_case(self):
+        table = Table()
+        table.add_dora_indicator(self._string_to_136_tile(honors='5'))
+        table.count_of_remaining_tiles = 10
+        player = table.player
+
+        tiles = self._string_to_136_array(man='3455567', sou='222', honors='666')
+        player.init_hand(tiles)
+        player.add_called_meld(self._make_meld(Meld.PON, man='555'))
+        player.add_called_meld(self._make_meld(Meld.PON, honors='666'))
+
+        tile = self._string_to_136_tile(man='5')
+
+        self.assertEqual(player.should_call_kan(tile, False), None)
+
+        player.draw_tile(tile)
+        discarded_tile = player.discard_tile()
+
+        self.assertEqual(self._to_string([discarded_tile]), '2s')
+
+    def test_call_upgrade_pon_and_bad_ukeire_after_call_third_case(self):
+        table = Table()
+        table.count_of_remaining_tiles = 10
+        player = table.player
+
+        tiles = self._string_to_136_array(man='67', pin='6', sou='1344478999')
+        table.player.init_hand(tiles)
+        table.player.add_called_meld(self._make_meld(Meld.PON, sou='444'))
+
+        tile = self._string_to_136_tile(sou='4')
+
+        # we don't want to call shouminkan here
+        self.assertEqual(table.player.should_call_kan(tile, False), None)
+
+        player.draw_tile(tile)
+        discarded_tile = player.discard_tile()
+
+        self.assertEqual(self._to_string([discarded_tile]), '6p')
+
+    def test_call_shouminkan(self):
+        table = Table()
+        table.count_of_remaining_tiles = 10
+
+        tiles = self._string_to_136_array(man='3455567', sou='222', honors='666')
+        table.player.init_hand(tiles)
+        table.player.add_called_meld(self._make_meld(Meld.PON, honors='666'))
+
+        tile = self._string_to_136_tile(honors='6')
+
         self.assertEqual(table.player.should_call_kan(tile, False), Meld.CHANKAN)
 
     def test_call_closed_kan(self):
@@ -451,6 +502,7 @@ def test_opened_kan(self):
         tile = self._string_to_136_tile(sou='1')
         self.assertEqual(table.player.should_call_kan(tile, True), None)
 
+    def test_opened_kan_second_case(self):
         table = Table()
         table.count_of_remaining_tiles = 10
 
@@ -466,6 +518,25 @@ def test_opened_kan(self):
         tile = self._string_to_136_tile(sou='1')
         self.assertEqual(table.player.should_call_kan(tile, True), Meld.KAN)
 
+    def test_opened_kan_third_case(self):
+        # we are in tempai already and there was a crash on 5s meld suggestion
+
+        table = Table()
+        table.count_of_remaining_tiles = 10
+        table.add_dora_indicator(self._string_to_136_tile(honors='5'))
+
+        tiles = self._string_to_136_array(man='456', sou='55567678', honors='66')
+        table.player.init_hand(tiles)
+        table.player.add_called_meld(self._make_meld(Meld.CHI, sou='678'))
+
+        # to rebuild all caches
+        table.player.draw_tile(self._string_to_136_tile(pin='9'))
+        table.player.discard_tile()
+
+        tile = self._string_to_136_tile(sou='5')
+        self.assertEqual(table.player.should_call_kan(tile, True), None)
+        self.assertEqual(table.player.try_to_call_meld(tile, True), (None, None))
+
     def test_dont_call_kan_in_defence_mode(self):
         table = Table()
 

project/game/player.py

@@ -65,13 +65,13 @@ def erase_state(self):
         self.round_step = 0
 
     def add_called_meld(self, meld: Meld):
-        # we already added chankan as a pon set
+        # we already added shouminkan as a pon set
         if meld.type == Meld.CHANKAN:
             tile_34 = meld.tiles[0] // 4
 
             pon_set = [x for x in self.melds if x.type == Meld.PON and (x.tiles[0] // 4) == tile_34]
 
-            # when we are doing reconnect and we have called chankan set
+            # when we are doing reconnect and we have called shouminkan set
             # we will not have called pon set in the hand
             if pon_set:
                 self.melds.remove(pon_set[0])

project/game/table.py

@@ -108,7 +108,7 @@ def add_called_meld(self, player_seat, meld):
         else:
             # can't have a pon or chi from the hand
             assert meld.type == Meld.KAN or meld.type == meld.CHANKAN
-            # player draws additional tile from the wall in case of closed kan or chankan
+            # player draws additional tile from the wall in case of closed kan or shouminkan
             self.count_of_remaining_tiles -= 1
 
         self.get_player(player_seat).add_called_meld(meld)
@@ -119,7 +119,7 @@ def add_called_meld(self, player_seat, meld):
         if meld.called_tile is not None:
             tiles.remove(meld.called_tile)
 
-        # for chankan we already added 3 tiles
+        # for shouminkan we already added 3 tiles
         if meld.type == meld.CHANKAN:
             tiles = [meld.tiles[0]]
 

project/tenhou/client.py

@@ -281,11 +281,13 @@ def start_game(self):
 
                         if kan_type == Meld.CHANKAN:
                             meld_type = 5
+                            logger.info('We upgraded pon to kan!')
                         else:
                             meld_type = 4
+                            logger.info('We called a closed kan set!')
 
                         self._send_message('<N type="{}" hai="{}" />'.format(meld_type, drawn_tile))
-                        logger.info('We called a closed kan\chankan set!')
+
                         continue
 
                     if not main_player.in_riichi:
@@ -345,7 +347,7 @@ def start_game(self):
                 ]
                 # we win by other player's discard
                 if any(i in message for i in win_suggestions):
-                    # enemy called chankan and we can win there
+                    # enemy called shouminkan and we can win there
                     if self.decoder.is_opened_set_message(message):
                         meld = self.decoder.parse_meld(message)
                         tile = meld.called_tile