Refactor AI a little bit

Author: Nihisil

project/game/ai/base/main.py

@@ -1,12 +1,79 @@
 # -*- coding: utf-8 -*-
 
 
-class BaseAI(object):
+class InterfaceAI(object):
+    """
+    Public interface of the bot AI
+    """
+    version = 'none'
+
     player = None
     table = None
 
     def __init__(self, player):
         self.player = player
+        self.table = player.table
 
     def discard_tile(self):
-        pass
+        """
+        Simple tile discard (after draw)
+        :return: int, 136 tile format
+        """
+        raise NotImplemented()
+
+    def init_state(self):
+        """
+        Method will be called after bot hand initialization
+        :return:
+        """
+
+    def erase_state(self):
+        """
+        Method will be called in the start of new round.
+        You can null here AI attributes that depends on round data
+        :return:
+        """
+
+    def draw_tile(self, tile):
+        """
+        :param tile: 136 tile format
+        :return:
+        """
+
+    def process_discard_option(self, discard_option, closed_hand):
+        """
+        :param discard_option: DiscardOption object
+        :param closed_hand: list of 136 tiles format
+        :return:
+        """
+
+    def should_call_riichi(self):
+        """
+        When bot in tempai this method will be run
+        You can check additional params here to decide should be riichi called or not
+        :return: boolean
+        """
+        return False
+
+    def should_call_kan(self, tile, is_open_kan):
+        """
+        Method will decide should we call a kan or upgrade pon to kan (chankan)
+        :param tile: 136 tile format
+        :param is_open_kan: boolean
+        :return: kan type (Meld.KAN, Meld.CHANKAN) or None
+        """
+        return False
+
+    def try_to_call_meld(self, tile, is_kamicha_discard):
+        """
+        Determine should we call a meld or not.
+        :param tile: 136 format tile
+        :param is_kamicha_discard: boolean
+        :return: Meld and DiscardOption objects or None, None
+        """
+        return None, None
+
+    def enemy_called_riichi(self, enemy_seat):
+        """
+        Will be called after other player riichi
+        """

project/game/ai/first_version/main.py

@@ -10,9 +10,8 @@
 from mahjong.tile import TilesConverter
 from mahjong.utils import is_pair, is_pon
 
-from game.ai.base.main import BaseAI
+from game.ai.base.main import InterfaceAI
 from game.ai.discard import DiscardOption
-from game.ai.first_version.defence.enemy_analyzer import EnemyAnalyzer
 from game.ai.first_version.defence.main import DefenceHandler
 from game.ai.first_version.strategies.honitsu import HonitsuStrategy
 from game.ai.first_version.strategies.main import BaseStrategy
@@ -22,14 +21,15 @@
 logger = logging.getLogger('ai')
 
 
-class MainAI(BaseAI):
+class ImplementationAI(InterfaceAI):
     version = '0.3.0'
 
     agari = None
     shanten = None
     defence = None
     hand_divider = None
     finished_hand = None
+    last_discard_option = None
 
     previous_shanten = 7
     in_defence = False
@@ -38,7 +38,7 @@ class MainAI(BaseAI):
     current_strategy = None
 
     def __init__(self, player):
-        super(MainAI, self).__init__(player)
+        super(ImplementationAI, self).__init__(player)
 
         self.agari = Agari()
         self.shanten = Shanten()
@@ -49,10 +49,25 @@ def __init__(self, player):
         self.current_strategy = None
         self.waiting = []
         self.in_defence = False
+        self.last_discard_option = None
+
+    def init_state(self):
+        """
+        Let's decide what we will do with our hand (like open for tanyao and etc.)
+        """
+        self.determine_strategy()
 
     def erase_state(self):
         self.current_strategy = None
         self.in_defence = False
