def calculate_dora_count(self, tiles_136):
self.dora_count_central = 0
self.dora_count_not_central = 0
self.aka_dora_count = 0
for tile_136 in tiles_136:
tile_34 = tile_136 // 4
dora_count = plus_dora(tile_136, self.player.table.dora_indicators)
if is_aka_dora(tile_136, self.player.table.has_aka_dora):
self.aka_dora_count += 1
if not dora_count:
continue
if is_honor(tile_34):
self.dora_count_not_central += dora_count
self.dora_count_honor += dora_count
elif is_terminal(tile_34):
self.dora_count_not_central += dora_count
else:
self.dora_count_central += dora_count
self.dora_count_central += self.aka_dora_count
self.dora_count_total = self.dora_count_central + self.dora_count_not_central
def _initialize_honitsu_dora_count(self, tiles_136, suit):
tiles_34 = TilesConverter.to_34_array(tiles_136)
dora_count_man_not_isolated = 0
dora_count_pin_not_isolated = 0
dora_count_sou_not_isolated = 0
for tile_136 in tiles_136:
tile_34 = tile_136 // 4
dora_count = plus_dora(tile_136, self.player.table.dora_indicators)
if is_aka_dora(tile_136, self.player.table.has_aka_dora):
dora_count += 1
if is_man(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_man_not_isolated += dora_count
if is_pin(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_pin_not_isolated += dora_count
if is_sou(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_sou_not_isolated += dora_count
if suit['name'] == 'pin':
self.dora_count_other_suits_not_isolated = dora_count_man_not_isolated + dora_count_sou_not_isolated
elif suit['name'] == 'sou':
self.dora_count_other_suits_not_isolated = dora_count_man_not_isolated + dora_count_pin_not_isolated
elif suit['name'] == 'man':
self.dora_count_other_suits_not_isolated = dora_count_sou_not_isolated + dora_count_pin_not_isolated
def _initialize_honitsu_dora_count(self, tiles_136, suit):
tiles_34 = TilesConverter.to_34_array(tiles_136)
dora_count_man_not_isolated = 0
dora_count_pin_not_isolated = 0
dora_count_sou_not_isolated = 0
for tile_136 in tiles_136:
tile_34 = tile_136 // 4
dora_count = plus_dora(tile_136, self.player.table.dora_indicators)
if is_aka_dora(tile_136, self.player.table.has_aka_dora):
dora_count += 1
if is_man(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_man_not_isolated += dora_count
if is_pin(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_pin_not_isolated += dora_count
if is_sou(tile_34):
if not is_tile_strictly_isolated(tiles_34, tile_34):
dora_count_sou_not_isolated += dora_count
if suit['name'] == 'pin':
self.dora_count_other_suits_not_isolated = dora_count_man_not_isolated + dora_count_sou_not_isolated
elif suit['name'] == 'sou':
self.dora_count_other_suits_not_isolated = dora_count_man_not_isolated + dora_count_pin_not_isolated
elif suit['name'] == 'man':
self.dora_count_other_suits_not_isolated = dora_count_sou_not_isolated + dora_count_pin_not_isolated
def calculate_dora_count(self, tiles_136):
self.dora_count_central = 0
self.dora_count_not_central = 0
self.aka_dora_count = 0
for tile_136 in tiles_136:
tile_34 = tile_136 // 4
dora_count = plus_dora(tile_136, self.player.table.dora_indicators)
if is_aka_dora(tile_136, self.player.table.has_aka_dora):
self.aka_dora_count += 1
if not dora_count:
continue
if is_honor(tile_34):
self.dora_count_not_central += dora_count
self.dora_count_honor += dora_count
elif is_terminal(tile_34):
self.dora_count_not_central += dora_count
else:
self.dora_count_central += dora_count
self.dora_count_central += self.aka_dora_count
self.dora_count_total = self.dora_count_central + self.dora_count_not_central
def is_threatening(self):
"""
Should we fold against this player or not
:return: boolean
"""
if self.player.in_riichi:
return True
discards = self.player.discards
discards_34 = TilesConverter.to_34_array([x.value for x in discards])
is_honitsu_open_sets, open_hand_suit = False, None
is_honitsu_discards, discard_suit = self._is_honitsu_discards(
discards_34)
meld_tiles = self.player.meld_tiles
meld_tiles_34 = TilesConverter.to_34_array(meld_tiles)
if meld_tiles:
dora_count = sum(
[plus_dora(x, self.table.dora_indicators) for x in meld_tiles])
# aka dora
dora_count += sum([
1 for x in meld_tiles
if is_aka_dora(x, self.table.has_open_tanyao)
])
# enemy has a lot of dora tiles in his opened sets
# so better to fold against him
if dora_count >= 3:
return True
# check that user has a discard and melds that looks like honitsu
is_honitsu_open_sets, open_hand_suit = self._is_honitsu_open_sets(
meld_tiles_34)
if is_honitsu_open_sets:
# for 2 opened melds we had to check discard, to be sure
if len(
self.player.melds
) <= 2 and is_honitsu_discards and discard_suit == open_hand_suit:
self.chosen_suit = open_hand_suit
return True
# for 3+ opened melds there is no sense to check discard
if len(self.player.melds) >= 3:
self.chosen_suit = open_hand_suit
return True
return False
def calculate_value(self, shanten=None):
# 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]
simplified_tile = simplify(self.tile_to_discard)
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):
# depends on how much honor tiles were discarded
# we will decrease tile value
discard_percentage = [100, 75, 20, 0, 0]
discarded_tiles = self.player.table.revealed_tiles[
self.tile_to_discard]
value = (value * discard_percentage[discarded_tiles]) / 100
# three honor tiles were discarded,
# so we don't need this tile anymore
if value == 0:
self.had_to_be_discarded = True
self.valuation = value
def is_threatening(self):
"""
Should we fold against this player or not
:return: boolean
"""
if self.player.in_riichi:
return True
discards = self.player.discards
discards_34 = TilesConverter.to_34_array([x.value for x in discards])
is_honitsu_open_sets, open_hand_suit = False, None
is_honitsu_discards, discard_suit = self._is_honitsu_discards(discards_34)
meld_tiles = self.player.meld_tiles
meld_tiles_34 = TilesConverter.to_34_array(meld_tiles)
if meld_tiles:
dora_count = sum([plus_dora(x, self.table.dora_indicators) for x in meld_tiles])
# aka dora
dora_count += sum([1 for x in meld_tiles if is_aka_dora(x, self.table.has_open_tanyao)])
# enemy has a lot of dora tiles in his opened sets
# so better to fold against him
if dora_count >= 3:
return True
# check that user has a discard and melds that looks like honitsu
is_honitsu_open_sets, open_hand_suit = self._is_honitsu_open_sets(meld_tiles_34)
if is_honitsu_open_sets:
# for 2 opened melds we had to check discard, to be sure
if len(self.player.melds) <= 2 and is_honitsu_discards and discard_suit == open_hand_suit:
self.chosen_suit = open_hand_suit
return True
# for 3+ opened melds there is no sense to check discard
if len(self.player.melds) >= 3:
self.chosen_suit = open_hand_suit
return True
return False
def _suji_tiles(self, suji):
suji_temp = suji % 9
base = suji - suji_temp - 1
first_danger = 20
second_danger = 30
third_danger = 40
result = []
if suji_temp == self.FIRST_SUJI:
result = [
DefenceTile(base + 1, first_danger),
DefenceTile(base + 4, second_danger),
DefenceTile(base + 7, third_danger)
]
if suji_temp == self.SECOND_SUJI:
result = [
DefenceTile(base + 2, second_danger),
DefenceTile(base + 5, second_danger),
DefenceTile(base + 8, second_danger)
]
if suji_temp == self.THIRD_SUJI:
result = [
DefenceTile(base + 3, third_danger),
DefenceTile(base + 6, second_danger),
DefenceTile(base + 9, first_danger)
]
# mark dora tiles as dangerous tiles to discard
for tile in result:
is_dora = plus_dora(tile.value * 4, self.table.dora_indicators) \
or is_aka_dora(tile.value * 4, self.table.has_open_tanyao)
if is_dora:
tile.danger += 100
return result
def _suji_tiles(self, suji):
suji_temp = suji % 9
base = suji - suji_temp - 1
first_danger = 20
second_danger = 30
third_danger = 40
result = []
if suji_temp == self.FIRST_SUJI:
result = [
DefenceTile(base + 1, first_danger),
DefenceTile(base + 4, second_danger),
DefenceTile(base + 7, third_danger)
]
if suji_temp == self.SECOND_SUJI:
result = [
DefenceTile(base + 2, second_danger),
DefenceTile(base + 5, second_danger),
DefenceTile(base + 8, second_danger)
]
if suji_temp == self.THIRD_SUJI:
result = [
DefenceTile(base + 3, third_danger),
DefenceTile(base + 6, second_danger),
DefenceTile(base + 9, first_danger)
]
# mark dora tiles as dangerous tiles to discard
for tile in result:
is_dora = plus_dora(tile.value * 4, self.table.dora_indicators) \
or is_aka_dora(tile.value * 4, self.table.has_open_tanyao)
if is_dora:
tile.danger += 100
return result
def should_call_riichi(self):
logger.info("Can call a reach!")
# empty waiting can be found in some cases
if not self.waiting:
logger.info("However it is impossible to win.")
return False
# In pushing state, it's better to call it
if self.pushing:
logger.info("Go for it! The player is in pushing state.")
return True
# Get the rank EV after round 3
if self.table.round_number >= 5: # DEBUG: set this to 0
try:
possible_hand_values = [self.estimate_hand_value(tile, call_riichi=True).cost["main"] for tile in self.waiting]
except Exception as e:
print(e)
possible_hand_values = [2000]
hand_value = sum(possible_hand_values) / len(possible_hand_values)
hand_value += self.table.count_of_riichi_sticks * 1000
if self.player.is_dealer:
hand_value += 700 # EV for dealer combo
lose_estimation = 6000 if self.player.is_dealer else 7000
hand_shape = "pro_bad_shape" if self.wanted_tiles_count <= 4 else "pro_good_shape"
rank_ev = self.defence.get_rank_ev(hand_value, lose_estimation, COUNTER_RATIO[hand_shape][len(self.player.discards)])
logger.info('''Cowboy: Proactive reach:
Hand value: {} Hand shape: {}
Is dealer: {} Current ranking: {}
'''.format(hand_value, hand_shape, self.player.is_dealer, self.table.get_players_sorted_by_scores()))
logger.info("Rank EV for proactive reach: {}".format(rank_ev))
if rank_ev < 0:
logger.info("It's better to fold.")
return False
else:
logger.info("Go for it!")
return True
should_attack = not self.defence.should_go_to_defence_mode()
# For bad shape, at least 1 dora is required
# Get count of dora
dora_count = sum([plus_dora(x, self.player.table.dora_indicators) for x in self.player.tiles])
# aka dora
dora_count += sum([1 for x in self.player.tiles if is_aka_dora(x, self.player.table.has_open_tanyao)])
if self.wanted_tiles_count <= 4 and dora_count == 0 and not self.player.is_dealer:
should_attack = False
logger.info("A bad shape with no dora, don't call it.")
# # If player is on the top, no need to call reach
# if self.player == self.player.table.get_players_sorted_by_scores()[0] and self.player.scores > 30000:
# should_attack = False
# logger.info("Player is in 1st position, no need to call reach.")
if should_attack:
# If we are proactive, let's set the state!
logger.info("Go for it!")
if self.player.play_state == "PREPARING": # If not changed in defense actions
if self.wanted_tiles_count > 4:
self.player.set_state("PROACTIVE_GOODSHAPE")
else:
self.player.set_state("PROACTIVE_BADSHAPE")
return True
else:
logger.info("However it's better to fold.")
return False
# These codes are unreachable, it is fine.
waiting = self.waiting[0]
tiles = self.player.closed_hand + [waiting * 4]
closed_melds = [x for x in self.player.melds if not x.opened]
for meld in closed_melds:
tiles.extend(meld.tiles[:3])
tiles_34 = TilesConverter.to_34_array(tiles)
results = self.hand_divider.divide_hand(tiles_34)
result = results[0]
count_of_pairs = len([x for x in result if is_pair(x)])
# with chitoitsu we can call a riichi with pair wait
if count_of_pairs == 7:
return True
for hand_set in result:
# better to not call a riichi for a pair wait
# it can be easily improved
if is_pair(hand_set) and waiting in hand_set:
return False
return True
def estimate_hand_value(
self,
tiles,
win_tile,
melds=None,
dora_indicators=None,
config=None,
scores_calculator_factory=ScoresCalculator,
use_hand_divider_cache=False,
):
"""
:param tiles: array with 14 tiles in 136-tile format
:param win_tile: 136 format tile that caused win (ron or tsumo)
:param melds: array with Meld objects
:param dora_indicators: array of tiles in 136-tile format
:param config: HandConfig object
:param use_hand_divider_cache: could be useful if you are calculating a lot of menchin hands
:return: HandResponse object
"""
if not melds:
melds = []
if not dora_indicators:
dora_indicators = []
self.config = config or HandConfig()
agari = Agari()
hand_yaku = []
scores_calculator = scores_calculator_factory()
tiles_34 = TilesConverter.to_34_array(tiles)
fu_calculator = FuCalculator()
is_aotenjou = isinstance(scores_calculator, Aotenjou)
opened_melds = [x.tiles_34 for x in melds if x.opened]
all_melds = [x.tiles_34 for x in melds]
is_open_hand = len(opened_melds) > 0
# special situation
if self.config.is_nagashi_mangan:
hand_yaku.append(self.config.yaku.nagashi_mangan)
fu = 30
han = self.config.yaku.nagashi_mangan.han_closed
cost = scores_calculator.calculate_scores(han, fu, self.config,
False)
return HandResponse(cost, han, fu, hand_yaku)
if win_tile not in tiles:
return HandResponse(error=HandCalculator.ERR_NO_WINNING_TILE)
if self.config.is_riichi and not self.config.is_daburu_riichi and is_open_hand:
return HandResponse(error=HandCalculator.ERR_OPEN_HAND_RIICHI)
if self.config.is_daburu_riichi and is_open_hand:
return HandResponse(error=HandCalculator.ERR_OPEN_HAND_DABURI)
if self.config.is_ippatsu and not self.config.is_riichi and not self.config.is_daburu_riichi:
return HandResponse(
error=HandCalculator.ERR_IPPATSU_WITHOUT_RIICHI)
if self.config.is_chankan and self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_CHANKAN_WITH_TSUMO)
if self.config.is_rinshan and not self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_RINSHAN_WITHOUT_TSUMO)
if self.config.is_haitei and not self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_HAITEI_WITHOUT_TSUMO)
if self.config.is_houtei and self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_HOUTEI_WITH_TSUMO)
if self.config.is_haitei and self.config.is_rinshan:
return HandResponse(error=HandCalculator.ERR_HAITEI_WITH_RINSHAN)
if self.config.is_houtei and self.config.is_chankan:
return HandResponse(error=HandCalculator.ERR_HOUTEI_WITH_CHANKAN)
# raise error only when player wind is defined (and is *not* EAST)
if self.config.is_tenhou and self.config.player_wind and not self.config.is_dealer:
return HandResponse(error=HandCalculator.ERR_TENHOU_NOT_AS_DEALER)
if self.config.is_tenhou and not self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_TENHOU_WITHOUT_TSUMO)
if self.config.is_tenhou and melds:
return HandResponse(error=HandCalculator.ERR_TENHOU_WITH_MELD)
# raise error only when player wind is defined (and is EAST)
if self.config.is_chiihou and self.config.player_wind and self.config.is_dealer:
return HandResponse(error=HandCalculator.ERR_CHIIHOU_AS_DEALER)
if self.config.is_chiihou and not self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_CHIIHOU_WITHOUT_TSUMO)
if self.config.is_chiihou and melds:
return HandResponse(error=HandCalculator.ERR_CHIIHOU_WITH_MELD)
# raise error only when player wind is defined (and is EAST)
if self.config.is_renhou and self.config.player_wind and self.config.is_dealer:
return HandResponse(error=HandCalculator.ERR_RENHOU_AS_DEALER)
if self.config.is_renhou and self.config.is_tsumo:
return HandResponse(error=HandCalculator.ERR_RENHOU_WITH_TSUMO)
if self.config.is_renhou and melds:
return HandResponse(error=HandCalculator.ERR_RENHOU_WITH_MELD)
if not agari.is_agari(tiles_34, all_melds):
return HandResponse(error=HandCalculator.ERR_HAND_NOT_WINNING)
if not self.config.options.has_double_yakuman:
self.config.yaku.daburu_kokushi.han_closed = 13
self.config.yaku.suuankou_tanki.han_closed = 13
self.config.yaku.daburu_chuuren_poutou.han_closed = 13
self.config.yaku.daisuushi.han_closed = 13
self.config.yaku.daisuushi.han_open = 13
hand_options = self.divider.divide_hand(
tiles_34, melds, use_cache=use_hand_divider_cache)
calculated_hands = []
for hand in hand_options:
is_chiitoitsu = self.config.yaku.chiitoitsu.is_condition_met(hand)
valued_tiles = [
HAKU, HATSU, CHUN, self.config.player_wind,
self.config.round_wind
]
win_groups = self._find_win_groups(win_tile, hand, opened_melds)
for win_group in win_groups:
cost = None
error = None
hand_yaku = []
han = 0
fu_details, fu = fu_calculator.calculate_fu(
hand, win_tile, win_group, self.config, valued_tiles,
melds)
is_pinfu = len(
fu_details) == 1 and not is_chiitoitsu and not is_open_hand
pon_sets = [x for x in hand if is_pon(x)]
kan_sets = [x for x in hand if is_kan(x)]
chi_sets = [x for x in hand if is_chi(x)]
if self.config.is_tsumo:
if not is_open_hand:
hand_yaku.append(self.config.yaku.tsumo)
if is_pinfu:
hand_yaku.append(self.config.yaku.pinfu)
# let's skip hand that looks like chitoitsu, but it contains open sets
if is_chiitoitsu and is_open_hand:
continue
if is_chiitoitsu:
hand_yaku.append(self.config.yaku.chiitoitsu)
is_daisharin = self.config.yaku.daisharin.is_condition_met(
hand, self.config.options.has_daisharin_other_suits)
if self.config.options.has_daisharin and is_daisharin:
self.config.yaku.daisharin.rename(hand)
hand_yaku.append(self.config.yaku.daisharin)
if self.config.options.has_daichisei and self.config.yaku.daichisei.is_condition_met(
hand):
hand_yaku.append(self.config.yaku.daichisei)
is_tanyao = self.config.yaku.tanyao.is_condition_met(hand)
if is_open_hand and not self.config.options.has_open_tanyao:
is_tanyao = False
if is_tanyao:
hand_yaku.append(self.config.yaku.tanyao)
if self.config.is_riichi and not self.config.is_daburu_riichi:
if self.config.is_open_riichi:
hand_yaku.append(self.config.yaku.open_riichi)
else:
hand_yaku.append(self.config.yaku.riichi)
if self.config.is_daburu_riichi:
if self.config.is_open_riichi:
hand_yaku.append(self.config.yaku.daburu_open_riichi)
else:
hand_yaku.append(self.config.yaku.daburu_riichi)
if (not self.config.is_tsumo
and self.config.options.has_sashikomi_yakuman and
((self.config.yaku.daburu_open_riichi in hand_yaku) or
(self.config.yaku.open_riichi in hand_yaku))):
hand_yaku.append(self.config.yaku.sashikomi)
if self.config.is_ippatsu:
hand_yaku.append(self.config.yaku.ippatsu)
if self.config.is_rinshan:
hand_yaku.append(self.config.yaku.rinshan)
if self.config.is_chankan:
hand_yaku.append(self.config.yaku.chankan)
if self.config.is_haitei:
hand_yaku.append(self.config.yaku.haitei)
if self.config.is_houtei:
hand_yaku.append(self.config.yaku.houtei)
if self.config.is_renhou:
if self.config.options.renhou_as_yakuman:
hand_yaku.append(self.config.yaku.renhou_yakuman)
else:
hand_yaku.append(self.config.yaku.renhou)
if self.config.is_tenhou:
hand_yaku.append(self.config.yaku.tenhou)
if self.config.is_chiihou:
hand_yaku.append(self.config.yaku.chiihou)
if self.config.yaku.honitsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.honitsu)
if self.config.yaku.chinitsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chinitsu)
if self.config.yaku.tsuisou.is_condition_met(hand):
hand_yaku.append(self.config.yaku.tsuisou)
if self.config.yaku.honroto.is_condition_met(hand):
hand_yaku.append(self.config.yaku.honroto)
if self.config.yaku.chinroto.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chinroto)
if self.config.yaku.ryuisou.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ryuisou)
if self.config.paarenchan > 0 and not self.config.options.paarenchan_needs_yaku:
# if no yaku is even needed to win on paarenchan and it is paarenchan condition, just add paarenchan
self.config.yaku.paarenchan.set_paarenchan_count(
self.config.paarenchan)
hand_yaku.append(self.config.yaku.paarenchan)
# small optimization, try to detect yaku with chi required sets only if we have chi sets in hand
if len(chi_sets):
if self.config.yaku.chantai.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chantai)
if self.config.yaku.junchan.is_condition_met(hand):
hand_yaku.append(self.config.yaku.junchan)
if self.config.yaku.ittsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ittsu)
if not is_open_hand:
if self.config.yaku.ryanpeiko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ryanpeiko)
elif self.config.yaku.iipeiko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.iipeiko)
if self.config.yaku.sanshoku.is_condition_met(hand):
hand_yaku.append(self.config.yaku.sanshoku)
# small optimization, try to detect yaku with pon required sets only if we have pon sets in hand
if len(pon_sets) or len(kan_sets):
if self.config.yaku.toitoi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.toitoi)
if self.config.yaku.sanankou.is_condition_met(
hand, win_tile, melds, self.config.is_tsumo):
hand_yaku.append(self.config.yaku.sanankou)
if self.config.yaku.sanshoku_douko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.sanshoku_douko)
if self.config.yaku.shosangen.is_condition_met(hand):
hand_yaku.append(self.config.yaku.shosangen)
if self.config.yaku.haku.is_condition_met(hand):
hand_yaku.append(self.config.yaku.haku)
if self.config.yaku.hatsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.hatsu)
if self.config.yaku.chun.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chun)
if self.config.yaku.east.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == EAST:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == EAST:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.south.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == SOUTH:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == SOUTH:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.west.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == WEST:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == WEST:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.north.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == NORTH:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == NORTH:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.daisangen.is_condition_met(hand):
hand_yaku.append(self.config.yaku.daisangen)
if self.config.yaku.shosuushi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.shosuushi)
if self.config.yaku.daisuushi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.daisuushi)
# closed kan can't be used in chuuren_poutou
if not len(
melds
) and self.config.yaku.chuuren_poutou.is_condition_met(
hand):
if tiles_34[win_tile // 4] == 2 or tiles_34[win_tile //
4] == 4:
hand_yaku.append(
self.config.yaku.daburu_chuuren_poutou)
else:
hand_yaku.append(self.config.yaku.chuuren_poutou)
if not is_open_hand and self.config.yaku.suuankou.is_condition_met(
hand, win_tile, self.config.is_tsumo):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(self.config.yaku.suuankou_tanki)
else:
hand_yaku.append(self.config.yaku.suuankou)
if self.config.yaku.sankantsu.is_condition_met(
hand, melds):
hand_yaku.append(self.config.yaku.sankantsu)
if self.config.yaku.suukantsu.is_condition_met(
hand, melds):
hand_yaku.append(self.config.yaku.suukantsu)
if self.config.paarenchan > 0 and self.config.options.paarenchan_needs_yaku and len(
hand_yaku) > 0:
# we waited until here to add paarenchan yakuman only if there is any other yaku
self.config.yaku.paarenchan.set_paarenchan_count(
self.config.paarenchan)
hand_yaku.append(self.config.yaku.paarenchan)
# yakuman is not connected with other yaku
yakuman_list = [x for x in hand_yaku if x.is_yakuman]
if yakuman_list:
if not is_aotenjou:
hand_yaku = yakuman_list
else:
scores_calculator.aotenjou_filter_yaku(
hand_yaku, self.config)
yakuman_list = []
# calculate han
for item in hand_yaku:
if is_open_hand and item.han_open:
han += item.han_open
else:
han += item.han_closed
if han == 0:
error = HandCalculator.ERR_NO_YAKU
cost = None
# we don't need to add dora to yakuman
if not yakuman_list:
tiles_for_dora = tiles[:]
count_of_dora = 0
count_of_aka_dora = 0
for tile in tiles_for_dora:
count_of_dora += plus_dora(tile, dora_indicators)
for tile in tiles_for_dora:
if is_aka_dora(tile, self.config.options.has_aka_dora):
count_of_aka_dora += 1
if count_of_dora:
self.config.yaku.dora.han_open = count_of_dora
self.config.yaku.dora.han_closed = count_of_dora
hand_yaku.append(self.config.yaku.dora)
han += count_of_dora
if count_of_aka_dora:
self.config.yaku.aka_dora.han_open = count_of_aka_dora
self.config.yaku.aka_dora.han_closed = count_of_aka_dora
hand_yaku.append(self.config.yaku.aka_dora)
han += count_of_aka_dora
if not is_aotenjou and (
self.config.options.limit_to_sextuple_yakuman
and han > 78):
han = 78
if fu == 0 and is_aotenjou:
fu = 40
if not error:
cost = scores_calculator.calculate_scores(
han, fu, self.config,
len(yakuman_list) > 0)
calculated_hand = {
"cost": cost,
"error": error,
"hand_yaku": hand_yaku,
"han": han,
"fu": fu,
"fu_details": fu_details,
}
calculated_hands.append(calculated_hand)
# exception hand
if not is_open_hand and self.config.yaku.kokushi.is_condition_met(
None, tiles_34):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(self.config.yaku.daburu_kokushi)
else:
hand_yaku.append(self.config.yaku.kokushi)
if not self.config.is_tsumo and self.config.options.has_sashikomi_yakuman:
if self.config.is_riichi and not self.config.is_daburu_riichi:
if self.config.is_open_riichi:
hand_yaku.append(self.config.yaku.sashikomi)
if self.config.is_daburu_riichi:
if self.config.is_open_riichi:
hand_yaku.append(self.config.yaku.sashikomi)
if self.config.is_renhou and self.config.options.renhou_as_yakuman:
hand_yaku.append(self.config.yaku.renhou_yakuman)
if self.config.is_tenhou:
hand_yaku.append(self.config.yaku.tenhou)
if self.config.is_chiihou:
hand_yaku.append(self.config.yaku.chiihou)
if self.config.paarenchan > 0:
self.config.yaku.paarenchan.set_paarenchan_count(
self.config.paarenchan)
hand_yaku.append(self.config.yaku.paarenchan)
# calculate han
han = 0
for item in hand_yaku:
if is_open_hand and item.han_open:
han += item.han_open
else:
han += item.han_closed
fu = 0
if is_aotenjou:
if self.config.is_tsumo:
fu = 30
else:
fu = 40
tiles_for_dora = tiles[:]
count_of_dora = 0
count_of_aka_dora = 0
for tile in tiles_for_dora:
count_of_dora += plus_dora(tile, dora_indicators)
for tile in tiles_for_dora:
if is_aka_dora(tile, self.config.options.has_aka_dora):
count_of_aka_dora += 1
if count_of_dora:
self.config.yaku.dora.han_open = count_of_dora
self.config.yaku.dora.han_closed = count_of_dora
hand_yaku.append(self.config.yaku.dora)
han += count_of_dora
if count_of_aka_dora:
self.config.yaku.aka_dora.han_open = count_of_aka_dora
self.config.yaku.aka_dora.han_closed = count_of_aka_dora
hand_yaku.append(self.config.yaku.aka_dora)
han += count_of_aka_dora
cost = scores_calculator.calculate_scores(han, fu, self.config,
len(hand_yaku) > 0)
calculated_hands.append({
"cost": cost,
"error": None,
"hand_yaku": hand_yaku,
"han": han,
"fu": fu,
"fu_details": []
})
# let's use cost for most expensive hand
calculated_hands = sorted(calculated_hands,
key=lambda x: (x["han"], x["fu"]),
reverse=True)
calculated_hand = calculated_hands[0]
cost = calculated_hand["cost"]
error = calculated_hand["error"]
hand_yaku = calculated_hand["hand_yaku"]
han = calculated_hand["han"]
fu = calculated_hand["fu"]
fu_details = calculated_hand["fu_details"]
return HandResponse(cost, han, fu, hand_yaku, error, fu_details,
is_open_hand)
def should_go_to_defence_mode(self, discard_candidate=None):
"""
The method is decides should bot go to the defence mode or not.
For now only full defence is possible
:return: true|false
"""
# we drew a tile, so we have 14 tiles in our hand
if discard_candidate:
shanten = discard_candidate.shanten
waiting = discard_candidate.waiting
wanted_tiles_count = discard_candidate.tiles_count
# we have 13 tiles in hand (this is not our turn)
else:
shanten = self.player.ai.previous_shanten
waiting = self.player.ai.waiting
wanted_tiles_count = self.player.ai.wanted_tiles_count
# if we are the top, it's better to defence
# if self.player == self.table.get_players_sorted_by_scores()[0] and self.player.scores > 30000:
# logger.info("Player is at the 1st position, better to fold.")
# return True
# if we are in riichi or meld too much, we can't defence
if self.player.in_riichi or self.player.ai.pushing or len(
self.player.melds) >= 3:
logger.info("In reach or pushing state, cannot defence.")
return False
# if we are the at the 4st position, it's better to push
if self.player == self.table.get_players_sorted_by_scores(
)[-1] and self.table.round_number >= 5:
logger.info("Player is at the 4st position, better to push.")
self.player.ai.pushing = True
self.player.set_state("PUSHING")
return False
threatening_players = self._get_threatening_players()
self.threatening_players = threatening_players # assign this for further calculation in other methods
# no one is threatening, so we can build our hand
if len(threatening_players) == 0:
return False
else:
#logger.info("There are some threatening players! Now shanten is {}".format(shanten))
pass
# more than 2 players are threatening, so defense is better
#if len(threatening_players) >= 2:
# logger.info("Watch those players feed each other!")
# return True
if shanten == 1:
# # When player is in 4th position, it's better to push in this situation
# if self.player == self.table.get_players_sorted_by_scores()[-1]:
# logger.info("Player is in 4th position, better to push.")
# return False
# TODO calculate all possible hand costs for 1-2 shanten
dora_count = sum([
plus_dora(x, self.table.dora_indicators)
for x in self.player.tiles
])
# aka dora
dora_count += sum([
1 for x in self.player.tiles
if is_aka_dora(x, self.table.has_open_tanyao)
])
# we had 3+ dora in our almost done hand,
# we can try to push it
if dora_count >= 3:
return False
# our hand is not tempai, so better to fold it
if shanten != 0:
#logger.info("Not prepared, ready to fold.")
return True
# we are in tempai, if there are so many melds, don't go to defence
# if len(self.player.melds) >= 2:
# logger.info("Too many melds, should push.")
# return False
# we are in tempai, let's try to estimate hand value
hands_estimated_cost = []
call_riichi = not self.player.is_open_hand
for tile in waiting:
# copy of tiles, because we are modifying a list
tiles = self.player.tiles[:]
# special case, when we already have 14 tiles in the hand
if discard_candidate:
temp_tile = discard_candidate.find_tile_in_hand(
self.player.closed_hand)
tiles.remove(temp_tile)
hand_result = self.player.ai.estimate_hand_value(
tile, tiles, call_riichi)
if hand_result.error is None:
hands_estimated_cost.append(hand_result.cost['main'])
# probably we are with opened hand without yaku, let's fold it
if not hands_estimated_cost:
logger.info("This hand cannot win, fold it.")
return True
# Get the hand value
hand_value = sum(hands_estimated_cost) / len(hands_estimated_cost)
hand_value += self.table.count_of_riichi_sticks * 1000
if self.player.is_dealer:
hand_value += 700 # EV for dealer combo
# EH: makes the calculation of hand value better by adding the remaining tile count
# Get the shape for attacking
hand_shape = "bad_shape"
if wanted_tiles_count > 4:
hand_shape = "good_shape"
# Check whether the player is in proactive mode
if "PROACTIVE" in self.player.play_state:
hand_shape = "pro_" + hand_shape
# Get the current hand index
hand_index = len(self.player.discards)
# Get the type of threatening player
counter_player_type = "player"
if threatening_players[0].is_dealer:
counter_player_type = "dealer"
score_ev = hand_value - COUNTER_VALUES[
counter_player_type] * COUNTER_RATIO[hand_shape][hand_index]
rank_ev = self.get_rank_ev(hand_value,
COUNTER_VALUES[counter_player_type],
COUNTER_RATIO[hand_shape][hand_index])
should_counter = False
if self.table.round_number < 3: # DEBUG: set this to 0 to debug rank ev calculation
# Before Round East 4, use score ev
if score_ev > 0:
should_counter = True
else:
if rank_ev > 0:
should_counter = True
elif rank_ev == 0 and score_ev > 0:
should_encounter = True
logger.info('''Cowboy: Counter:
Hand Value: {} Hand Shape: {}
Hand Index: {} Counter Player Type: {}
Score EV: {} Rank EV: {}
Should Counter: {}'''.format(hand_value, hand_shape, hand_index,
counter_player_type, score_ev,
rank_ev, should_counter))
if should_counter:
# set state
self.player.ai.waiting = waiting
self.player.ai.wanted_tiles_count = wanted_tiles_count
if self.player.play_state in ["PREPARING", "DEFENCE"]:
if hand_shape == "good_shape":
self.player.set_state("REACTIVE_GOODSHAPE")
else:
self.player.set_state("REACTIVE_BADSHAPE")
if self.player != self.table.get_players_sorted_by_scores()[0]:
# When player is on the top, no need to push, else push it
self.player.ai.pushing = True
return False
else:
return True
# our open hand in tempai, but it is cheap
# so we can fold it
# if self.player.is_open_hand and max_cost < 7000:
# return True
# when we call riichi we can get ura dora,
# so it is reasonable to riichi 3k+ hands
# if not self.player.is_open_hand:
# # there are a lot of chances that we will not win with a bad wait
# # against other threatening players
# if max_cost < 3000 or len(waiting) < 2:
# return True
return False
def is_dora(self, tile):
return plus_dora(tile, self.dora_indicators) or is_aka_dora(tile, self.has_open_tanyao)
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
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:
# 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)
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
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
# we will decrease tile value
discard_percentage = [100, 75, 20, 0, 0]
discarded_tiles = self.player.table.revealed_tiles[
self.tile_to_discard]
value = (value * discard_percentage[discarded_tiles]) / 100
# three honor tiles were discarded,
# so we don't need this tile anymore
if value == 0:
self.had_to_be_discarded = True
self.valuation = int(value)
def is_dora(self, tile):
return plus_dora(tile, self.dora_indicators) or is_aka_dora(tile, self.has_open_tanyao)
def prepare_closed_hand_input(
round_wind,
dora_indicators,
player_closed_hand,
player_melds,
player_discards,
tenpai_player_wind,
tenpai_player_riichi,
tenpai_player_melds,
tenpai_player_discards,
second_player_melds,
second_player_discards,
third_player_melds,
third_player_discards,
):
"""
meld dict format = {
'tiles': List of 136 format tiles
}
discard dict format = {
'tile': 136 format,
'is_tsumogiri': bool,
'is_after_meld': bool,
}
:param round_wind: 27 (east), 28 (south), 29 (west), 30 (north)
:param dora_indicators: List of 136 format tiles
:param player_closed_hand: Our player. List of 136 format tiles
:param player_melds: Our player. List of meld dicts
:param player_discards: Our player. List of discard dicts
:param tenpai_player_wind: 27 (east), 28 (south), 29 (west), 30 (north)
:param tenpai_player_riichi: bool
:param tenpai_player_melds: Tenpai player. List of meld dicts
:param tenpai_player_discards: Tenpai player. List of discard dicts
:param second_player_melds: Second player. List of meld dicts
:param second_player_discards: Second player. List of discard dicts
:param third_player_melds: Third player. List of meld dicts
:param third_player_discards: Third player. List of discard dicts
:return: list of 0 and 1 values
"""
tiles_unique = 34
max_dora_in_hand = 8
max_dora_on_the_table = 16 + 3
winds_input_size = 8
tenpai_player_discards_input = [0 for _ in range(tiles_unique)]
tenpai_player_melds_input = [1 for _ in range(tiles_unique)]
winds_input = [0 for _ in range(winds_input_size)]
dora_in_player_open_melds_input = [0 for _ in range(max_dora_in_hand)]
not_visible_dora_on_the_table_input = [
0 for _ in range(max_dora_on_the_table)
]
for discard_dict in tenpai_player_discards:
tile = discard_dict['tile'] // 4
tenpai_player_discards_input[tile] = 1
for meld in tenpai_player_melds:
tiles = meld['tiles']
for tile in tiles:
tile = tile // 4
tenpai_player_melds_input[tile] = 1
out_tiles_136 = []
for tile_136 in player_closed_hand:
out_tiles_136.append(tile_136)
for tile_136 in dora_indicators:
out_tiles_136.append(tile_136)
discards = [
player_discards, tenpai_player_discards, second_player_discards,
third_player_discards
]
for discards_list in discards:
for x in discards_list:
# we will add this tile in melds loop
if x['was_taken_for_meld']:
continue
out_tiles_136.append(x['tile'])
melds = [
player_melds, tenpai_player_melds, second_player_melds,
third_player_melds
]
for meld_list in melds:
for x in meld_list:
out_tiles_136.extend(x['tiles'])
out_tiles = [0 for _ in range(tiles_unique)]
for x in out_tiles_136:
tile = x // 4
out_tiles[tile] += 1
assert out_tiles[tile] <= 4
out_tiles_0 = [1 if x >= 1 else 0 for x in out_tiles]
out_tiles_1 = [1 if x >= 2 else 0 for x in out_tiles]
out_tiles_2 = [1 if x >= 3 else 0 for x in out_tiles]
out_tiles_3 = [1 if x == 4 else 0 for x in out_tiles]
if round_wind == EAST:
winds_input[0] = 1
elif round_wind == SOUTH:
winds_input[1] = 1
elif round_wind == WEST:
winds_input[2] = 1
elif round_wind == NORTH:
winds_input[3] = 1
if tenpai_player_wind == EAST:
winds_input[4] = 1
elif tenpai_player_wind == SOUTH:
winds_input[5] = 1
elif tenpai_player_wind == WEST:
winds_input[6] = 1
elif tenpai_player_wind == NORTH:
winds_input[7] = 1
number_of_dora_in_player_open_melds = 0
player_melds = tenpai_player_melds
for meld in player_melds:
for tile in meld['tiles']:
number_of_dora_in_player_open_melds += plus_dora(
tile, dora_indicators)
if is_aka_dora(tile, True):
number_of_dora_in_player_open_melds += 1
if number_of_dora_in_player_open_melds > max_dora_in_hand:
number_of_dora_in_player_open_melds = max_dora_in_hand
for i in range(max_dora_in_hand):
if i + 1 <= number_of_dora_in_player_open_melds:
dora_in_player_open_melds_input[i] = 1
visible_dora = 0
for visible_tile in out_tiles:
visible_dora += plus_dora(visible_tile, dora_indicators)
if is_aka_dora(visible_tile, True):
visible_dora += 1
not_visible_dora = max_dora_on_the_table - visible_dora
for i in range(max_dora_on_the_table):
if i + 1 <= not_visible_dora:
not_visible_dora_on_the_table_input[i] = 1
return list(
itertools.chain(
winds_input,
not_visible_dora_on_the_table_input,
dora_in_player_open_melds_input,
tenpai_player_discards_input,
tenpai_player_melds_input,
out_tiles_0,
out_tiles_1,
out_tiles_2,
out_tiles_3,
))
def is_dora(self, tile):
return plus_dora(tile, self.dora_indicators) or is_aka_dora(tile)
def estimate_hand_value(self,
tiles,
win_tile,
is_tsumo=False,
is_riichi=False,
is_dealer=False,
is_ippatsu=False,
is_rinshan=False,
is_chankan=False,
is_haitei=False,
is_houtei=False,
is_daburu_riichi=False,
is_nagashi_mangan=False,
is_tenhou=False,
is_renhou=False,
is_chiihou=False,
open_sets=None,
dora_indicators=None,
called_kan_indices=None,
player_wind=None,
round_wind=None):
"""
:param tiles: array with 14 tiles in 136-tile format
:param win_tile: tile that caused win (ron or tsumo)
:param is_tsumo:
:param is_riichi:
:param is_dealer:
:param is_ippatsu:
:param is_rinshan:
:param is_chankan:
:param is_haitei:
:param is_houtei:
:param is_tenhou:
:param is_renhou:
:param is_chiihou:
:param is_daburu_riichi:
:param is_nagashi_mangan:
:param open_sets: array of array with open sets in 136-tile format
:param dora_indicators: array of tiles in 136-tile format
:param called_kan_indices: array of tiles in 136-tile format
:param player_wind: index of player wind
:param round_wind: index of round wind
:return: The dictionary with hand cost or error response
{"cost": {'main': 1000, 'additional': 0}, "han": 1, "fu": 30, "error": None, "hand_yaku": []}
{"cost": None, "han": 0, "fu": 0, "error": "Hand is not valid", "hand_yaku": []}
"""
if not open_sets:
open_sets = []
else:
# cast 136 format to 34 format
for item in open_sets:
item[0] //= 4
item[1] //= 4
item[2] //= 4
is_open_hand = len(open_sets) > 0
if not dora_indicators:
dora_indicators = []
kan_indices_136 = []
if not called_kan_indices:
called_kan_indices = []
else:
kan_indices_136 = called_kan_indices
called_kan_indices = [x // 4 for x in called_kan_indices]
agari = Agari()
cost = None
error = None
hand_yaku = []
han = 0
fu = 0
def return_response():
return {
'cost': cost,
'error': error,
'han': han,
'fu': fu,
'hand_yaku': hand_yaku
}
# special situation
if is_nagashi_mangan:
hand_yaku.append(yaku.nagashi_mangan)
fu = 30
han = yaku.nagashi_mangan.han['closed']
cost = self.calculate_scores(han, fu, is_tsumo, is_dealer)
return return_response()
if win_tile not in tiles:
error = "Win tile not in the hand"
return return_response()
if is_riichi and is_open_hand:
error = "Riichi can't be declared with open hand"
return return_response()
if is_ippatsu and is_open_hand:
error = "Ippatsu can't be declared with open hand"
return return_response()
if is_ippatsu and not is_riichi and not is_daburu_riichi:
error = "Ippatsu can't be declared without riichi"
return return_response()
tiles_34 = TilesConverter.to_34_array(tiles)
divider = HandDivider()
if not agari.is_agari(tiles_34):
error = 'Hand is not winning'
return return_response()
hand_options = divider.divide_hand(tiles_34, open_sets,
called_kan_indices)
calculated_hands = []
for hand in hand_options:
cost = None
error = None
hand_yaku = []
han = 0
fu = 0
if is_tsumo or is_open_hand:
fu += 20
else:
fu += 30
pon_sets = [x for x in hand if is_pon(x)]
chi_sets = [x for x in hand if is_chi(x)]
additional_fu = self.calculate_additional_fu(
win_tile, hand, is_tsumo, player_wind, round_wind, open_sets,
called_kan_indices)
if additional_fu == 0 and len(chi_sets) == 4:
"""
- A hand without pon and kan sets, so it should contains all sequences and a pair
- The pair should be not valued
- The waiting must be an open wait (on 2 different tiles)
- Hand should be closed
"""
if is_open_hand:
fu += 2
is_pinfu = False
else:
is_pinfu = True
else:
fu += additional_fu
is_pinfu = False
if is_tsumo:
if not is_open_hand:
hand_yaku.append(yaku.tsumo)
# pinfu + tsumo always is 20 fu
if not is_pinfu:
fu += 2
if is_pinfu:
hand_yaku.append(yaku.pinfu)
is_chitoitsu = self.is_chitoitsu(hand)
# let's skip hand that looks like chitoitsu, but it contains open sets
if is_chitoitsu and is_open_hand:
continue
if is_chitoitsu:
hand_yaku.append(yaku.chiitoitsu)
is_tanyao = self.is_tanyao(hand)
if is_open_hand and not settings.OPEN_TANYAO:
is_tanyao = False
if is_tanyao:
hand_yaku.append(yaku.tanyao)
if is_riichi and not is_daburu_riichi:
hand_yaku.append(yaku.riichi)
if is_daburu_riichi:
hand_yaku.append(yaku.daburu_riichi)
if is_ippatsu:
hand_yaku.append(yaku.ippatsu)
if is_rinshan:
hand_yaku.append(yaku.rinshan)
if is_chankan:
hand_yaku.append(yaku.chankan)
if is_haitei:
hand_yaku.append(yaku.haitei)
if is_houtei:
hand_yaku.append(yaku.houtei)
if is_renhou:
hand_yaku.append(yaku.renhou)
if is_tenhou:
hand_yaku.append(yaku.tenhou)
if is_chiihou:
hand_yaku.append(yaku.chiihou)
if self.is_honitsu(hand):
hand_yaku.append(yaku.honitsu)
if self.is_chinitsu(hand):
hand_yaku.append(yaku.chinitsu)
if self.is_tsuisou(hand):
hand_yaku.append(yaku.tsuisou)
if self.is_honroto(hand):
hand_yaku.append(yaku.honroto)
if self.is_chinroto(hand):
hand_yaku.append(yaku.chinroto)
# small optimization, try to detect yaku with chi required sets only if we have chi sets in hand
if len(chi_sets):
if self.is_chanta(hand):
hand_yaku.append(yaku.chanta)
if self.is_junchan(hand):
hand_yaku.append(yaku.junchan)
if self.is_ittsu(hand):
hand_yaku.append(yaku.ittsu)
if not is_open_hand:
if self.is_ryanpeiko(hand):
hand_yaku.append(yaku.ryanpeiko)
elif self.is_iipeiko(hand):
hand_yaku.append(yaku.iipeiko)
if self.is_sanshoku(hand):
hand_yaku.append(yaku.sanshoku)
# small optimization, try to detect yaku with pon required sets only if we have pon sets in hand
if len(pon_sets):
if self.is_toitoi(hand):
hand_yaku.append(yaku.toitoi)
if self.is_sanankou(win_tile, hand, open_sets, is_tsumo):
hand_yaku.append(yaku.sanankou)
if self.is_sanshoku_douko(hand):
hand_yaku.append(yaku.sanshoku_douko)
if self.is_shosangen(hand):
hand_yaku.append(yaku.shosangen)
if self.is_haku(hand):
hand_yaku.append(yaku.haku)
if self.is_hatsu(hand):
hand_yaku.append(yaku.hatsu)
if self.is_chun(hand):
hand_yaku.append(yaku.hatsu)
if self.is_east(hand, player_wind, round_wind):
if player_wind == EAST:
hand_yaku.append(yaku.yakuhai_place)
if round_wind == EAST:
hand_yaku.append(yaku.yakuhai_round)
if self.is_south(hand, player_wind, round_wind):
if player_wind == SOUTH:
hand_yaku.append(yaku.yakuhai_place)
if round_wind == SOUTH:
hand_yaku.append(yaku.yakuhai_round)
if self.is_west(hand, player_wind, round_wind):
if player_wind == WEST:
hand_yaku.append(yaku.yakuhai_place)
if round_wind == WEST:
hand_yaku.append(yaku.yakuhai_round)
if self.is_north(hand, player_wind, round_wind):
if player_wind == NORTH:
hand_yaku.append(yaku.yakuhai_place)
if round_wind == NORTH:
hand_yaku.append(yaku.yakuhai_round)
if self.is_daisangen(hand):
hand_yaku.append(yaku.daisangen)
if self.is_shosuushi(hand):
hand_yaku.append(yaku.shosuushi)
if self.is_daisuushi(hand):
hand_yaku.append(yaku.daisuushi)
if self.is_ryuisou(hand):
hand_yaku.append(yaku.ryuisou)
if not is_open_hand and self.is_chuuren_poutou(hand):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(yaku.daburu_chuuren_poutou)
else:
hand_yaku.append(yaku.chuuren_poutou)
if not is_open_hand and self.is_suuankou(
win_tile, hand, is_tsumo):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(yaku.suuankou_tanki)
else:
hand_yaku.append(yaku.suuankou)
if self.is_sankantsu(hand, called_kan_indices):
hand_yaku.append(yaku.sankantsu)
if self.is_suukantsu(hand, called_kan_indices):
hand_yaku.append(yaku.suukantsu)
# chitoitsu is always 25 fu
if is_chitoitsu:
fu = 25
tiles_for_dora = tiles + kan_indices_136
count_of_dora = 0
count_of_aka_dora = 0
for tile in tiles_for_dora:
count_of_dora += plus_dora(tile, dora_indicators)
for tile in tiles_for_dora:
if is_aka_dora(tile):
count_of_aka_dora += 1
if count_of_dora:
yaku_item = yaku.dora
yaku_item.han['open'] = count_of_dora
yaku_item.han['closed'] = count_of_dora
hand_yaku.append(yaku_item)
if count_of_aka_dora:
yaku_item = yaku.aka_dora
yaku_item.han['open'] = count_of_aka_dora
yaku_item.han['closed'] = count_of_aka_dora
hand_yaku.append(yaku_item)
# yakuman is not connected with other yaku
yakuman_list = [x for x in hand_yaku if x.is_yakuman]
if yakuman_list:
hand_yaku = yakuman_list
# calculate han
for item in hand_yaku:
if is_open_hand and item.han['open']:
han += item.han['open']
else:
han += item.han['closed']
# round up
# 22 -> 30 and etc.
if fu != 25:
fu = int(math.ceil(fu / 10.0)) * 10
if han == 0 or (han == 1 and fu < 30):
error = 'Not valid han ({0}) and fu ({1})'.format(han, fu)
cost = None
else:
cost = self.calculate_scores(han, fu, is_tsumo, is_dealer)
calculated_hand = {
'cost': cost,
'error': error,
'hand_yaku': hand_yaku,
'han': han,
'fu': fu
}
calculated_hands.append(calculated_hand)
# exception hand
if not is_open_hand and self.is_kokushi(tiles_34):
if tiles_34[win_tile // 4] == 2:
han = yaku.daburu_kokushi.han['closed']
else:
han = yaku.kokushi.han['closed']
fu = 0
cost = self.calculate_scores(han, fu, is_tsumo, is_dealer)
calculated_hands.append({
'cost': cost,
'error': None,
'hand_yaku': [yaku.kokushi],
'han': han,
'fu': fu
})
# let's use cost for most expensive hand
calculated_hands = sorted(calculated_hands,
key=lambda x: (x['han'], x['fu']),
reverse=True)
calculated_hand = calculated_hands[0]
cost = calculated_hand['cost']
error = calculated_hand['error']
hand_yaku = calculated_hand['hand_yaku']
han = calculated_hand['han']
fu = calculated_hand['fu']
return return_response()
def estimate_hand_value(self,
tiles,
win_tile,
melds=None,
dora_indicators=None,
config=None):
"""
:param tiles: array with 14 tiles in 136-tile format
:param win_tile: 136 format tile that caused win (ron or tsumo)
:param melds: array with Meld objects
:param dora_indicators: array of tiles in 136-tile format
:param config: HandConfig object
:return: HandResponse object
"""
if not melds:
melds = []
if not dora_indicators:
dora_indicators = []
self.config = config or HandConfig()
agari = Agari()
hand_yaku = []
scores_calculator = ScoresCalculator()
tiles_34 = TilesConverter.to_34_array(tiles)
divider = HandDivider()
fu_calculator = FuCalculator()
opened_melds = [x.tiles_34 for x in melds if x.opened]
all_melds = [x.tiles_34 for x in melds]
is_open_hand = len(opened_melds) > 0
# special situation
if self.config.is_nagashi_mangan:
hand_yaku.append(self.config.yaku.nagashi_mangan)
fu = 30
han = self.config.yaku.nagashi_mangan.han_closed
cost = scores_calculator.calculate_scores(han, fu, self.config,
False)
return HandResponse(cost, han, fu, hand_yaku)
if win_tile not in tiles:
return HandResponse(error="Win tile not in the hand")
if self.config.is_riichi and is_open_hand:
return HandResponse(
error="Riichi can't be declared with open hand")
if self.config.is_ippatsu and is_open_hand:
return HandResponse(
error="Ippatsu can't be declared with open hand")
if self.config.is_ippatsu and not self.config.is_riichi and not self.config.is_daburu_riichi:
return HandResponse(
error="Ippatsu can't be declared without riichi")
if not agari.is_agari(tiles_34, all_melds):
return HandResponse(error='Hand is not winning')
if not self.config.options.has_double_yakuman:
self.config.yaku.daburu_kokushi.han_closed = 13
self.config.yaku.suuankou_tanki.han_closed = 13
self.config.yaku.daburu_chuuren_poutou.han_closed = 13
self.config.yaku.daisuushi.han_closed = 13
self.config.yaku.daisuushi.han_open = 13
hand_options = divider.divide_hand(tiles_34, melds)
calculated_hands = []
for hand in hand_options:
is_chiitoitsu = self.config.yaku.chiitoitsu.is_condition_met(hand)
valued_tiles = [
HAKU, HATSU, CHUN, self.config.player_wind,
self.config.round_wind
]
win_groups = self._find_win_groups(win_tile, hand, opened_melds)
for win_group in win_groups:
cost = None
error = None
hand_yaku = []
han = 0
fu_details, fu = fu_calculator.calculate_fu(
hand, win_tile, win_group, self.config, valued_tiles,
melds)
is_pinfu = len(
fu_details) == 1 and not is_chiitoitsu and not is_open_hand
pon_sets = [x for x in hand if is_pon(x)]
chi_sets = [x for x in hand if is_chi(x)]
if self.config.is_tsumo:
if not is_open_hand:
hand_yaku.append(self.config.yaku.tsumo)
if is_pinfu:
hand_yaku.append(self.config.yaku.pinfu)
# let's skip hand that looks like chitoitsu, but it contains open sets
if is_chiitoitsu and is_open_hand:
continue
if is_chiitoitsu:
hand_yaku.append(self.config.yaku.chiitoitsu)
is_daisharin = self.config.yaku.daisharin.is_condition_met(
hand, self.config.options.has_daisharin_other_suits)
if self.config.options.has_daisharin and is_daisharin:
self.config.yaku.daisharin.rename(hand)
hand_yaku.append(self.config.yaku.daisharin)
is_tanyao = self.config.yaku.tanyao.is_condition_met(hand)
if is_open_hand and not self.config.options.has_open_tanyao:
is_tanyao = False
if is_tanyao:
hand_yaku.append(self.config.yaku.tanyao)
if self.config.is_riichi and not self.config.is_daburu_riichi:
hand_yaku.append(self.config.yaku.riichi)
if self.config.is_daburu_riichi:
hand_yaku.append(self.config.yaku.daburu_riichi)
if self.config.is_ippatsu:
hand_yaku.append(self.config.yaku.ippatsu)
if self.config.is_rinshan:
hand_yaku.append(self.config.yaku.rinshan)
if self.config.is_chankan:
hand_yaku.append(self.config.yaku.chankan)
if self.config.is_haitei:
hand_yaku.append(self.config.yaku.haitei)
if self.config.is_houtei:
hand_yaku.append(self.config.yaku.houtei)
if self.config.is_renhou:
if self.config.options.renhou_as_yakuman:
hand_yaku.append(self.config.yaku.renhou_yakuman)
else:
hand_yaku.append(self.config.yaku.renhou)
if self.config.is_tenhou:
hand_yaku.append(self.config.yaku.tenhou)
if self.config.is_chiihou:
hand_yaku.append(self.config.yaku.chiihou)
if self.config.yaku.honitsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.honitsu)
if self.config.yaku.chinitsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chinitsu)
if self.config.yaku.tsuisou.is_condition_met(hand):
hand_yaku.append(self.config.yaku.tsuisou)
if self.config.yaku.honroto.is_condition_met(hand):
hand_yaku.append(self.config.yaku.honroto)
if self.config.yaku.chinroto.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chinroto)
# small optimization, try to detect yaku with chi required sets only if we have chi sets in hand
if len(chi_sets):
if self.config.yaku.chanta.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chanta)
if self.config.yaku.junchan.is_condition_met(hand):
hand_yaku.append(self.config.yaku.junchan)
if self.config.yaku.ittsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ittsu)
if not is_open_hand:
if self.config.yaku.ryanpeiko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ryanpeiko)
elif self.config.yaku.iipeiko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.iipeiko)
if self.config.yaku.sanshoku.is_condition_met(hand):
hand_yaku.append(self.config.yaku.sanshoku)
# small optimization, try to detect yaku with pon required sets only if we have pon sets in hand
if len(pon_sets):
if self.config.yaku.toitoi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.toitoi)
if self.config.yaku.sanankou.is_condition_met(
hand, win_tile, melds, self.config.is_tsumo):
hand_yaku.append(self.config.yaku.sanankou)
if self.config.yaku.sanshoku_douko.is_condition_met(hand):
hand_yaku.append(self.config.yaku.sanshoku_douko)
if self.config.yaku.shosangen.is_condition_met(hand):
hand_yaku.append(self.config.yaku.shosangen)
if self.config.yaku.haku.is_condition_met(hand):
hand_yaku.append(self.config.yaku.haku)
if self.config.yaku.hatsu.is_condition_met(hand):
hand_yaku.append(self.config.yaku.hatsu)
if self.config.yaku.chun.is_condition_met(hand):
hand_yaku.append(self.config.yaku.chun)
if self.config.yaku.east.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == EAST:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == EAST:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.south.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == SOUTH:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == SOUTH:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.west.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == WEST:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == WEST:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.north.is_condition_met(
hand, self.config.player_wind,
self.config.round_wind):
if self.config.player_wind == NORTH:
hand_yaku.append(self.config.yaku.yakuhai_place)
if self.config.round_wind == NORTH:
hand_yaku.append(self.config.yaku.yakuhai_round)
if self.config.yaku.daisangen.is_condition_met(hand):
hand_yaku.append(self.config.yaku.daisangen)
if self.config.yaku.shosuushi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.shosuushi)
if self.config.yaku.daisuushi.is_condition_met(hand):
hand_yaku.append(self.config.yaku.daisuushi)
if self.config.yaku.ryuisou.is_condition_met(hand):
hand_yaku.append(self.config.yaku.ryuisou)
# closed kan can't be used in chuuren_poutou
if not len(
melds
) and self.config.yaku.chuuren_poutou.is_condition_met(
hand):
if tiles_34[win_tile // 4] == 2 or tiles_34[win_tile //
4] == 4:
hand_yaku.append(
self.config.yaku.daburu_chuuren_poutou)
else:
hand_yaku.append(self.config.yaku.chuuren_poutou)
if not is_open_hand and self.config.yaku.suuankou.is_condition_met(
hand, win_tile, self.config.is_tsumo):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(self.config.yaku.suuankou_tanki)
else:
hand_yaku.append(self.config.yaku.suuankou)
if self.config.yaku.sankantsu.is_condition_met(
hand, melds):
hand_yaku.append(self.config.yaku.sankantsu)
if self.config.yaku.suukantsu.is_condition_met(
hand, melds):
hand_yaku.append(self.config.yaku.suukantsu)
# yakuman is not connected with other yaku
yakuman_list = [x for x in hand_yaku if x.is_yakuman]
if yakuman_list:
hand_yaku = yakuman_list
# calculate han
for item in hand_yaku:
if is_open_hand and item.han_open:
han += item.han_open
else:
han += item.han_closed
if han == 0:
error = 'There are no yaku in the hand'
cost = None
# we don't need to add dora to yakuman
if not yakuman_list:
tiles_for_dora = tiles[:]
# we had to search for dora in kan fourth tiles as well
for meld in melds:
if meld.type == Meld.KAN or meld.type == Meld.CHANKAN:
tiles_for_dora.append(meld.tiles[3])
count_of_dora = 0
count_of_aka_dora = 0
for tile in tiles_for_dora:
count_of_dora += plus_dora(tile, dora_indicators)
for tile in tiles_for_dora:
if is_aka_dora(tile, self.config.options.has_aka_dora):
count_of_aka_dora += 1
if count_of_dora:
self.config.yaku.dora.han_open = count_of_dora
self.config.yaku.dora.han_closed = count_of_dora
hand_yaku.append(self.config.yaku.dora)
han += count_of_dora
if count_of_aka_dora:
self.config.yaku.aka_dora.han_open = count_of_aka_dora
self.config.yaku.aka_dora.han_closed = count_of_aka_dora
hand_yaku.append(self.config.yaku.aka_dora)
han += count_of_aka_dora
if not error:
cost = scores_calculator.calculate_scores(
han, fu, self.config,
len(yakuman_list) > 0)
calculated_hand = {
'cost': cost,
'error': error,
'hand_yaku': hand_yaku,
'han': han,
'fu': fu,
'fu_details': fu_details
}
calculated_hands.append(calculated_hand)
# exception hand
if not is_open_hand and self.config.yaku.kokushi.is_condition_met(
None, tiles_34):
if tiles_34[win_tile // 4] == 2:
hand_yaku.append(self.config.yaku.daburu_kokushi)
else:
hand_yaku.append(self.config.yaku.kokushi)
if self.config.is_renhou and self.config.options.renhou_as_yakuman:
hand_yaku.append(self.config.yaku.renhou_yakuman)
if self.config.is_tenhou:
hand_yaku.append(self.config.yaku.tenhou)
if self.config.is_chiihou:
hand_yaku.append(self.config.yaku.chiihou)
# calculate han
han = 0
for item in hand_yaku:
if is_open_hand and item.han_open:
han += item.han_open
else:
han += item.han_closed
fu = 0
cost = scores_calculator.calculate_scores(han, fu, self.config,
len(hand_yaku) > 0)
calculated_hands.append({
'cost': cost,
'error': None,
'hand_yaku': hand_yaku,
'han': han,
'fu': fu,
'fu_details': []
})
# let's use cost for most expensive hand
calculated_hands = sorted(calculated_hands,
key=lambda x: (x['han'], x['fu']),
reverse=True)
calculated_hand = calculated_hands[0]
cost = calculated_hand['cost']
error = calculated_hand['error']
hand_yaku = calculated_hand['hand_yaku']
han = calculated_hand['han']
fu = calculated_hand['fu']
fu_details = calculated_hand['fu_details']
return HandResponse(cost, han, fu, hand_yaku, error, fu_details)
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
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:
# 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)
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
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
# we will decrease tile value
discard_percentage = [100, 75, 20, 0, 0]
discarded_tiles = self.player.table.revealed_tiles[self.tile_to_discard]
value = (value * discard_percentage[discarded_tiles]) / 100
# three honor tiles were discarded,
# so we don't need this tile anymore
if value == 0:
self.had_to_be_discarded = True
self.valuation = int(value)
def should_activate_strategy(self):
"""
Tanyao hand is a hand without terminal and honor tiles, to achieve this
we will use different approaches
:return: boolean
"""
result = super(TanyaoStrategy, self).should_activate_strategy()
if not result:
return False
# Get count of dora
dora_count = sum([
plus_dora(x, self.player.table.dora_indicators)
for x in self.player.tiles
])
# aka dora
dora_count += sum([
1 for x in self.player.tiles
if is_aka_dora(x, self.player.table.has_open_tanyao)
])
# Get shanten
shanten = self.player.ai.previous_shanten
# Get hand index
hand_index = len(self.player.discards)
#if not ((dora_count >= 1) or (shanten <= 1 and hand_index >= 8) or self.player.is_dealer):
# return False
if len(self.player.discards) <= 4:
#Do not activate it too early
return False
tiles = TilesConverter.to_34_array(self.player.tiles)
count_of_terminal_pon_sets = 0
count_of_terminal_pairs = 0
count_of_valued_pairs = 0
for x in range(0, 34):
tile = tiles[x]
if not tile:
continue
if x in self.not_suitable_tiles and tile == 3:
count_of_terminal_pon_sets += 1
if x in self.not_suitable_tiles and tile == 2:
count_of_terminal_pairs += 1
if x in self.player.valued_honors:
count_of_valued_pairs += 1
# if we already have pon of honor\terminal tiles
# we don't need to open hand for tanyao
if count_of_terminal_pon_sets > 0:
return False
# with valued pair (yakuhai wind or dragon)
# we don't need to go for tanyao
if count_of_valued_pairs > 0:
return False
# no pair is ok in tanyao pair
# but 1+ pairs can't be suitable
#if count_of_terminal_pairs >= 1:
# return False
# 1234 and 9876 indices
indices = [
[0, 1, 2, 3],
[8, 7, 6, 5],
[9, 10, 11, 12],
[17, 16, 15, 14],
[18, 19, 20, 21],
[26, 25, 24, 23],
]
num_terminal_lugs = 0
for index_set in indices:
first = int(tiles[index_set[0]] >= 1)
second = int(tiles[index_set[1]] >= 1)
third = int(tiles[index_set[2]] >= 1)
fourth = int(tiles[index_set[3]] >= 1)
if ((first + second >= 2) or (first + third >= 2) or
(second + third >= 2)) and fourth == 0:
num_terminal_lugs += 1
if first + second + third >= 3:
num_terminal_lugs += 2
num_terminal_lugs += count_of_terminal_pairs
if num_terminal_lugs > 1:
return False
return True
def is_dora(self, tile):
"""
tile in 136 format
"""
return plus_dora(tile, self.dora_indicators) or is_aka_dora(tile, True)
def should_go_to_defence_mode(self, discard_candidate=None):
"""
The method is decides should bot go to the defence mode or not.
For now only full defence is possible
:return: true|false
"""
# we drew a tile, so we have 14 tiles in our hand
if discard_candidate:
shanten = discard_candidate.shanten
waiting = discard_candidate.waiting
# we have 13 tiles in hand (this is not our turn)
else:
shanten = self.player.ai.shanten
waiting = self.player.ai.waiting
if not waiting:
waiting = []
# if we are in riichi, we can't defence
if self.player.in_riichi:
return False
threatening_players = self._get_threatening_players()
# no one is threatening, so we can build our hand
if len(threatening_players) == 0:
return False
if shanten == 1:
# TODO calculate all possible hand costs for 1-2 shanten
dora_count = sum([
plus_dora(x, self.table.dora_indicators)
for x in self.player.tiles
])
# aka dora
dora_count += sum([
1 for x in self.player.tiles
if is_aka_dora(x, self.table.has_open_tanyao)
])
# we had 3+ dora in our almost done hand,
# we can try to push it
if dora_count >= 3:
return False
# our hand is not tempai, so better to fold it
if shanten != 0:
return True
# we are in tempai, let's try to estimate hand value
hands_estimated_cost = []
call_riichi = not self.player.is_open_hand
for tile in waiting:
# copy of tiles, because we are modifying a list
tiles = self.player.tiles[:]
# special case, when we already have 14 tiles in the hand
if discard_candidate:
temp_tile = discard_candidate.find_tile_in_hand(
self.player.closed_hand)
tiles.remove(temp_tile)
hand_result = self.player.ai.estimate_hand_value(
tile, tiles, call_riichi)
if hand_result.error is None:
hands_estimated_cost.append(hand_result.cost['main'])
# probably we are with opened hand without yaku, let's fold it
if not hands_estimated_cost:
return True
max_cost = max(hands_estimated_cost)
# our open hand in tempai, but it is cheap
# so we can fold it
if self.player.is_open_hand and max_cost < 7000:
return True
# when we call riichi we can get ura dora,
# so it is reasonable to riichi 3k+ hands
if not self.player.is_open_hand:
# there are a lot of chances that we will not win with a bad wait
# against other threatening players
if max_cost < 3000 or len(waiting) < 2:
return True
return False
def should_go_to_defence_mode(self, discard_candidate=None):
"""
The method is decides should bot go to the defence mode or not.
For now only full defence is possible
:return: true|false
"""
# we drew a tile, so we have 14 tiles in our hand
if discard_candidate:
shanten = discard_candidate.shanten
waiting = discard_candidate.waiting
# we have 13 tiles in hand (this is not our turn)
else:
shanten = self.player.ai.shanten
waiting = self.player.ai.waiting
if not waiting:
waiting = []
# if we are in riichi, we can't defence
if self.player.in_riichi:
return False
threatening_players = self._get_threatening_players()
# no one is threatening, so we can build our hand
if len(threatening_players) == 0:
return False
if shanten == 1:
# TODO calculate all possible hand costs for 1-2 shanten
dora_count = sum([plus_dora(x, self.table.dora_indicators) for x in self.player.tiles])
# aka dora
dora_count += sum([1 for x in self.player.tiles if is_aka_dora(x, self.table.has_open_tanyao)])
# we had 3+ dora in our almost done hand,
# we can try to push it
if dora_count >= 3:
return False
# our hand is not tempai, so better to fold it
if shanten != 0:
return True
# we are in tempai, let's try to estimate hand value
hands_estimated_cost = []
call_riichi = not self.player.is_open_hand
for tile in waiting:
# copy of tiles, because we are modifying a list
tiles = self.player.tiles[:]
# special case, when we already have 14 tiles in the hand
if discard_candidate:
temp_tile = discard_candidate.find_tile_in_hand(self.player.closed_hand)
tiles.remove(temp_tile)
hand_result = self.player.ai.estimate_hand_value(tile, tiles, call_riichi)
if hand_result.error is None:
hands_estimated_cost.append(hand_result.cost['main'])
# probably we are with opened hand without yaku, let's fold it
if not hands_estimated_cost:
return True
max_cost = max(hands_estimated_cost)
# our open hand in tempai, but it is cheap
# so we can fold it
if self.player.is_open_hand and max_cost < 7000:
return True
# when we call riichi we can get ura dora,
# so it is reasonable to riichi 3k+ hands
if not self.player.is_open_hand:
# there are a lot of chances that we will not win with a bad wait
# against other threatening players
if max_cost < 3000 or len(waiting) < 2:
return True
return False
