Various improvements

.flake8

@@ -1,3 +1,3 @@
 [flake8]
 max-line-length = 120
-exclude = settings.py
+exclude = *settings.py,tests_validate_hand.py

.gitignore

@@ -20,4 +20,7 @@ project/game/data/*
 project/analytics/data/*
 
 # temporary files
-experiments
+experiments
+
+*.prof
+profile.py

.travis.yml

@@ -1,7 +1,10 @@
 language: python
+dist: xenial
+sudo: true
 python:
   - "3.5"
   - "3.6"
+  - "3.7"
 before_script:
   - cd project
 install: "pip install -r project/requirements.txt"

CODE_OF_CONDUCT.md

@@ -0,0 +1,5 @@
+## Tenhou bot code of conduct:
+
+1. A robot may not injure a human being or, through inaction, allow a human being to come to harm.
+2. A robot must obey orders given it by human beings except where such orders would conflict with the First Law.
+3. A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.

bin/run.sh

@@ -1,19 +1,21 @@
 #!/bin/sh -e
 
-# cron will run each 5 minutes
-# and will search the run process
+# the cron job will be executed each 5 minutes
+# and it will try to find bot process
 # if there is no process, it will run it
+# example of usage
+# */5 * * * * bash /root/bot/bin/run.sh bot_settings_name
 
-# */5 * * * * bash /root/bot/bin/run.sh
+SETTINGS_NAME="$1"
 
-PID=`ps -eaf | grep project/main.py | grep -v grep | awk '{print $2}'`
+PID=`ps -eaf | grep "project/main.py -s ${SETTINGS_NAME}" | grep -v grep | awk '{print $2}'`
 
-if [[ "" =  "$PID" ]]; then
-  /root/bot/env/bin/python /root/bot/project/main.py
+if [[ "" = "$PID" ]]; then
+  /root/bot/env/bin/python /root/bot/project/main.py -s ${SETTINGS_NAME}
 else
   WORKED_SECONDS=`ps -p "$PID" -o etimes=`
-  # if process run > 60 minutes, probably it hang and we need to kill it
-  if [ ${WORKED_SECONDS} -gt "3600" ]; then
+  # if process run > 60 minutes, probably it hangs and we need to kill it
+  if [[ ${WORKED_SECONDS} -gt "3600" ]]; then
     kill ${PID}
   fi
 fi

project/game/ai/base/main.py

@@ -56,11 +56,12 @@ def should_call_riichi(self):
         """
         return False
 
-    def should_call_kan(self, tile, is_open_kan):
+    def should_call_kan(self, tile, is_open_kan, from_riichi=False):
         """
-        When bot can call kan or chankan this method will be called
+        When bot can call kan or shouminkan this method will be called
         :param tile: 136 tile format
         :param is_open_kan: boolean
+        :param from_riichi: boolean
         :return: kan type (Meld.KAN, Meld.CHANKAN) or None
         """
         return False

project/game/ai/discard.py

@@ -1,18 +1,25 @@
 # -*- coding: utf-8 -*-
 from mahjong.constants import AKA_DORA_LIST
 from mahjong.tile import TilesConverter
-from mahjong.utils import is_honor, simplify, plus_dora, is_aka_dora
+from mahjong.utils import is_honor, simplify, plus_dora, is_aka_dora, is_sou, is_man, is_pin
+
+from game.ai.first_version.strategies.main import BaseStrategy
 
 
 class DiscardOption(object):
+    DORA_VALUE = 10000
+    DORA_FIRST_NEIGHBOUR = 1000
+    DORA_SECOND_NEIGHBOUR = 100
+
     player = None
 
     # in 34 tile format
     tile_to_discard = None
     # array of tiles that will improve our hand
     waiting = None
     # how much tiles will improve our hand
-    tiles_count = None
+    ukeire = None
+    ukeire_second = None
     # number of shanten for that tile
     shanten = None
     # sometimes we had to force tile to be discarded
@@ -23,25 +30,45 @@ class DiscardOption(object):
     valuation = None
     # how danger this tile is
     danger = None
+    # wait to ukeire map
+    wait_to_ukeire = None
+    # second level cost approximation for 1-shanten hands
+    second_level_cost = None
 
-    def __init__(self, player, tile_to_discard, shanten, waiting, tiles_count, danger=100):
+    def __init__(self, player, tile_to_discard, shanten, waiting, ukeire, danger=100, wait_to_ukeire=None):
         """
         :param player:
         :param tile_to_discard: tile in 34 format
         :param waiting: list of tiles in 34 format
