Refactor AI a little more

Author: Nihisil

README.md

@@ -105,7 +105,7 @@ After this you can debug bot decisions.
 
 ### Reproduce from our log
 
-Sometimes we had to debug bot <-> server communication. For this purpose we built this reproducer.
+Sometimes we had to debug `bot <-> server` communication. For this purpose we built this reproducer.
 
 Just use it with already played game:
 

project/game/ai/base/main.py

@@ -14,10 +14,11 @@ def __init__(self, player):
         self.player = player
         self.table = player.table
 
-    def discard_tile(self):
+    def discard_tile(self, discard_tile):
         """
         Simple tile discard (after draw)
-        :return: int, 136 tile format
+        :param discard_tile: 136 tile format
+        :return: 136 tile format
         """
         raise NotImplemented()
 
@@ -40,12 +41,13 @@ def draw_tile(self, tile):
         :return:
         """
 
-    def process_discard_option(self, discard_option, closed_hand):
+    def should_call_win(self, tile, enemy_seat):
         """
-        :param discard_option: DiscardOption object
-        :param closed_hand: list of 136 tiles format
-        :return:
+        When we can call win by other player discard
+        this methid will be called
+        :return: boolean
         """
+        return True
 
     def should_call_riichi(self):
         """

project/game/ai/discard.py

@@ -77,8 +77,8 @@ def calculate_value(self, shanten=None):
             honored_value = 0
 
         if is_honor(self.tile_to_discard):
-            if self.tile_to_discard in self.player.ai.valued_honors:
-                count_of_winds = [x for x in self.player.ai.valued_honors if x == self.tile_to_discard]
+            if self.tile_to_discard in self.player.valued_honors:
+                count_of_winds = [x for x in self.player.valued_honors if x == self.tile_to_discard]
                 # for west-west, east-east we had to double tile value
                 value += honored_value * len(count_of_winds)
         else:

project/game/ai/first_version/main.py

@@ -69,7 +69,13 @@ def draw_tile(self, tile):
         """
         self.determine_strategy()
 
-    def discard_tile(self):
+    def discard_tile(self, discard_tile):
+        # we called meld and we had discard tile that we wanted to discard
+        if discard_tile is not None:
+            if not self.last_discard_option:
+                return discard_tile
+            return self.process_discard_option(self.last_discard_option, self.player.closed_hand)
+
         results, shanten = self.calculate_outs(self.player.tiles,
                                                self.player.closed_hand,
                                                self.player.open_hand_34_tiles)
@@ -168,7 +174,13 @@ def try_to_call_meld(self, tile, is_kamicha_discard):
         if not self.current_strategy:
             return None, None
 
-        return self.current_strategy.try_to_call_meld(tile, is_kamicha_discard)
+        meld, discard_option = self.current_strategy.try_to_call_meld(tile, is_kamicha_discard)
+        tile_to_discard = None
+        if discard_option:
+            self.last_discard_option = discard_option
+            tile_to_discard = discard_option.tile_to_discard
+
+        return meld, tile_to_discard
 
     def determine_strategy(self):
         # for already opened hand we don't need to give up on selected strategy
@@ -383,6 +395,9 @@ def should_call_kan(self, tile, open_kan):
 
         return None
 
+    def should_call_win(self, tile, enemy_seat):
+        return True
+
     def enemy_called_riichi(self, enemy_seat):
         """
         After enemy riichi we had to check will we fold or not
