Trying to fix bad open hands behaviour

Author: Nihisil

project/game/ai/hand_builder.py

@@ -41,7 +41,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
 
         tiles_we_can_discard = [x for x in discard_options if x.danger.get_max_danger() <= x.danger.danger_border]
         if not tiles_we_can_discard:
-            return self._chose_first_option_or_safe_tiles([], discard_options)
+            return self._chose_first_option_or_safe_tiles([], discard_options, for_open_hand)
 
         # our strategy can affect discard options
         if self.ai.current_strategy:
@@ -52,7 +52,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
         had_to_be_discarded_tiles = [x for x in tiles_we_can_discard if x.had_to_be_discarded]
         if had_to_be_discarded_tiles:
             tiles_we_can_discard = sorted(had_to_be_discarded_tiles, key=lambda x: (x.shanten, -x.ukeire, x.valuation))
-            return self._chose_first_option_or_safe_tiles(tiles_we_can_discard, discard_options)
+            return self._chose_first_option_or_safe_tiles(tiles_we_can_discard, discard_options, for_open_hand)
 
         # remove needed tiles from discard options
         tiles_we_can_discard = [x for x in tiles_we_can_discard if not x.had_to_be_saved]
@@ -101,7 +101,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
             min_dora = min([x.count_of_dora for x in possible_options])
             min_dora_list = [x for x in possible_options if x.count_of_dora == min_dora]
             return self._chose_first_option_or_safe_tiles(
-                sorted(min_dora_list, key=lambda x: -getattr(x, ukeire_field)), discard_options
+                sorted(min_dora_list, key=lambda x: -getattr(x, ukeire_field)), discard_options, for_open_hand
             )
 
         # only one option - so we choose it
@@ -113,6 +113,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
             return self._chose_first_option_or_safe_tiles(
                 sorted(tiles_without_dora, key=lambda x: (-x.second_level_cost, -x.ukeire_second, x.valuation)),
                 discard_options,
+                for_open_hand,
             )
 
         if first_option.shanten == 2 or first_option.shanten == 3:
@@ -139,13 +140,13 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
         if isolated_tiles:
             # let's sort tiles by value and let's choose less valuable tile to discard
             return self._chose_first_option_or_safe_tiles(
-                sorted(isolated_tiles, key=lambda x: x.valuation), discard_options
+                sorted(isolated_tiles, key=lambda x: x.valuation), discard_options, for_open_hand
             )
 
         # there are no isolated tiles or we don't care about them
         # let's discard tile with greater ukeire/ukeire2
         filtered_options = sorted(filtered_options, key=lambda x: -getattr(x, ukeire_field))
