Improve logic to call chankan sets

Author: Nihisil

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_chankan_candidate = False
+        for meld in pon_melds:
+            # tile is equal to our already opened pon
+            if tile_34 in meld:
+                has_chankan_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_chankan_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_chankan_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_chankan_and_bad_ukeire_after_call(self):
         table = Table()
         table.count_of_remaining_tiles = 10
 
@@ -409,6 +409,31 @@ 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_chankan_and_bad_ukeire_after_call_second(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, man='555'))
+        table.player.add_called_meld(self._make_meld(Meld.PON, honors='666'))
+
+        tile = self._string_to_136_tile(man='5')
+
+        self.assertEqual(table.player.should_call_kan(tile, False), None)
+
+    def test_upgrade_opened_pon_to_kan(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 +476,8 @@ def test_opened_kan(self):
         tile = self._string_to_136_tile(sou='1')
         self.assertEqual(table.player.should_call_kan(tile, True), None)
 
+        # test case 2
+
         table = Table()
         table.count_of_remaining_tiles = 10
 
@@ -466,6 +493,24 @@ def test_opened_kan(self):
         tile = self._string_to_136_tile(sou='1')
         self.assertEqual(table.player.should_call_kan(tile, True), Meld.KAN)
 
+        # test case 3
+        # 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)
+
     def test_dont_call_kan_in_defence_mode(self):
         table = Table()