@@ -398,7 +413,3 @@ def enemy_players(self):
         Return list of players except our bot
         """
         return self.player.table.players[1:]
-
-    @property
-    def valued_honors(self):
-        return [CHUN, HAKU, HATSU, self.player.table.round_wind, self.player.player_wind]

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

@@ -35,7 +35,7 @@ def should_activate_strategy(self):
             if x in self.not_suitable_tiles and tile == 2:
                 count_of_terminal_pairs += 1
 
-                if x in self.player.ai.valued_honors:
+                if x in self.player.valued_honors:
                     count_of_valued_pairs += 1
 
         # if we already have pon of honor\terminal tiles

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

@@ -17,7 +17,7 @@ def should_activate_strategy(self):
             return False
 
         tiles_34 = TilesConverter.to_34_array(self.player.tiles)
-        valued_pairs = [x for x in self.player.ai.valued_honors if tiles_34[x] >= 2]
+        valued_pairs = [x for x in self.player.valued_honors if tiles_34[x] >= 2]
 
         for pair in valued_pairs:
             # we have valued pair in the hand and there is enough tiles
@@ -40,7 +40,7 @@ def determine_what_to_discard(self, closed_hand, outs_results, shanten, for_open
             tile_for_open_hand //= 4
 
         tiles_34 = TilesConverter.to_34_array(self.player.tiles)
-        valued_pairs = [x for x in self.player.ai.valued_honors if tiles_34[x] == 2]
+        valued_pairs = [x for x in self.player.valued_honors if tiles_34[x] == 2]
 
         # when we trying to open hand with tempai state, we need to chose a valued pair waiting
         if shanten == 0 and valued_pairs and for_open_hand and tile_for_open_hand not in valued_pairs:
@@ -74,7 +74,7 @@ def meld_had_to_be_called(self, tile):
 
         tile //= 4
         tiles_34 = TilesConverter.to_34_array(self.player.tiles)
-        valued_pairs = [x for x in self.player.ai.valued_honors if tiles_34[x] == 2]
+        valued_pairs = [x for x in self.player.valued_honors if tiles_34[x] == 2]
 
         for meld in self.player.melds:
             # for big shanten number we don't need to check already opened pon set,
@@ -95,4 +95,4 @@ def meld_had_to_be_called(self, tile):
         return False
 
     def _is_yakuhai_pon(self, meld):
-        return meld.type == Meld.PON and meld.tiles[0] // 4 in self.player.ai.valued_honors
+        return meld.type == Meld.PON and meld.tiles[0] // 4 in self.player.valued_honors

project/game/ai/random/main.py

@@ -10,7 +10,7 @@ class ImplementationAI(InterfaceAI):
     """
     version = 'random'
 
-    def discard_tile(self):
+    def discard_tile(self, discard_tile):
         tile_to_discard = random.randrange(len(self.player.tiles) - 1)
         tile_to_discard = self.player.tiles[tile_to_discard]
         return tile_to_discard

project/game/player.py

@@ -2,7 +2,7 @@
 import logging
 import copy
 
-from mahjong.constants import EAST, SOUTH, WEST, NORTH
+from mahjong.constants import EAST, SOUTH, WEST, NORTH, CHUN, HAKU, HATSU
 from mahjong.meld import Meld
 from mahjong.tile import TilesConverter, Tile
 
@@ -144,16 +144,13 @@ def draw_tile(self, tile):
 
         self.ai.draw_tile(tile)
 
-    def discard_tile(self, discard_option=None):
+    def discard_tile(self, discard_tile=None):
         """
-        :param discard_option:
+        :param discard_tile: 136 tile format
         :return:
         """
 
-        if discard_option:
-            tile_to_discard = self.ai.process_discard_option(discard_option, self.closed_hand)
-        else:
-            tile_to_discard = self.ai.discard_tile()
+        tile_to_discard = self.ai.discard_tile(discard_tile)
 
         is_tsumogiri = tile_to_discard == self.last_draw
         # it is important to use table method,
@@ -164,7 +161,11 @@ def discard_tile(self, discard_option=None):
         return tile_to_discard
 
     def can_call_riichi(self):
