Improve AI structure a little bit. Remove all not necessary dependencies

Author: Nihisil

project/game/ai/base/base.py project/game/ai/base/main.pyproject/game/ai/base/base.py renamed to project/game/ai/base/main.py

@@ -5,15 +5,28 @@
 class EnemyAnalyzer(object):
     player = None
     chosen_suit = None
+    initialized = False
 
     def __init__(self, player):
         """
         :param player: instance of EnemyPlayer
         """
         self.player = player
         self.table = player.table
+
         self.chosen_suit = None
 
+        # we need it to determine user's chosen suit
+        self.initialized = self.is_threatening
+
+    @property
+    def is_dealer(self):
+        return self.player.is_dealer
+
+    @property
+    def all_safe_tiles(self):
+        return self.player.all_safe_tiles
+
     @property
     def in_tempai(self):
         """

project/game/ai/base/discard.py project/game/ai/discard.pyproject/game/ai/base/discard.py renamed to project/game/ai/discard.py

@@ -2,6 +2,7 @@
 from mahjong.utils import plus_dora, is_honor
 
 from game.ai.first_version.defence.defence import DefenceTile
+from game.ai.first_version.defence.enemy_analyzer import EnemyAnalyzer
 from game.ai.first_version.defence.impossible_wait import ImpossibleWait
 from game.ai.first_version.defence.kabe import Kabe
 from game.ai.first_version.defence.suji import Suji
@@ -155,7 +156,7 @@ def try_to_find_safe_tile_to_discard(self, discard_results):
         # let's find safe tiles for most dangerous player first
         # and than for all other players if we failed find tile for dangerous player
         for player in threatening_players:
-            player_safe_tiles = [DefenceTile(x, DefenceTile.SAFE) for x in player.all_safe_tiles]
+            player_safe_tiles = [DefenceTile(x, DefenceTile.SAFE) for x in player.player.all_safe_tiles]
             player_suji_tiles = self.suji.find_tiles_to_discard([player])
 
             # it can be that safe tile will be mark as "almost safe",
@@ -186,6 +187,11 @@ def try_to_find_safe_tile_to_discard(self, discard_results):
         # we wasn't able to find safe tile to discard
         return None
 
+    @property
+    def analyzed_enemies(self):
+        players = self.player.ai.enemy_players
+        return [EnemyAnalyzer(x) for x in players]
+
     def _find_tile_to_discard(self, safe_tiles, discard_tiles):
         """
         Try to find most effective safe tile to discard
