Merge branch 'hand-calculating-refactoring'

Author: Nihisil

.gitignore

@@ -6,7 +6,7 @@ __pycache__
 .DS_Store
 logs
 project/settings_local.py
-old_version.py
+project/game/ai/common
 
 tests_validate_hand.py
 loader.py

README.md

@@ -8,21 +8,7 @@ For now only **Python 3.5+** is supported.
 
 ## Mahjong hands calculation
 
-We have a code which can calculate hand cost (han, fu, yaku and scores) based on the hand's tiles.
-
-It supports features like:
-
-- Disable\enable aka dora in the hand
-- Disable\enable open tanyao yaku
-- By now it supports double yakumans (Dai Suushii, Daburu Kokushi musou, Suu ankou tanki, 
-Daburu Chuuren Poutou). Later I plan to have a disabling option in settings for it.
-
-The code was validated on tenhou.net phoenix replays in total on **8'527'296 hands**, and 
-results were the same in 100% cases.
-
-So, we can say that our own hand calculator works the same way that tenhou.net hand calculation.
-
-The example of usage you can find here: https://github.com/MahjongRepository/tenhou-python-bot/blob/master/project/validate_hand.py#L194
+You can find it here: https://github.com/MahjongRepository/mahjong
 
 ## Mahjong bot
 
@@ -74,8 +60,8 @@ For the next version I have a plan to improve win rate, probably bot should push
 
 ## How to run it?
 
-Run `pythone main.py` it will connect to the tenhou.net and will play a match. 
-After the end of the match it will close connection to the server
+1. `pip install -r requirements.txt`
+2. Run `pythone main.py` it will connect to the tenhou.net and will play a game
 
 ## Configuration instructions
 
@@ -84,6 +70,21 @@ They will override settings from default `settings.py` file
 2. Also you can override some default settings with command argument. 
 Use `python main.py -h` to check all available commands
 
+## Implement your own AI
+
+We tried to isolate default AI from the project as much as we could.
+
+There is `game.ai.base.InterfaceAI` with one required method `discard_tile` that had to be implemented by your AI.
+
+### Start with your AI
+
+This command will make a copy of the simple bot (it is discarding random tiles from the hand)
+1. `cd project`
+2. `cp -a game/ai/random game/ai/common` 
+3. You can run new AI with command: `python main.py -a common` (or change `AI_PACKAGE` in settings)
+
+After that you can change all what you want in `game.ai.common` package and test it in real games.
+
 ## Round reproducer
 
 We built the way to reproduce already played round. 
@@ -119,7 +120,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/mahjong/__init__.py project/game/__init__.pyproject/mahjong/__init__.py renamed to project/game/__init__.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+
+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, discard_tile):
+        """
+        AI should decide what tile had to be discarded from the hand on bot turn
+        :param discard_tile: 136 tile format. Sometimes we want to discard specific tile
+        :return: 136 tile format
+        """
+        raise NotImplemented()
+
+    def init_hand(self):
+        """
+        Method will be called after bot hand initialization (when tiles will be set to the player)
+        :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 should_call_win(self, tile, enemy_seat):
+        """
+        When we can call win by other player discard this method will be called
+        :return: boolean
+        """
+        return True
+
+    def should_call_riichi(self):
+        """
+        When bot can call riichi this method will be called.
+        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):
+        """
+        When bot can call kan or chankan this method will be called
+        :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):
+        """
+        When bot can open hand with a set (chi or pon/kan) this method will be called
+        :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/mahjong/ai/__init__.py project/game/ai/__init__.pyproject/mahjong/ai/__init__.py renamed to project/game/ai/__init__.py

@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
 from mahjong.constants import AKA_DORA_LIST
 from mahjong.tile import TilesConverter
-from mahjong.utils import simplify, is_honor, plus_dora
-from utils.settings_handler import settings
+from mahjong.utils import is_honor, simplify, plus_dora, is_aka_dora
 
 
 class DiscardOption(object):
@@ -48,7 +47,7 @@ def find_tile_in_hand(self, closed_hand):
         Find and return 136 tile in closed player hand
         """
 
-        if settings.FIVE_REDS:
+        if self.player.table.has_aka_dora:
             # special case, to keep aka dora in hand
             if self.tile_to_discard in [4, 13, 22]:
                 aka_closed_hand = closed_hand[:]
@@ -78,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:
@@ -89,6 +88,9 @@ def calculate_value(self, shanten=None):
             value += suit_tile_grades[simplified_tile]
 
         count_of_dora = plus_dora(self.tile_to_discard * 4, self.player.table.dora_indicators)
+        if is_aka_dora(self.tile_to_discard * 4, self.player.table.has_open_tanyao):
+            count_of_dora += 1
+
         value += 50 * count_of_dora
 
         if is_honor(self.tile_to_discard):