-        result = all([
+        result = self.formal_riichi_conditions()
+        return result and self.ai.should_call_riichi()
+
+    def formal_riichi_conditions(self):
+        return all([
             self.in_tempai,
 
             not self.in_riichi,
@@ -174,8 +175,6 @@ def can_call_riichi(self):
             self.table.count_of_remaining_tiles > 4
         ])
 
-        return result and self.ai.should_call_riichi()
-
     def should_call_kan(self, tile, open_kan):
         """
         Method will decide should we call a kan,
@@ -185,6 +184,9 @@ def should_call_kan(self, tile, open_kan):
         """
         return self.ai.should_call_kan(tile, open_kan)
 
+    def should_call_win(self, tile, enemy_seat):
+        return self.ai.should_call_win(tile, enemy_seat)
+
     def try_to_call_meld(self, tile, is_kamicha_discard):
         return self.ai.try_to_call_meld(tile, is_kamicha_discard)
 
@@ -237,6 +239,10 @@ def open_hand_34_tiles(self):
             results.append([meld[0] // 4, meld[1] // 4, meld[2] // 4])
         return results
 
+    @property
+    def valued_honors(self):
+        return [CHUN, HAKU, HATSU, self.table.round_wind, self.player_wind]
+
 
 class EnemyPlayer(PlayerInterface):
     # array of tiles in 34 tile format

project/game/tests/tests_player.py

@@ -7,6 +7,7 @@
 
 from game.player import Player
 from game.table import Table
+from utils.settings_handler import settings
 
 
 class PlayerTestCase(unittest.TestCase, TestMixin):
@@ -19,13 +20,12 @@ def test_can_call_riichi_and_tempai(self):
         player.in_riichi = False
         player.scores = 2000
         player.table.count_of_remaining_tiles = 40
-        player.ai.waiting = [1, 2]
 
-        self.assertEqual(player.can_call_riichi(), False)
+        self.assertEqual(player.formal_riichi_conditions(), False)
 
         player.in_tempai = True
 
-        self.assertEqual(player.can_call_riichi(), True)
+        self.assertEqual(player.formal_riichi_conditions(), True)
 
     def test_can_call_riichi_and_already_in_riichi(self):
         table = Table()
@@ -35,13 +35,12 @@ def test_can_call_riichi_and_already_in_riichi(self):
         player.in_riichi = True
         player.scores = 2000
         player.table.count_of_remaining_tiles = 40
-        player.ai.waiting = [1, 2]
 
-        self.assertEqual(player.can_call_riichi(), False)
+        self.assertEqual(player.formal_riichi_conditions(), False)
 
         player.in_riichi = False
 
-        self.assertEqual(player.can_call_riichi(), True)
+        self.assertEqual(player.formal_riichi_conditions(), True)
 
     def test_can_call_riichi_and_scores(self):
         table = Table()
@@ -51,13 +50,12 @@ def test_can_call_riichi_and_scores(self):
         player.in_riichi = False
         player.scores = 0
         player.table.count_of_remaining_tiles = 40
-        player.ai.waiting = [1, 2]
 
-        self.assertEqual(player.can_call_riichi(), False)
+        self.assertEqual(player.formal_riichi_conditions(), False)
 
         player.scores = 1000
 
-        self.assertEqual(player.can_call_riichi(), True)
+        self.assertEqual(player.formal_riichi_conditions(), True)
 
     def test_can_call_riichi_and_remaining_tiles(self):
         table = Table()
@@ -67,13 +65,12 @@ def test_can_call_riichi_and_remaining_tiles(self):
         player.in_riichi = False
         player.scores = 2000
         player.table.count_of_remaining_tiles = 3
-        player.ai.waiting = [1, 2]
 
-        self.assertEqual(player.can_call_riichi(), False)
+        self.assertEqual(player.formal_riichi_conditions(), False)
 
         player.table.count_of_remaining_tiles = 5
 
-        self.assertEqual(player.can_call_riichi(), True)
+        self.assertEqual(player.formal_riichi_conditions(), True)
 
     def test_can_call_riichi_and_open_hand(self):
         table = Table()
@@ -84,13 +81,12 @@ def test_can_call_riichi_and_open_hand(self):
         player.scores = 2000
         player.melds = [Meld()]
         player.table.count_of_remaining_tiles = 40
-        player.ai.waiting = [1, 2]
 
-        self.assertEqual(player.can_call_riichi(), False)
+        self.assertEqual(player.formal_riichi_conditions(), False)
 
         player.melds = []
 
-        self.assertEqual(player.can_call_riichi(), True)
+        self.assertEqual(player.formal_riichi_conditions(), True)
 
     def test_player_wind(self):
         table = Table()

project/main.py

@@ -40,7 +40,7 @@ def parse_args_and_set_up_settings():
 
     parser.add_option('-a', '--ai',
                       type='string',
-                      default=settings.AI,
+                      default=settings.AI_PACKAGE,
                       help='AI package')
 
     opts, _ = parser.parse_args()
@@ -51,6 +51,9 @@ def parse_args_and_set_up_settings():
     settings.WAITING_GAME_TIMEOUT_MINUTES = opts.timeout
     settings.AI_PACKAGE = opts.ai
 
+    # it is important to reload bot class
+    settings.load_ai_class()
+
     if opts.championship:
         settings.IS_TOURNAMENT = True
         settings.LOBBY = opts.championship