improve atodzuke handling rules #72

1. Fixed ukeire2 calculation with atodzuke.
2. For tanyao now only strictly avoid atodzuke in tempai.
3. Don't consider wait to be atodzuke if there are no live non-suitable tiles.

Author: bogachev-pa

project/game/ai/first_version/hand_builder.py

@@ -198,11 +198,7 @@ def find_discard_options(self, tiles, closed_hand, melds=None):
 
     def count_tiles(self, waiting, tiles_34):
         n = 0
-        not_suitable_tiles = self.ai.current_strategy and self.ai.current_strategy.not_suitable_tiles or []
         for tile_34 in waiting:
-            if self.player.is_open_hand and tile_34 in not_suitable_tiles:
-                continue
-
             n += 4 - self.player.total_tiles(tile_34, tiles_34)
         return n
 
@@ -639,23 +635,40 @@ def calculate_second_level_ukeire(self, discard_option):
 
             # let's take best ukeire here
             if results:
-                # TODO: find best one considering atodzuke
-                best_one = sorted(results, key=lambda x: -x.ukeire)[0]
-                sum_tiles += best_one.ukeire * live_tiles
-
-                has_atodzuke = False
+                result_has_atodzuke = False
                 if self.player.is_open_hand:
-                    for wait_34 in best_one.waiting:
-                        if wait_34 in not_suitable_tiles:
-                            has_atodzuke = True
+                    best_one = results[0]
+                    best_ukeire = 0
+                    for result in results:
+                        has_atodzuke = False
+                        ukeire = 0
+                        for wait_34 in result.waiting:
+                            if wait_34 in not_suitable_tiles:
+                                has_atodzuke = True
+                            else:
+                                ukeire += result.wait_to_ukeire[wait_34]
+
+                        # let's consider atodzuke waits to be worse than non-atodzuke ones
+                        if has_atodzuke:
+                            ukeire /= 2
+
+                        if (ukeire > best_ukeire) or (ukeire >= best_ukeire and not has_atodzuke):
+                            best_ukeire = ukeire
+                            best_one = result
+                            result_has_atodzuke = has_atodzuke
+                else:
+                    best_one = sorted(results, key=lambda x: -x.ukeire)[0]
+                    best_ukeire = best_one.ukeire
+
+                sum_tiles += best_ukeire * live_tiles
 
                 # if we are going to have a tempai (on our second level) - let's also count its cost
                 if shanten == 0:
                     next_tile_in_hand = best_one.find_tile_in_hand(self.player.closed_hand)
                     self.player.tiles.remove(next_tile_in_hand)
                     cost_x_ukeire, _ = self._estimate_cost_x_ukeire(best_one, call_riichi=call_riichi)
                     # we reduce tile valuation for atodzuke
-                    if has_atodzuke:
+                    if result_has_atodzuke:
                         cost_x_ukeire /= 2
                     sum_cost += cost_x_ukeire
                     self.player.tiles.append(next_tile_in_hand)

project/game/ai/first_version/strategies/tanyao.py

@@ -140,9 +140,13 @@ def determine_what_to_discard(self, discard_options, hand, open_melds):
                 continue
 
             # there is no sense to wait 1-4 if we have open hand
-            all_waiting_are_fine = all([self.is_tile_suitable(x * 4) for x in item.waiting])
-            if all_waiting_are_fine:
-                results.append(item)
+            # but let's only avoid atodzuke tiles in tempai, the rest will be dealt with in
+            # generic logic
+            if item.shanten == 0:
+                all_waiting_are_fine = all(
+                    [(self.is_tile_suitable(x * 4) or item.wait_to_ukeire[x] == 0) for x in item.waiting])
+                if all_waiting_are_fine:
+                    results.append(item)
 
         if not_suitable_tiles:
             return not_suitable_tiles

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

@@ -31,7 +31,7 @@ def test_should_activate_strategy(self):
         tiles = self._string_to_136_array(sou='234', man='223344', pin='5669')
         player.init_hand(tiles)
         player.draw_tile(self._string_to_136_tile(pin='5'))
-        player.ai.shanten = 0
+        player.discard_tile()
         self.assertEqual(strategy.should_activate_strategy(player.tiles), False)
 
         tiles = self._string_to_136_array(sou='234', man='22334455669')

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

@@ -220,6 +220,46 @@ def test_choose_correct_waiting(self):
         discard = player.discard_tile()
         self.assertEqual(self._to_string([discard]), '7s')
 
+    def test_choose_balanced_ukeire_in_1_shanten(self):
+        table = self._make_table()
+        player = table.player
+
+        meld = self._make_meld(Meld.CHI, man='678')
+        player.add_called_meld(meld)
+
+        tiles = self._string_to_136_array(man='22678', sou='234568', pin='45')
+        player.init_hand(tiles)
+        player.draw_tile(self._string_to_136_tile(man='2'))
+
+        self._assert_tanyao(player)
+
+        # there are lost of options to avoid atodzuke and even if it is atodzuke,
+        # it is still a good one, so let's choose more efficient 8s discard instead of 2s
+        discard = player.discard_tile()
+        self.assertEqual(self._to_string([discard]), '8s')
+
+    def test_choose_pseudo_atodzuke(self):
+        table = self._make_table()
+        table.has_aka_dora = False
+        player = table.player
+
+        # one tile is dora indicator and 3 are out
+        # so this 1-4 wait is not atodzuke
+        for _ in range(0, 3):
+            table.add_discarded_tile(1, self._string_to_136_tile(pin='1'), False)
+
+        meld = self._make_meld(Meld.CHI, man='678')
+        player.add_called_meld(meld)
+
+        tiles = self._string_to_136_array(man='222678', sou='23488', pin='35')
+        player.init_hand(tiles)
+        player.draw_tile(self._string_to_136_tile(pin='2'))
+
+        self._assert_tanyao(player)
+
+        discard = player.discard_tile()
+        self.assertEqual(self._to_string([discard]), '5p')
+
     def test_choose_correct_waiting_and_first_opened_meld(self):
         tiles = self._string_to_136_array(man='2337788', sou='222', pin='234')
         self.player.init_hand(tiles)