-        :param tiles_count: count of tiles to wait after discard
+        :param ukeire: count of tiles to wait after discard
         """
         self.player = player
         self.tile_to_discard = tile_to_discard
         self.shanten = shanten
         self.waiting = waiting
-        self.tiles_count = tiles_count
+        self.ukeire = ukeire
+        self.ukeire_second = 0
+        self.count_of_dora = 0
         self.danger = danger
         self.had_to_be_saved = False
         self.had_to_be_discarded = False
+        self.wait_to_ukeire = wait_to_ukeire
 
         self.calculate_value()
 
+    def __unicode__(self):
+        tile_format_136 = TilesConverter.to_one_line_string([self.tile_to_discard*4])
+        return 'tile={}, shanten={}, ukeire={}, ukeire2={}, valuation={}'.format(
+            tile_format_136,
+            self.shanten,
+            self.ukeire,
+            self.ukeire_second,
+            self.valuation
+        )
+
+    def __repr__(self):
+        return '{}'.format(self.__unicode__())
+
     def find_tile_in_hand(self, closed_hand):
         """
         Find and return 136 tile in closed player hand
@@ -69,31 +96,66 @@ def find_tile_in_hand(self, closed_hand):
 
         return TilesConverter.find_34_tile_in_136_array(self.tile_to_discard, closed_hand)
 
-    def calculate_value(self, shanten=None):
+    def calculate_value(self):
         # base is 100 for ability to mark tiles as not needed (like set value to 50)
         value = 100
         honored_value = 20
 
-        # we don't need to keep honor tiles in almost completed hand
-        if shanten and shanten <= 2:
-            honored_value = 0
-
         if is_honor(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:
-            # suits
-            suit_tile_grades = [10, 20, 30, 40, 50, 40, 30, 20, 10]
+            # aim for tanyao
+            if self.player.ai.current_strategy and self.player.ai.current_strategy.type == BaseStrategy.TANYAO:
+                suit_tile_grades = [10, 20, 30, 50, 40, 50, 30, 20, 10]
+            # usual hand
+            else:
+                suit_tile_grades = [10, 20, 40, 50, 30, 50, 40, 20, 10]
+
             simplified_tile = simplify(self.tile_to_discard)
             value += suit_tile_grades[simplified_tile]
 
+            for indicator in self.player.table.dora_indicators:
+                indicator_34 = indicator // 4
+                if is_honor(indicator_34):
+                    continue
+
+                # indicator and tile not from the same suit
+                if is_sou(indicator_34) and not is_sou(self.tile_to_discard):
+                    continue
+
+                # indicator and tile not from the same suit
+                if is_man(indicator_34) and not is_man(self.tile_to_discard):
+                    continue
+
+                # indicator and tile not from the same suit
+                if is_pin(indicator_34) and not is_pin(self.tile_to_discard):
+                    continue
+
+                simplified_indicator = simplify(indicator_34)
+                simplified_dora = simplified_indicator + 1
+                # indicator is 9 man
+                if simplified_dora == 9:
+                    simplified_dora = 0
+
+                # tile so close to the dora
+                if simplified_tile + 1 == simplified_dora or simplified_tile - 1 == simplified_dora:
+                    value += DiscardOption.DORA_FIRST_NEIGHBOUR
+
+                # tile not far away from dora
+                if simplified_tile + 2 == simplified_dora or simplified_tile - 2 == simplified_dora:
+                    value += DiscardOption.DORA_SECOND_NEIGHBOUR
+
         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):
+
+        tile_136 = self.find_tile_in_hand(self.player.closed_hand)
+        if is_aka_dora(tile_136, self.player.table.has_aka_dora):
             count_of_dora += 1
 
-        value += 50 * count_of_dora
+        self.count_of_dora = count_of_dora
+        value += count_of_dora * DiscardOption.DORA_VALUE
 
         if is_honor(self.tile_to_discard):
             # depends on how much honor tiles were discarded
@@ -108,4 +170,4 @@ def calculate_value(self, shanten=None):
             if value == 0:
                 self.had_to_be_discarded = True
 
