Merge pull request #112 from MahjongRepository/chiitoitsu_shanten

Fix shanten calculation rules in regard with chiitoitsu consideration

Author: Nihisil

project/game/ai/first_version/hand_builder.py

@@ -114,13 +114,35 @@ def discard_tile(self, tiles, closed_hand, melds, print_log=True):
 
         return self.process_discard_option(selected_tile, closed_hand, print_log=print_log)
 
+    def calculate_shanten(self, tiles_34, open_sets_34=None):
+        shanten_with_chiitoitsu = self.ai.shanten_calculator.calculate_shanten(tiles_34,
+                                                                               open_sets_34,
+                                                                               chiitoitsu=True)
+        shanten_without_chiitoitsu = self.ai.shanten_calculator.calculate_shanten(tiles_34,
+                                                                                  open_sets_34,
+                                                                                  chiitoitsu=False)
+
+        if shanten_with_chiitoitsu == 0 and shanten_without_chiitoitsu >= 1:
+            shanten = shanten_with_chiitoitsu
+            use_chiitoitsu = True
+        elif shanten_with_chiitoitsu == 1 and shanten_without_chiitoitsu >= 3:
+            shanten = shanten_with_chiitoitsu
+            use_chiitoitsu = True
+        else:
+            shanten = shanten_without_chiitoitsu
+            use_chiitoitsu = False
+
+        return shanten, use_chiitoitsu
+
     def calculate_waits(self, tiles_34, open_sets_34=None):
         """
         :param tiles_34: array of tiles in 34 formant, 13 of them (this is important)
         :param open_sets_34: array of array with tiles in 34 format
         :return: array of waits in 34 format and number of shanten
         """
-        shanten = self.ai.shanten_calculator.calculate_shanten(tiles_34, open_sets_34, chiitoitsu=self.ai.use_chitoitsu)
+
+        shanten, use_chiitoitsu = self.calculate_shanten(tiles_34, open_sets_34)
+
         waiting = []
         for j in range(0, 34):
             if tiles_34[j] == 4:
@@ -131,7 +153,7 @@ def calculate_waits(self, tiles_34, open_sets_34=None):
             key = '{},{},{}'.format(
                 ''.join([str(x) for x in tiles_34]),
                 ';'.join([str(x) for x in open_sets_34]),
-                self.ai.use_chitoitsu and 1 or 0
+                use_chiitoitsu and 1 or 0
             )
 
             if key in self.ai.hand_cache:
@@ -140,7 +162,7 @@ def calculate_waits(self, tiles_34, open_sets_34=None):
                 new_shanten = self.ai.shanten_calculator.calculate_shanten(
                     tiles_34,
                     open_sets_34,
-                    chiitoitsu=self.ai.use_chitoitsu
+                    chiitoitsu=use_chiitoitsu
                 )
                 self.ai.hand_cache[key] = new_shanten
 
@@ -188,10 +210,9 @@ def find_discard_options(self, tiles, closed_hand, melds=None):
         if is_agari:
             shanten = Shanten.AGARI_STATE
         else:
-            shanten = self.ai.shanten_calculator.calculate_shanten(
+            shanten, _ = self.calculate_shanten(
                 tiles_34,
-                open_sets_34,
-                chiitoitsu=self.ai.use_chitoitsu
+                open_sets_34
             )
 
         return results, shanten
@@ -484,7 +505,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, print_log=True):
         if first_option.shanten in [1, 2, 3]:
             ukeire_field = 'ukeire_second'
             for x in possible_options:
-                self.calculate_second_level_ukeire(x)
+                self.calculate_second_level_ukeire(x, tiles, melds)
 
             possible_options = sorted(possible_options, key=lambda x: -getattr(x, ukeire_field))
 