+        self.last_discard_option = None
+
+    def draw_tile(self, tile):
+        """
+        :param tile: 136 tile format
+        :return:
+        """
+        self.determine_strategy()
 
     def discard_tile(self):
         results, shanten = self.calculate_outs(self.player.tiles,
@@ -234,11 +249,11 @@ def sorting(x):
 
         return selected_tile
 
-    def process_discard_option(self, selected_tile, closed_hand):
-        self.waiting = selected_tile.waiting
-        self.player.ai.previous_shanten = selected_tile.shanten
+    def process_discard_option(self, discard_option, closed_hand):
+        self.waiting = discard_option.waiting
+        self.player.ai.previous_shanten = discard_option.shanten
         self.player.in_tempai = self.player.ai.previous_shanten == 0
-        return selected_tile.find_tile_in_hand(closed_hand)
+        return discard_option.find_tile_in_hand(closed_hand)
 
     def estimate_hand_value(self, win_tile, tiles=None, call_riichi=False):
         """
@@ -274,6 +289,9 @@ def should_call_riichi(self):
         if not self.waiting:
             return False
 
+        if self.in_defence:
+            return False
+
         # we have a good wait, let's riichi
         if len(self.waiting) > 1:
             return True
@@ -302,7 +320,7 @@ def should_call_riichi(self):
 
         return True
 
-    def can_call_kan(self, tile, open_kan):
+    def should_call_kan(self, tile, open_kan):
         """
         Method will decide should we call a kan,
         or upgrade pon to kan
@@ -365,6 +383,15 @@ def can_call_kan(self, tile, open_kan):
 
         return None
 
+    def enemy_called_riichi(self, enemy_seat):
+        """
+        After enemy riichi we had to check will we fold or not
+        it is affect open hand decisions
+        :return:
+        """
+        if self.defence.should_go_to_defence_mode():
+            self.in_defence = True
+
     @property
     def enemy_players(self):
         """

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

@@ -243,13 +243,13 @@ def test_upgrade_opened_pon_to_kan(self):
         tile = self._string_to_136_tile(man='4')
         player.draw_tile(tile)
 
-        self.assertEqual(player.can_call_kan(tile, False), None)
+        self.assertEqual(player.should_call_kan(tile, False), None)
 
         player.add_called_meld(self._make_meld(Meld.PON, man='444'))
 
         self.assertEqual(len(player.melds), 1)
         self.assertEqual(len(player.tiles), 14)
-        self.assertEqual(player.can_call_kan(tile, False), Meld.CHANKAN)
+        self.assertEqual(player.should_call_kan(tile, False), Meld.CHANKAN)
 
         player.discard_tile()
         player.draw_tile(tile)
@@ -269,15 +269,15 @@ def test_call_closed_kan(self):
         player.draw_tile(tile)
 
         # it is pretty stupid to call closed kan with 2m
-        self.assertEqual(player.can_call_kan(tile, False), None)
+        self.assertEqual(player.should_call_kan(tile, False), None)
 
         tiles = self._string_to_136_array(man='12223', sou='111456', pin='12')
         player.init_hand(tiles)
         tile = self._string_to_136_tile(sou='1')
         player.draw_tile(tile)
 
         # call closed kan with 1s is fine
-        self.assertEqual(player.can_call_kan(tile, False), Meld.KAN)
+        self.assertEqual(player.should_call_kan(tile, False), Meld.KAN)
 
     def test_opened_kan(self):
         table = Table()
@@ -292,14 +292,14 @@ def test_opened_kan(self):
 
         # our hand is closed, we don't need to call opened kan here
         tile = self._string_to_136_tile(sou='1')
-        self.assertEqual(player.can_call_kan(tile, True), None)
+        self.assertEqual(player.should_call_kan(tile, True), None)
 
         player.add_called_meld(self._make_meld(Meld.PON, honors='111'))
 
         # our hand is open, but it is not tempai
         # we don't need to open kan here
         tile = self._string_to_136_tile(sou='1')
-        self.assertEqual(player.can_call_kan(tile, True), None)
+        self.assertEqual(player.should_call_kan(tile, True), None)
 
         table = Table()
         player = table.player
@@ -314,7 +314,7 @@ def test_opened_kan(self):
 
         # our hand is open, in tempai and with a good wait
         tile = self._string_to_136_tile(sou='1')
-        self.assertEqual(player.can_call_kan(tile, True), Meld.KAN)
+        self.assertEqual(player.should_call_kan(tile, True), Meld.KAN)
 
     def test_closed_kan_and_riichi(self):
         table = Table()
@@ -330,7 +330,7 @@ def test_closed_kan_and_riichi(self):
         tile = kan_tiles[3]
         player.draw_tile(tile)
 
-        kan_type = player.can_call_kan(tile, False)
+        kan_type = player.should_call_kan(tile, False)
         self.assertEqual(kan_type, Meld.KAN)
 
         meld = Meld()
@@ -362,4 +362,4 @@ def test_dont_call_kan_in_defence_mode(self):
         table.add_called_riichi(1)
 
         tile = self._string_to_136_tile(sou='1')
-        self.assertEqual(table.player.can_call_kan(tile, False), None)
+        self.assertEqual(table.player.should_call_kan(tile, False), None)

project/game/ai/random/main.py

@@ -1,19 +1,15 @@
 # -*- coding: utf-8 -*-
 import random
 
-from game.ai.base.main import BaseAI
+from game.ai.base.main import InterfaceAI
 
 
-class MainAI(BaseAI):
+class ImplementationAI(InterfaceAI):
     """
     AI that will discard random tile from the hand
     """
-
     version = 'random'
 
-    def __init__(self, player):
-        super(MainAI, self).__init__(player)
-
     def discard_tile(self):
         tile_to_discard = random.randrange(len(self.player.tiles) - 1)
         tile_to_discard = self.player.tiles[tile_to_discard]

project/game/player.py

@@ -6,7 +6,7 @@
 from mahjong.meld import Meld
 from mahjong.tile import TilesConverter, Tile
 
-from game.ai.first_version.main import MainAI
+from utils.settings_handler import settings
 
 logger = logging.getLogger('tenhou')
 
@@ -117,7 +117,7 @@ class Player(PlayerInterface):
     def __init__(self, table, seat, dealer_seat):
         super().__init__(table, seat, dealer_seat)
 
-        self.ai = MainAI(self)
+        self.ai = settings.AI_CLASS(self)
 
     def erase_state(self):
         super().erase_state()
@@ -133,7 +133,7 @@ def erase_state(self):
     def init_hand(self, tiles):
         self.tiles = tiles
 
-        self.ai.determine_strategy()
+        self.ai.init_state()
 
     def draw_tile(self, tile):
         self.last_draw = tile
@@ -142,14 +142,14 @@ def draw_tile(self, tile):
         # we need sort it to have a better string presentation
         self.tiles = sorted(self.tiles)
 
-        self.ai.determine_strategy()
+        self.ai.draw_tile(tile)
 
     def discard_tile(self, discard_option=None):
         """
         :param discard_option:
         :return:
         """
-        # we can't use if tile, because of 0 tile
+
         if discard_option:
             tile_to_discard = self.ai.process_discard_option(discard_option, self.closed_hand)
         else:
@@ -169,26 +169,28 @@ def can_call_riichi(self):
 
             not self.in_riichi,
             not self.is_open_hand,
-            not self.ai.in_defence,
 
             self.scores >= 1000,
             self.table.count_of_remaining_tiles > 4
         ])
 
         return result and self.ai.should_call_riichi()
 
-    def can_call_kan(self, tile, open_kan):
+    def should_call_kan(self, tile, open_kan):
         """
         Method will decide should we call a kan,
         or upgrade pon to kan
         :param tile: 136 tile format
         :return:
         """
-        return self.ai.can_call_kan(tile, open_kan)
+        return self.ai.should_call_kan(tile, open_kan)
 
     def try_to_call_meld(self, tile, is_kamicha_discard):
         return self.ai.try_to_call_meld(tile, is_kamicha_discard)
 
+    def enemy_called_riichi(self, player_seat):
+        self.ai.enemy_called_riichi(player_seat)
+
     def total_tiles(self, tile, tiles_34):
         """
         Return sum of all tiles (discarded + from melds + our hand)
@@ -198,15 +200,6 @@ def total_tiles(self, tile, tiles_34):
         """
         return tiles_34[tile] + self.table.revealed_tiles[tile]
 
-    def enemy_called_riichi(self):
-        """
-        After enemy riichi we had to check will we fold or not
-        it is affect open hand decision
-        :return:
-        """
-        if self.ai.defence.should_go_to_defence_mode():
-            self.ai.in_defence = True
-
     def add_called_meld(self, meld: Meld):
         # we had to remove tile from the hand for closed kan set
         if (meld.type == Meld.KAN and not meld.opened) or meld.type == Meld.CHANKAN:

project/game/table.py

@@ -93,7 +93,7 @@ def add_called_riichi(self, player_seat):
 
         # we had to check will we go for defence or not
         if player_seat != 0:
-            self.player.enemy_called_riichi()
+            self.player.enemy_called_riichi(player_seat)
 
     def add_discarded_tile(self, player_seat, tile, is_tsumogiri):
         """