-        self.valuation = value
+        self.valuation = int(value)

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

@@ -14,10 +14,10 @@ def find_tiles_to_discard(self, _):
 
         results = []
         for x in HONOR_INDICES:
-            if self.player.total_tiles(x, self.defence.hand_34) == 4:
+            if self.player.total_tiles(x, self.defence.closed_hand_34) == 4:
                 results.append(DefenceTile(x, DefenceTile.SAFE))
 
-            if self.player.total_tiles(x, self.defence.hand_34) == 3:
+            if self.player.total_tiles(x, self.defence.closed_hand_34) == 3:
                 results.append(DefenceTile(x, DefenceTile.ALMOST_SAFE_TILE))
 
         return results

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

@@ -7,52 +7,96 @@
 
 class Kabe(Defence):
 
-    def find_tiles_to_discard(self, _):
-        results = []
-
+    def find_all_kabe(self, tiles_34):
         # all indices shifted to -1
         kabe_matrix = [
-            {'indices': [1], 'blocked_tiles': [0]},
-            {'indices': [2], 'blocked_tiles': [0, 1]},
-            {'indices': [3], 'blocked_tiles': [1, 2]},
-            {'indices': [4], 'blocked_tiles': [2, 6]},
-            {'indices': [5], 'blocked_tiles': [6, 7]},
-            {'indices': [6], 'blocked_tiles': [7, 8]},
-            {'indices': [7], 'blocked_tiles': [8]},
-            {'indices': [1, 5], 'blocked_tiles': [3]},
-            {'indices': [2, 6], 'blocked_tiles': [4]},
-            {'indices': [3, 7], 'blocked_tiles': [5]},
-            {'indices': [1, 4], 'blocked_tiles': [2, 3]},
-            {'indices': [2, 5], 'blocked_tiles': [3, 4]},
-            {'indices': [3, 6], 'blocked_tiles': [4, 5]},
-            {'indices': [4, 7], 'blocked_tiles': [5, 6]},
+            {'indices': [1], 'blocked_tiles': [0], 'type': KabeTile.STRONG_KABE},
+            {'indices': [2], 'blocked_tiles': [0, 1], 'type': KabeTile.STRONG_KABE},
+            {'indices': [6], 'blocked_tiles': [7, 8], 'type': KabeTile.STRONG_KABE},
+            {'indices': [7], 'blocked_tiles': [8], 'type': KabeTile.STRONG_KABE},
+            {'indices': [0, 3], 'blocked_tiles': [2, 3], 'type': KabeTile.STRONG_KABE},
+            {'indices': [1, 3], 'blocked_tiles': [2], 'type': KabeTile.STRONG_KABE},
+            {'indices': [1, 4], 'blocked_tiles': [2, 3], 'type': KabeTile.STRONG_KABE},
+            {'indices': [2, 4], 'blocked_tiles': [3], 'type': KabeTile.STRONG_KABE},
+            {'indices': [2, 5], 'blocked_tiles': [3, 4], 'type': KabeTile.STRONG_KABE},
+            {'indices': [3, 5], 'blocked_tiles': [4], 'type': KabeTile.STRONG_KABE},
+            {'indices': [3, 6], 'blocked_tiles': [4, 5], 'type': KabeTile.STRONG_KABE},
+            {'indices': [4, 6], 'blocked_tiles': [5], 'type': KabeTile.STRONG_KABE},
+            {'indices': [4, 7], 'blocked_tiles': [5, 6], 'type': KabeTile.STRONG_KABE},
+            {'indices': [5, 7], 'blocked_tiles': [6], 'type': KabeTile.STRONG_KABE},
+            {'indices': [5, 8], 'blocked_tiles': [6, 7], 'type': KabeTile.STRONG_KABE},
+
+            {'indices': [3], 'blocked_tiles': [1, 2], 'type': KabeTile.WEAK_KABE},
+            {'indices': [4], 'blocked_tiles': [2, 6], 'type': KabeTile.WEAK_KABE},
+            {'indices': [5], 'blocked_tiles': [6, 7], 'type': KabeTile.WEAK_KABE},
+            {'indices': [1, 5], 'blocked_tiles': [3], 'type': KabeTile.WEAK_KABE},
+            {'indices': [2, 6], 'blocked_tiles': [4], 'type': KabeTile.WEAK_KABE},
+            {'indices': [3, 7], 'blocked_tiles': [5], 'type': KabeTile.WEAK_KABE},
         ]
 