-        first_option = self._chose_first_option_or_safe_tiles(filtered_options, discard_options)
+        first_option = self._chose_first_option_or_safe_tiles(filtered_options, discard_options, for_open_hand)
 
         other_tiles_with_same_ukeire = [
             x for x in filtered_options if getattr(x, ukeire_field) == getattr(first_option, ukeire_field)
@@ -155,7 +156,7 @@ def choose_tile_to_discard(self, tiles, closed_hand, melds, for_open_hand=False)
         # or in tempai we can have several tiles with same ukeire
         if other_tiles_with_same_ukeire:
             return self._chose_first_option_or_safe_tiles(
-                sorted(other_tiles_with_same_ukeire, key=lambda x: x.valuation), discard_options
+                sorted(other_tiles_with_same_ukeire, key=lambda x: x.valuation), discard_options, for_open_hand
             )
 
         # we have only one candidate to discard with greater ukeire
@@ -397,9 +398,15 @@ def calculate_second_level_ukeire(self, discard_option, tiles, melds):
         # restore original state of player hand
         self.player.tiles = player_tiles_original
 
-    def _chose_first_option_or_safe_tiles(self, chosen_candidates, all_discard_options):
+    def _chose_first_option_or_safe_tiles(self, chosen_candidates, all_discard_options, for_open_hand):
+        # it looks like everything is fine
         if len(chosen_candidates):
             return chosen_candidates[0]
+        # we don't want to open hand in that case
+        elif for_open_hand:
+            return None
+
+        # we can't discard effective tile from the hand, let's fold
         DecisionsLogger.debug(log.DISCARD_SAFE_TILE, "There are only dangerous tiles. Discard safest tile.")
         return sorted(all_discard_options, key=lambda x: x.danger.get_max_danger())[0]
 

project/game/ai/strategies/main.py

@@ -1,6 +1,17 @@
 import utils.decisions_constants as log
 from mahjong.tile import TilesConverter
-from mahjong.utils import is_aka_dora, is_chi, is_honor, is_man, is_pin, is_pon, is_sou, is_terminal, plus_dora
+from mahjong.utils import (
+    is_aka_dora,
+    is_chi,
+    is_honor,
+    is_man,
+    is_pin,
+    is_pon,
+    is_sou,
+    is_terminal,
+    plus_dora,
+    simplify,
+)
 from utils.decisions_logger import DecisionsLogger, MeldPrint
 
 
@@ -178,7 +189,11 @@ def try_to_call_meld(self, tile, is_kamicha_discard, new_tiles):
         if not possible_melds:
             return None, None
 
-        chosen_meld = self._find_best_meld_to_open(possible_melds, new_tiles, closed_hand, tile)
+        chosen_meld = self._find_best_meld_to_open(tile, possible_melds, new_tiles, closed_hand, tile)
+        # we didn't find a good discard candidate after open meld
+        if not chosen_meld:
+            return None, None
+
         selected_tile = chosen_meld["discard_tile"]
         meld = chosen_meld["meld"]
 
@@ -232,7 +247,7 @@ def calculate_dora_count(self, tiles_136):
         self.dora_count_central += self.aka_dora_count
         self.dora_count_total = self.dora_count_central + self.dora_count_not_central
 
-    def _find_best_meld_to_open(self, possible_melds, new_tiles, closed_hand, discarded_tile):
+    def _find_best_meld_to_open(self, call_tile_136, possible_melds, new_tiles, closed_hand, discarded_tile):
         discarded_tile_34 = discarded_tile // 4
 
         final_results = []
@@ -264,6 +279,36 @@ def _find_best_meld_to_open(self, possible_melds, new_tiles, closed_hand, discar
                 new_tiles, closed_hand_copy, melds, for_open_hand=True
             )
 
+            # we can't find a good discard candidate, so let's skip this
+            if not selected_tile:
+                continue
+
+            # kuikae
+            # we can't discard the same tile
+            # or tile from the same suji
+            if not is_honor(selected_tile.tile_to_discard):
+                call_tile_34 = call_tile_136 // 4
+
+                if is_sou(selected_tile.tile_to_discard) and is_sou(call_tile_34):
+                    same_suit = True
+                elif is_man(selected_tile.tile_to_discard) and is_man(call_tile_34):
+                    same_suit = True
+                elif is_pin(selected_tile.tile_to_discard) and is_pin(call_tile_34):
+                    same_suit = True
+                else:
+                    same_suit = False
+
+                if same_suit:
+                    simplified_call = simplify(call_tile_136 // 4)
+                    simplified_discard = simplify(selected_tile.tile_to_discard)
+                    if simplified_discard in [simplified_call - 3, simplified_call, simplified_call + 3]:
+                        tile_str = TilesConverter.to_one_line_string([selected_tile.tile_to_discard * 4])
+                        DecisionsLogger.debug(
+                            log.MELD_DEBUG,
+                            f"Kuikae discard {tile_str} candidate. Abort this tile melding.",
+                        )
+                        continue
+
             final_results.append(
                 {
                     "discard_tile": selected_tile,
@@ -272,6 +317,10 @@ def _find_best_meld_to_open(self, possible_melds, new_tiles, closed_hand, discar
                 }
             )
 
+        if not final_results:
+            DecisionsLogger.debug(log.MELD_DEBUG, "There are no good discards after melding.")
+            return None
+
         final_results = sorted(
             final_results,
             key=lambda x: (x["discard_tile"].shanten, -x["discard_tile"].ukeire, x["discard_tile"].valuation),