@@ -600,7 +621,7 @@ def process_discard_option(self, discard_option, closed_hand, force_discard=Fals
         else:
             return discard_option.find_tile_in_hand(closed_hand)
 
-    def calculate_second_level_ukeire(self, discard_option):
+    def calculate_second_level_ukeire(self, discard_option, tiles, melds):
         not_suitable_tiles = self.ai.current_strategy and self.ai.current_strategy.not_suitable_tiles or []
         call_riichi = not self.player.is_open_hand
 
@@ -609,6 +630,8 @@ def calculate_second_level_ukeire(self, discard_option):
         player_tiles_original = self.player.tiles.copy()
 
         tile_in_hand = discard_option.find_tile_in_hand(self.player.closed_hand)
+
+        self.player.tiles = tiles.copy()
         self.player.tiles.remove(tile_in_hand)
 
         sum_tiles = 0
@@ -629,7 +652,7 @@ def calculate_second_level_ukeire(self, discard_option):
             results, shanten = self.find_discard_options(
                 self.player.tiles,
                 self.player.closed_hand,
-                self.player.melds
+                melds
             )
             results = [x for x in results if x.shanten == discard_option.shanten - 1]
 

project/game/ai/first_version/main.py

@@ -44,7 +44,6 @@ class ImplementationAI(InterfaceAI):
 
     current_strategy = None
     last_discard_option = None
-    use_chitoitsu = False
 
     hand_cache = {}
 
@@ -70,7 +69,6 @@ def erase_state(self):
 
         self.current_strategy = None
         self.last_discard_option = None
-        self.use_chitoitsu = False
 
         self.hand_cache = {}
 
@@ -81,9 +79,7 @@ def init_hand(self):
             'Hand: {}'.format(self.player.format_hand_for_print()),
         ])
 
-        self.shanten = self.shanten_calculator.calculate_shanten(
-            TilesConverter.to_34_array(self.player.tiles)
-        )
+        self.shanten, _ = self.hand_builder.calculate_shanten(TilesConverter.to_34_array(self.player.tiles))
 
     def draw_tile(self, tile_136):
         self.determine_strategy(self.player.tiles)
@@ -104,18 +100,15 @@ def discard_tile(self, discard_tile, print_log=True):
         )
 
     def try_to_call_meld(self, tile_136, is_kamicha_discard):
-        tiles_136 = self.player.tiles[:] + [tile_136]
+        tiles_136_previous = self.player.tiles[:]
+        tiles_136 = tiles_136_previous + [tile_136]
         self.determine_strategy(tiles_136)
 
         if not self.current_strategy:
             return None, None
 
-        tiles_34 = TilesConverter.to_34_array(tiles_136)
-        previous_shanten = self.shanten_calculator.calculate_shanten(
-            tiles_34,
-            self.player.meld_34_tiles,
-            chiitoitsu=self.use_chitoitsu
-        )
+        tiles_34_previous = TilesConverter.to_34_array(tiles_136_previous)
+        previous_shanten, _ = self.hand_builder.calculate_shanten(tiles_34_previous, self.player.meld_34_tiles)
 
         if previous_shanten == Shanten.AGARI_STATE and not self.current_strategy.can_meld_into_agari():
             return None, None
@@ -133,35 +126,32 @@ def try_to_call_meld(self, tile_136, is_kamicha_discard):
         return meld, discard_option
 
     def determine_strategy(self, tiles_136):
-        self.use_chitoitsu = False
-
         # for already opened hand we don't need to give up on selected strategy
         if self.player.is_open_hand and self.current_strategy:
             return False
 
         old_strategy = self.current_strategy
         self.current_strategy = None
 
-        # order is important
-        strategies = [
-            ChinitsuStrategy(BaseStrategy.CHINITSU, self.player),
-            HonitsuStrategy(BaseStrategy.HONITSU, self.player),
-            YakuhaiStrategy(BaseStrategy.YAKUHAI, self.player),
-        ]
+        # order is important, we add strategies with the highest priority first
+        strategies = []
 
         if self.player.table.has_open_tanyao:
             strategies.append(TanyaoStrategy(BaseStrategy.TANYAO, self.player))
 
+        strategies.append(YakuhaiStrategy(BaseStrategy.YAKUHAI, self.player))
+        strategies.append(HonitsuStrategy(BaseStrategy.HONITSU, self.player))
+        strategies.append(ChinitsuStrategy(BaseStrategy.CHINITSU, self.player))
+
         strategies.append(ChiitoitsuStrategy(BaseStrategy.CHIITOITSU, self.player))
         strategies.append(FormalTempaiStrategy(BaseStrategy.FORMAL_TEMPAI, self.player))
 
         for strategy in strategies:
             if strategy.should_activate_strategy(tiles_136):
                 self.current_strategy = strategy
+                break
 
         if self.current_strategy:
-            self.use_chitoitsu = self.current_strategy.type == BaseStrategy.CHIITOITSU
-
             if not old_strategy or self.current_strategy.type != old_strategy.type:
                 DecisionsLogger.debug(
                     log.STRATEGY_ACTIVATE,

project/game/ai/first_version/tests/strategies/tests_chiitoitsu.py

@@ -50,3 +50,47 @@ def test_dont_call_meld(self):
         tile = self._string_to_136_tile(man='9')
         meld, _ = player.try_to_call_meld(tile, True)
         self.assertEqual(meld, None)
+
+    def test_keep_chiitoitsu_tempai(self):
+        table = Table()
+        player = table.player
+
+        tiles = self._string_to_136_array(sou='113355', man='22669', pin='99')
+        player.init_hand(tiles)
+
+        player.draw_tile(self._string_to_136_tile(man='6'))
+
+        discard = player.discard_tile()
+        self.assertEqual(self._to_string([discard]), '6m')
+
+    def test_5_pairs_yakuhai_not_chiitoitsu(self):
+        table = Table()
+        player = table.player
+
+        table.add_dora_indicator(self._string_to_136_tile(sou='9'))
+        table.add_dora_indicator(self._string_to_136_tile(sou='1'))
+
+        tiles = self._string_to_136_array(sou='112233', pin='16678', honors='66')
+        player.init_hand(tiles)
+
+        tile = self._string_to_136_tile(honors='6')
+        meld, _ = player.try_to_call_meld(tile, True)
+
+        self.assertNotEqual(player.ai.current_strategy.type, BaseStrategy.CHIITOITSU)
+
+        self.assertEqual(player.ai.current_strategy.type, BaseStrategy.YAKUHAI)
+
+        self.assertNotEqual(meld, None)
+
+    def chiitoitsu_tanyao_tempai(self):
+        table = Table()
+        player = table.player
+
+        tiles = self._string_to_136_array(sou='223344', pin='788', man='4577')
+        player.init_hand(tiles)
+
+        player.draw_tile(self._string_to_136_tile(man='4'))
+
+        discard = player.discard_tile()
+        discard_correct = self._to_string([discard]) == '7p' or self._to_string([discard]) == '5m'
+        self.assertEqual(discard_correct, True)

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

@@ -762,30 +762,72 @@ def test_calculate_second_level_ukeire(self):
 
         tile = self._string_to_136_tile(man='4')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 108)
 
         tile = self._string_to_136_tile(man='3')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 108)
 
         tile = self._string_to_136_tile(pin='2')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 96)
 
         tile = self._string_to_136_tile(pin='3')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 96)
 
         tile = self._string_to_136_tile(pin='5')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 96)
 
         tile = self._string_to_136_tile(pin='6')
         discard_option = [x for x in discard_options if x.tile_to_discard == tile // 4][0]
-        player.ai.hand_builder.calculate_second_level_ukeire(discard_option)
+        player.ai.hand_builder.calculate_second_level_ukeire(discard_option, player.tiles, player.melds)
         self.assertEqual(discard_option.ukeire_second, 96)
+
+    def test_choose_1_shanten_with_cost_possibility_draw(self):
+        table = Table()
+        player = table.player
+        table.add_dora_indicator(self._string_to_136_tile(sou='4'))
+
+        tiles = self._string_to_136_array(man='557', pin='468', sou='55577', honors='66')
+        player.init_hand(tiles)
+
+        meld = self._make_meld(Meld.PON, sou='555')
+        player.add_called_meld(meld)
+
+        tile = self._string_to_136_tile(sou='7')
+        player.draw_tile(tile)
+        discarded_tile = player.discard_tile()
+        self.assertNotEqual(player.ai.current_strategy, None)
+        self.assertEqual(player.ai.current_strategy.type, BaseStrategy.YAKUHAI)
+        self.assertEqual(self._to_string([discarded_tile]), '7m')
+
+    def test_choose_1_shanten_with_cost_possibility_meld(self):
+        table = Table()
+        player = table.player
+        table.add_dora_indicator(self._string_to_136_tile(sou='4'))
+
+        tiles = self._string_to_136_array(man='557', pin='468', sou='55577', honors='66')
+        player.init_hand(tiles)
+
+        meld = self._make_meld(Meld.PON, sou='555')
+        player.add_called_meld(meld)
+
+        tile = self._string_to_136_tile(sou='7')
+        meld, discard_option = player.try_to_call_meld(tile, False)
+        self.assertNotEqual(meld, None)
+        self.assertEqual(meld.type, Meld.PON)
+        self.assertEqual(self._to_string(meld.tiles), '777s')
+
+        self.assertNotEqual(player.ai.current_strategy, None)
+        self.assertEqual(player.ai.current_strategy.type, BaseStrategy.YAKUHAI)
+
+        discarded_tile = discard_option.find_tile_in_hand(player.closed_hand)
+
+        self.assertEqual(self._to_string([discarded_tile]), '7m')