-        suits = self._suits_tiles(self.defence.hand_34)
+        kabe_tiles_strong = []
+        kabe_tiles_weak = []
+        kabe_tiles_partial = []
+
+        suits = self._suits_tiles(tiles_34)
         for x in range(0, 3):
             suit = suits[x]
             # "kabe" - 4 revealed tiles
             kabe_tiles = []
+            partial_kabe_tiles = []
             for y in range(0, 9):
                 suit_tile = suit[y]
                 if suit_tile == 4:
                     kabe_tiles.append(y)
+                elif suit_tile == 3:
+                    partial_kabe_tiles.append(y)
 
-            blocked_indices = []
             for matrix_item in kabe_matrix:
-                all_indices = len(list(set(matrix_item['indices']) - set(kabe_tiles))) == 0
-                if all_indices:
-                    blocked_indices.extend(matrix_item['blocked_tiles'])
+                if len(list(set(matrix_item['indices']) - set(kabe_tiles))) == 0:
+                    for tile in matrix_item['blocked_tiles']:
+                        if matrix_item['type'] == KabeTile.STRONG_KABE:
+                            kabe_tiles_strong.append(tile + x * 9)
+                        else:
+                            kabe_tiles_weak.append(tile + x * 9)
+
+                if len(list(set(matrix_item['indices']) - set(partial_kabe_tiles))) == 0:
+                    for tile in matrix_item['blocked_tiles']:
+                        kabe_tiles_partial.append(tile + x * 9)
+
+        kabe_tiles_unique = []
+        kabe_tiles_strong = list(set(kabe_tiles_strong))
+        kabe_tiles_weak = list(set(kabe_tiles_weak))
+        kabe_tiles_partial = list(set(kabe_tiles_partial))
+
+        for tile in kabe_tiles_strong:
+            kabe_tiles_unique.append(KabeTile(tile, KabeTile.STRONG_KABE))
+
+        for tile in kabe_tiles_weak:
+            if tile not in kabe_tiles_strong:
+                kabe_tiles_unique.append(KabeTile(tile, KabeTile.WEAK_KABE))
+
+        for tile in kabe_tiles_partial:
+            if tile not in kabe_tiles_strong and tile not in kabe_tiles_weak:
+                kabe_tiles_unique.append(KabeTile(tile, KabeTile.PARTIAL_KABE))
+
+        return kabe_tiles_unique
 
-            blocked_indices = list(set(blocked_indices))
-            for index in blocked_indices:
-                # let's find 34 tile index
-                tile = index + x * 9
-                if self.player.total_tiles(tile, self.defence.hand_34) == 4:
-                    results.append(DefenceTile(tile, DefenceTile.SAFE))
+    def find_tiles_to_discard(self, _):
+        all_kabe = self.find_all_kabe(self.defence.closed_hand_34)
+
+        results = []
+
+        for kabe in all_kabe:
+            # we don't use it for defence now
+            if kabe.kabe_type == KabeTile.PARTIAL_KABE:
+                continue
 
-                if self.player.total_tiles(tile, self.defence.hand_34) == 3:
-                    results.append(DefenceTile(tile, DefenceTile.ALMOST_SAFE_TILE))
+            tile = kabe.tile_34
+            if self.player.total_tiles(tile, self.defence.closed_hand_34) == 4:
+                results.append(DefenceTile(tile, DefenceTile.SAFE))
+
+            if self.player.total_tiles(tile, self.defence.closed_hand_34) == 3:
+                results.append(DefenceTile(tile, DefenceTile.ALMOST_SAFE_TILE))
 
         return results
 
@@ -88,3 +132,16 @@ def _suits_tiles(self, tiles_34):
             suits[suit_index][simplified_tile] += total_tiles
 
         return suits
+
+
+class KabeTile(object):
+    STRONG_KABE = 0
+    WEAK_KABE = 1
+    PARTIAL_KABE = 2
+
+    tile_34 = None
+    kabe_type = None
+
+    def __init__(self, tile_34, kabe_type):
+        self.tile_34 = tile_34
+        self.kabe_type = kabe_type