@@ -218,12 +224,12 @@ def _get_threatening_players(self):
         Sorted by threat level. Most threatening on the top
         """
         result = []
-        for player in self.table.enemy_players:
+        for player in self.analyzed_enemies:
             if player.is_threatening:
                 result.append(player)
 
         # dealer is most threatening player
-        result = sorted(result, key=lambda x: x.is_dealer, reverse=True)
+        result = sorted(result, key=lambda x: x.player.is_dealer, reverse=True)
 
         return result
 

project/game/ai/first_version/defence/enemy_analyzer.py

@@ -10,8 +10,9 @@
 from mahjong.tile import TilesConverter
 from mahjong.utils import is_pair, is_pon
 
-from game.ai.base.base import BaseAI
-from game.ai.base.discard import DiscardOption
+from game.ai.base.main import BaseAI
+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
@@ -364,6 +365,13 @@ def can_call_kan(self, tile, open_kan):
 
         return None
 
+    @property
+    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/defence/main.py

@@ -4,7 +4,7 @@
 from mahjong.constants import EAST, SOUTH, WEST, NORTH, HAKU, HATSU, CHUN, FIVE_RED_SOU
 from mahjong.tests_mixin import TestMixin
 
-from game.ai.base.discard import DiscardOption
+from game.ai.discard import DiscardOption
 from game.table import Table
 
 

project/game/ai/first_version/main.py

@@ -5,6 +5,7 @@
 from mahjong.tests_mixin import TestMixin
 from mahjong.utils import is_pin
 
+from game.ai.first_version.defence.enemy_analyzer import EnemyAnalyzer
 from game.table import Table
 
 
@@ -13,33 +14,33 @@ class EnemyAnalyzerTestCase(unittest.TestCase, TestMixin):
     def test_detect_enemy_tempai_and_riichi(self):
         table = Table()
 
-        self.assertEqual(table.get_player(1).in_tempai, False)
-        self.assertEqual(table.get_player(1).is_threatening, False)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
 
         table.add_called_riichi(1)
 
-        self.assertEqual(table.get_player(1).in_tempai, True)
-        self.assertEqual(table.get_player(1).is_threatening, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
 
     def test_detect_enemy_tempai_and_opened_sets(self):
         table = Table()
 
-        self.assertEqual(table.get_player(1).in_tempai, False)
-        self.assertEqual(table.get_player(1).is_threatening, False)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
 
         table.add_called_meld(1, self._make_meld(Meld.CHI, sou='567'))
         table.add_called_meld(1, self._make_meld(Meld.CHI, pin='123'))
         table.add_called_meld(1, self._make_meld(Meld.CHI, man='345'))
         table.add_called_meld(1, self._make_meld(Meld.PON, man='777'))
 
-        self.assertEqual(table.get_player(1).in_tempai, True)
-        self.assertEqual(table.get_player(1).is_threatening, False)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
 
         table.dora_indicators = [self._string_to_136_tile(man='6')]
 
         # enemy opened the pon of dor, so better to fold against him
-        self.assertEqual(table.get_player(1).in_tempai, True)
-        self.assertEqual(table.get_player(1).is_threatening, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
 
     def test_try_to_detect_honitsu_hand(self):
         table = Table()
@@ -56,5 +57,5 @@ def test_try_to_detect_honitsu_hand(self):
         table.add_discarded_tile(1, self._string_to_136_tile(man='1'), False)
         table.add_discarded_tile(1, self._string_to_136_tile(pin='1'), False)
 
-        self.assertEqual(table.get_player(1).is_threatening, True)
-        self.assertEqual(table.get_player(1).chosen_suit, is_pin)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
+        self.assertEqual(EnemyAnalyzer(table.get_player(1)).chosen_suit, is_pin)

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

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import random
 
-from game.ai.base.base import BaseAI
+from game.ai.base.main import BaseAI
 
 
 class MainAI(BaseAI):

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

@@ -5,8 +5,8 @@
 class Client(object):
     table = None
 
-    def __init__(self, previous_ai=False):
-        self.table = Table(previous_ai)
+    def __init__(self):
+        self.table = Table()
 
     def connect(self):
         raise NotImplemented()

project/game/ai/random/base.py project/game/ai/random/main.pyproject/game/ai/random/base.py renamed to project/game/ai/random/main.py

@@ -6,7 +6,6 @@
 from mahjong.meld import Meld
 from mahjong.tile import TilesConverter, Tile
 
-from game.ai.first_version.defence.enemy_analyzer import EnemyAnalyzer
 from game.ai.first_version.main import MainAI
 
 logger = logging.getLogger('tenhou')
@@ -28,13 +27,10 @@ class PlayerInterface(object):
     name = ''
     rank = ''
 
-    previous_ai = False
-
-    def __init__(self, table, seat, dealer_seat, previous_ai):
+    def __init__(self, table, seat, dealer_seat):
         self.table = table
         self.seat = seat
         self.dealer_seat = dealer_seat
-        self.previous_ai = previous_ai
 
         self.erase_state()
 
@@ -74,7 +70,7 @@ def add_discarded_tile(self, tile: Tile):
         # all tiles that were discarded after player riichi will be safe against him
         # because of furiten
         tile = tile.value // 4
-        for player in self.table.enemy_players:
+        for player in self.table.players[1:]:
             if player.in_riichi and tile not in player.safe_tiles:
                 player.safe_tiles.append(tile)
 
@@ -118,9 +114,10 @@ class Player(PlayerInterface):
     in_tempai = False
     in_defence_mode = False
 
-    def __init__(self, table, seat, dealer_seat, previous_ai):
-        super().__init__(table, seat, dealer_seat, previous_ai)
-        self._load_ai()
+    def __init__(self, table, seat, dealer_seat):
+        super().__init__(table, seat, dealer_seat)
+
+        self.ai = MainAI(self)
 
     def erase_state(self):
         super().erase_state()
@@ -247,24 +244,19 @@ def open_hand_34_tiles(self):
             results.append([meld[0] // 4, meld[1] // 4, meld[2] // 4])
         return results
 
-    def _load_ai(self):
-        self.ai = MainAI(self)
-
 
 class EnemyPlayer(PlayerInterface):
     # array of tiles in 34 tile format
     safe_tiles = None
     # tiles that were discarded in the current "step"
     # so, for example kamicha discard will be a safe tile for all players
     temporary_safe_tiles = None
-    enemy_analyzer = None
 
     def erase_state(self):
         super().erase_state()
 
         self.safe_tiles = []
         self.temporary_safe_tiles = []
-        self.enemy_analyzer = EnemyAnalyzer(self)
 
     def add_discarded_tile(self, tile: Tile):
         super().add_discarded_tile(tile)
@@ -277,6 +269,7 @@ def add_discarded_tile(self, tile: Tile):
         self.temporary_safe_tiles = []
         affected_players = [1, 2, 3]
         affected_players.remove(self.seat)
+
         # temporary furiten, for one "step"
         for x in affected_players:
             if tile not in self.table.get_player(x).temporary_safe_tiles:
@@ -285,27 +278,3 @@ def add_discarded_tile(self, tile: Tile):
     @property
     def all_safe_tiles(self):
         return list(set(self.temporary_safe_tiles + self.safe_tiles))
-
-    @property
-    def in_tempai(self):
-        """
-        Try to detect is user in tempai or not
-        :return: boolean
-        """
-        return self.enemy_analyzer.in_tempai
-
-    @property
-    def is_threatening(self):
-        """
-        Should we fold against this player or not
-        :return: boolean
-        """
-        return self.enemy_analyzer.is_threatening
-
-    @property
-    def chosen_suit(self):
-        """
-        If user collecting honitsu we can detect his specific suit
-        :return: function
-        """
-        return self.enemy_analyzer.chosen_suit