def getCanWinTiles(self, handTiles, win_op, idx):
handCopyTiles = list(handTiles)
handCopyTiles = sorted(handCopyTiles)
kings, handTilesButKing = utility.classifyKingTiles(
handCopyTiles, self.kingTiles)
kingTilesNum = len(kings)
allTiles = const.CHARACTER + const.BAMBOO + const.DOT + const.WINDS + const.DRAGONS
canWinTiles = []
for tile in allTiles:
handCopyTiles.append(tile)
is_win, _, _ = self.can_win(handCopyTiles, tile, win_op, idx)
if is_win:
canWinTiles.append(tile)
handCopyTiles.pop()
DEBUG_MSG(
"room:{},curround:{} getCanWinTiles idx:{} canWinTiles:{}".format(
self.roomID, self.current_round, idx, canWinTiles))
return canWinTiles
def can_win(self, handTiles, finalTile, win_op, idx):
#"""平胡 爆头 七对子 清七对"""
#"""杠 + 飘"""
result_list = [0] * 4
multiply = 0
if len(handTiles) % 3 != 2:
DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, self.base_score * (2**multiply), result_list
if win_op == const.OP_WREATH_WIN:
DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, 2 ** multiply, result_list
if win_op == const.OP_GIVE_WIN and finalTile in self.kingTiles:
DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, 2 ** multiply, result_list
p = self.players_list[idx]
handCopyTiles = list(handTiles)
handCopyTiles = sorted(handCopyTiles)
kings, handTilesButKing = utility.classifyKingTiles(handCopyTiles, self.kingTiles)
kingTilesNum = len(kings)
# 白板代替财神
if len(self.kingTiles) > 0:
handTilesButKing = list(map(lambda x:self.kingTiles[0] if x == const.DRAGON_WHITE else x, handTilesButKing))
insteadFinalTile = self.kingTiles[0] if finalTile == const.DRAGON_WHITE else finalTile
else:
insteadFinalTile = finalTile
handTilesButKing = sorted(handTilesButKing)
#2N
is7Pair, isBaoTou, kongNum = utility.checkIs7Pair(handCopyTiles, handTilesButKing, kingTilesNum, self.kingTiles, insteadFinalTile)
if is7Pair:
DEBUG_MSG("room:{},curround:{} is7Pair".format(self.roomID, self.current_round))
result_list[2] = 1 + kongNum
multiply += result_list[2]
if isBaoTou:
result_list[1] = 1
kingKongList = [1 if op == const.OP_DISCARD else -1 for op in utility.serialKingKong(p.op_r, self.kingTiles)]
multiply += len(kingKongList) + 1
result_list.extend(kingKongList)
DEBUG_MSG("room:{},curround:{} is7Pair baotou".format(self.roomID, self.current_round))
return True , self.base_score * (2 ** multiply), result_list
elif kingTilesNum <= 0:
result_list[3] = 1
multiply += 1
DEBUG_MSG("room:{},curround:{} is7Pair not baotou kingNum:0".format(self.roomID, self.current_round))
return True, self.base_score * (2 ** multiply), result_list
if self.bao_tou == 0:
return True, self.base_score * (2**multiply), result_list
#3N2
result_list = [0] * 4
multiply = 0
if kingTilesNum <= 0: #无财神(只要满足能胡就可以胡)
DEBUG_MSG("room:{},curround:{} kingTilesNum <= 0".format(self.roomID, self.current_round))
if utility.meld_with_pair_need_num(handTilesButKing) <= kingTilesNum:
result_list[0] = 1
for op in utility.serialKingKong(p.op_r, self.kingTiles): #只有连续杠开
if op != const.OP_DISCARD:
result_list.append(-1)
multiply += 1
else:
break
DEBUG_MSG("room:{},curround:{} 3N2 kingNum:0".format(self.roomID, self.current_round))
return True, self.base_score * (2**multiply), result_list
DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, self.base_score * (2**multiply), result_list
else: #有财神(只要暴头都可以胡, 如果有财必暴，非暴头不能胡)
# 除去暴头一对组成3N
baotou_n3_list = []
tryKingsNum = kingTilesNum
if finalTile in self.kingTiles: # 最后一张 摸的是财神
if tryKingsNum >= 2:
tryKingsNum -= 2
baotou_n3_list.append(list(handTilesButKing))
else:
tryKingsNum -= 1
tryList = list(handTilesButKing)
tryList.remove(insteadFinalTile) # 若最后一张不是财神 则用代替后的牌
baotou_n3_list.append(tryList)
DEBUG_MSG("room:{},curround:{} baotou_n3_list:{}".format(self.roomID, self.current_round, baotou_n3_list))
#优先尝试暴头
for tryList in baotou_n3_list:
if utility.getMeldNeed(tryList) <= tryKingsNum:
result_list[1] = 1
# 连续飘杠胜利
kingKongList = [1 if op == const.OP_DISCARD else -1 for op in utility.serialKingKong(p.op_r, self.kingTiles)]
multiply += len(kingKongList) + 1
result_list.extend(kingKongList)
DEBUG_MSG("room:{},curround:{} 3N baotou".format(self.roomID, self.current_round))
return True, self.base_score * (2 ** multiply), result_list
else:
DEBUG_MSG("room:{},curround:{} try not baotou".format(self.roomID, self.current_round))
if self.bao_tou == 0 and utility.winWith3N2NeedKing(handTilesButKing) <= kingTilesNum:
result_list[0] = 1
# 连续杠胜利
for op in utility.serialKingKong(p.op_r, self.kingTiles): # 只有连续杠开
if op != const.OP_DISCARD:
result_list.append(-1)
multiply += 1
else:
break
DEBUG_MSG("room:{},curround:{} 3N not baotou".format(self.roomID, self.current_round))
return True, self.base_score * (2 ** multiply), result_list
DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, self.base_score * (2 ** multiply), result_list
def can_win(self, handTiles, finalTile, win_op, idx):
#"""0自摸 1点炮 2抢杠 3明杠 4暗杠 5庄家 6边张 7砍张 8吊将 9缺门 10清一色 11一条龙 12清龙"""
result_list = [0] * 13
base_score = 1
p = self.players_list[idx]
if p.state == const.DISCARD_FREE:
DEBUG_MSG(
"room:{},curround:{} 0 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
if len(handTiles) % 3 != 2:
DEBUG_MSG(
"room:{},curround:{} 1 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
if win_op == const.OP_WREATH_WIN:
DEBUG_MSG(
"room:{},curround:{} 2 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
# DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
handCopyTiles = list(handTiles)
handCopyTiles = sorted(handCopyTiles)
kings, handTilesButKing = utility.classifyKingTiles(
handCopyTiles, self.kingTiles)
kingTilesNum = len(kings)
uptiles = p.upTiles
#3N2
if kingTilesNum <= 0: #无财神(只要满足能胡就可以胡)
if utility.meld_with_pair_need_num(
handTilesButKing) <= kingTilesNum:
result_list[0] = 1 if win_op == const.OP_DRAW_WIN else 0
# result_list[1] = 1 if win_op == const.OP_GIVE_WIN else 0
# result_list[2] = 1 if win_op == const.OP_KONG_WIN else 0
exposed_kong_num = sum(
[1 for op in p.op_r if op[0] == const.OP_EXPOSED_KONG])
concealed_kong_num = sum(
[1 for op in p.op_r if op[0] == const.OP_CONCEALED_KONG])
continue_kong_num = sum(
[1 for op in p.op_r if op[0] == const.OP_CONTINUE_KONG])
if exposed_kong_num > 0 or continue_kong_num > 0: # 明杠
result_list[3] = 1
if concealed_kong_num > 0: # 暗杠
result_list[4] = 1
if p.idx == self.dealer_idx: # 庄家
result_list[5] = 1
base_score += 1
result_list[6], result_list[7], result_list[
8] = utility.checkIsEdgeMidSingle(handTilesButKing,
finalTile)
if len(p.canWinTiles) != 1:
result_list[6] = 0
result_list[7] = 0
result_list[8] = 0
if result_list[6] == 1 or result_list[7] == 1 or result_list[
8] == 1: # 边张 砍张 吊将
base_score += 1
colorType = utility.getTileColorType(handTilesButKing, uptiles)
if colorType == const.LACK_DOOR: # 缺门
result_list[9] = 1
base_score += 1
if self.same_suit_mode == 1 and colorType == const.SAME_SUIT: # 清一色
result_list[10] = 1
base_score += 10
if utility.checkIsOneDragon(handTilesButKing): # 一条龙
result_list[11] = 1
base_score += 10
if self.same_suit_loong == 1 and result_list[
10] == 1 and result_list[11] == 1: # 清龙
result_list[12] = 1
DEBUG_MSG("room:{},curround:{} 3N2 result_list:{}".format(
self.roomID, self.current_round, result_list))
return True, (
base_score *
[2 if result_list[0] == 1 else 1][0]), result_list
DEBUG_MSG(
"room:{},curround:{} 3 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
def can_win(self, handTiles, finalTile, win_op, idx):
#"""平胡 四财神 爆头 七对子 碰碰胡 清一色 乱风 清风 天胡 地胡 十三不搭 海底捞月"""
#"""杠 + 飘"""
is_win = False
is_bao_tou = False
result_list = [0] * 12
score = 0
DEBUG_MSG("{} {}".format(self.prefixLogStr, "****begin***" * 5))
DEBUG_MSG(
"{} idx:{} win_op:{} handTiles:{} upTiles:{} finalTile:{}".format(
self.prefixLogStr, idx, win_op, handTiles,
self.players_list[idx].upTiles, finalTile))
if len(handTiles) % 3 != 2:
return is_win, score, result_list
if win_op == const.OP_WREATH_WIN:
return False, score, result_list
p = self.players_list[idx]
upTiles = p.upTiles
handCopyTiles = list(handTiles)
handCopyTiles = sorted(handCopyTiles)
kings, handTilesButKing = utility.classifyKingTiles(
handCopyTiles, self.kingTiles)
kingTilesNum = len(kings)
handTilesButKing = sorted(handTilesButKing)
def cut_list(lis, mid=0): # 截取数组 到小于或者 大于 某个值为止
min_list = []
max_list = []
for x in lis:
if x < mid:
min_list.append(x)
else:
break
for x in lis:
if x > mid:
max_list.append(x)
else:
break
return min_list, max_list
def not_bao_tou_3n2(op_r, handTilesButKing, kingTilesNum, upTiles,
result_list):
sum_score = 0
if utility.winWith3N2NeedKing(handTilesButKing) <= kingTilesNum:
# 只有连续杠开
kingKongList = [
1 if op == const.OP_DISCARD else -1
for op in utility.serialKingKong(op_r, self.kingTiles)
]
# 截取全部是 -1 的数组（杠）
min_list, _ = cut_list(kingKongList)
sum_score += len(min_list) * 2
result_list.extend(min_list)
# 碰碰胡
if utility.isPongPongWin3N2(handTilesButKing, kingTilesNum,
upTiles):
sum_score += 2
result_list[4] = 1
elif len(min_list) <= 0:
result_list[0] = 1
return True, sum_score
return False, sum_score
def bao_tou_3n(op_r, tryList, tryKingsNum, upTiles, result_list):
sum_score = 0
if utility.getMeldNeed(tryList) <= tryKingsNum:
result_list[2] = 1
# 连续飘杠胜利
kingKongList = [
1 if op == const.OP_DISCARD else -1
for op in utility.serialKingKong(op_r, self.kingTiles)
]
sum_score += (len(kingKongList) + 1) * 2
result_list.extend(kingKongList)
# 碰碰胡
if utility.isPongPongWin3N(tryList, tryKingsNum, upTiles):
sum_score += 2
result_list[4] = 1
return True, sum_score
return False, sum_score
# 十三不搭
not_match_mode = utility.isThirteenNotMatch(handCopyTiles,
self.kingTiles)
if not_match_mode > 0:
is_win = True
result_list[10] = not_match_mode
DEBUG_MSG("{} thirteenNotMatch match mode:{}".format(
self.prefixLogStr, not_match_mode))
if not_match_mode == const.MATCH_NOT_STANDARD:
score += 1
elif not_match_mode == const.MATCH_NOT_STANDARD_7STAR:
score += 2
elif not_match_mode == const.MATCH_STANDARD:
score += 2
else:
score += 4
else:
# 可能满足7对 也满足 平胡 条件的牌
# 2N
is7Pair, isBaoTou, _ = utility.checkIs7Pair(
handCopyTiles, handTilesButKing, kingTilesNum, self.kingTiles,
finalTile)
if is7Pair:
score += 2
result_list[3] = 1
is_win = True
DEBUG_MSG("{} 7Pair".format(self.prefixLogStr))
if isBaoTou:
is_bao_tou = True
result_list[2] = 1
# 连续 飘财
kingKongList = [
1 if op == const.OP_DISCARD else -1
for op in utility.serialKingKong(
p.op_r, self.kingTiles)
]
result_list.extend(kingKongList)
score += (len(kingKongList) + 1) * 2
DEBUG_MSG("{} 7Pair baotou ".format(self.prefixLogStr))
else:
# 3N2
if kingTilesNum <= 0:
is_win, sum_score = not_bao_tou_3n2(
p.op_r, handTilesButKing, kingTilesNum, upTiles,
result_list)
score += sum_score if is_win else 0
DEBUG_MSG(
"{} 3N2 kingTilesNum <= 0 is_win:{} sum_score:{}".
format(self.prefixLogStr, is_win, sum_score))
else:
baotou_n3_list = []
tryKingsNum = kingTilesNum
if finalTile in self.kingTiles: # 最后一张 摸的是财神
if tryKingsNum >= 2:
tryKingsNum -= 2
baotou_n3_list.append(list(handTilesButKing))
else:
tryKingsNum -= 1
tryList = list(handTilesButKing)
tryList.remove(finalTile) # 若最后一张不是财神 则用代替后的牌
baotou_n3_list.append(tryList)
DEBUG_MSG("{} baotou_n3_list:{}".format(
self.prefixLogStr, baotou_n3_list))
# 优先尝试暴头
for tryList in baotou_n3_list:
is_win, sum_score = bao_tou_3n(p.op_r, tryList,
tryKingsNum, upTiles,
result_list)
if is_win:
is_bao_tou = True
score += sum_score
DEBUG_MSG("{} 3N baotou sum_score:{}".format(
self.prefixLogStr, sum_score))
break
else:
is_win, sum_score = not_bao_tou_3n2(
p.op_r, handTilesButKing, kingTilesNum, upTiles,
result_list)
score += sum_score if is_win else 0
DEBUG_MSG(
"{} 3N2 notbaotou is_win:{} sum_score:{}".format(
self.prefixLogStr, is_win, sum_score))
# 是否是清一色(必须是 2N 3N2 胡法 十三幺不存在清一色)
if is_win and utility.isAllSameCBDSuit(handTilesButKing,
upTiles): # 清一色
result_list[0] = 0
result_list[5] = 2
score += 10 if win_op == const.OP_GIVE_WIN else 8
DEBUG_MSG("{} qingyise".format(self.prefixLogStr))
elif is_win and len(
self.job_relation(idx)) > 0 and utility.isAllUpMeldCBDSuit(
upTiles): # 门前清 承包
result_list[5] = 1
score += 8 if win_op == const.OP_DRAW_WIN else 10
DEBUG_MSG("{} menqianqing".format(self.prefixLogStr))
if win_op == const.OP_GIVE_WIN:
# 门前清 不能放炮胡
return False, score, result_list
elif utility.isAllWindsDragons(handTilesButKing, upTiles): # 全字
result_list[0] = 0
is_win = True
if sum([i if i >= 0 else abs(i)
for i in result_list]) > 0: # 清风
result_list[7] = 1
score += 20
DEBUG_MSG("{} qingfeng".format(self.prefixLogStr))
else:
result_list[6] = 1 # 若不是清风 必定是乱风
score += 10
DEBUG_MSG("{} luanfeng".format(self.prefixLogStr))
# 4财神 (额外)
if kingTilesNum == 4:
is_win = True
result_list[1] = 4
# score += 2
DEBUG_MSG("{} hand king 4".format(self.prefixLogStr))
elif is_win:
# 连续 杠飘
if is_bao_tou:
kingKongList = [
1 if op == const.OP_DISCARD else -1
for op in utility.serialKingKong(p.op_r, self.kingTiles)
]
if sum([1 for i in kingKongList if i > 0]) + kingTilesNum == 4:
result_list[1] = 4
# score += 2
DEBUG_MSG("{} hand king {} allking {}".format(
self.prefixLogStr, kingTilesNum,
sum([1 for i in kingKongList if i > 0]) + kingTilesNum))
# 满足胡的条件下
if is_win:
# 天胡
if idx == self.dealer_idx and win_op == const.OP_DRAW_WIN and len(
p.op_r) == 1:
score += 10
result_list[8] = 1
result_list[0] = 0
DEBUG_MSG("{} tianhu".format(self.prefixLogStr))
# 地胡
elif idx != self.dealer_idx and win_op == const.OP_GIVE_WIN and len(
self.all_discard_tiles) == 1:
score += 10
result_list[9] = 1
result_list[0] = 0
DEBUG_MSG("{} dihu".format(self.prefixLogStr))
# 海底捞月
elif win_op == const.OP_DRAW_WIN and len(
self.tiles) <= self.end_tile_num:
score += 2
result_list[11] = 1
result_list[0] = 0
DEBUG_MSG("{} haidilaoyue".format(self.prefixLogStr))
# 如果只有 平胡 还要 算 1分
if result_list[0] == 1 and sum([1
for i in result_list if i != 0]) == 1:
score += 1
# 能不能放炮 抢杠 条件筛选
# 放炮胡 和 抢杠胡的条件是一样的， 只有大于等于2分以上的牌才可以放炮、抢杠，并且财神头不能 放炮、抢杠 除了清一色 清风 乱风 这三种财神头
DEBUG_MSG("{} all score {}, all result_list:{}".format(
self.prefixLogStr, score, result_list))
DEBUG_MSG("{} {}".format(self.prefixLogStr, "****end***" * 5))
if win_op == const.OP_KONG_WIN:
score = max(2, score)
if is_bao_tou and result_list[5] <= 0 and result_list[
6] <= 0 and result_list[7] <= 0:
return False, score, result_list
if win_op == const.OP_GIVE_WIN:
if score < 2:
return False, score, result_list
if is_bao_tou and result_list[5] <= 0 and result_list[
6] <= 0 and result_list[7] <= 0:
return False, score, result_list
return is_win, score, result_list
def can_win(self, handTiles, finalTile, win_op, idx):
#"""平胡 清一色 七小对 豪华七小对 一条龙 十三幺"""
result_list = [0] * 6
base_score = 0
# return False, multiply, result_list
p = self.players_list[idx]
if p.state == const.DISCARD_FREE:
# DEBUG_MSG("room:{},curround:{} 0 handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
return False, base_score, result_list
DEBUG_MSG("room:{},curround:{} state:{} idx:{}".format(
self.roomID, self.current_round, p.state, idx))
if self.pass_win_list[idx] == 1 and win_op != const.OP_DRAW_WIN:
DEBUG_MSG(
"room:{},curround:{} 00 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
if len(handTiles) % 3 != 2:
DEBUG_MSG(
"room:{},curround:{} 1 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
if win_op == const.OP_WREATH_WIN:
DEBUG_MSG(
"room:{},curround:{} 2 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
# if win_op == const.OP_GIVE_WIN and finalTile in self.kingTiles:
# DEBUG_MSG("room:{},curround:{} handTiles:{} finalTile:{} win_op:{} idx:{}".format(self.roomID, self.current_round, handTiles, finalTile, win_op, idx))
# return False, base_score, result_list
if self.is_win_limit(finalTile, win_op) == False:
return False, base_score, result_list
handCopyTiles = list(handTiles)
handCopyTiles = sorted(handCopyTiles)
kings, handTilesButKing = utility.classifyKingTiles(
handCopyTiles, self.kingTiles)
kingTilesNum = len(kings)
uptiles = p.upTiles
if finalTile in self.kingTiles:
for winTile in self.canWinTiles:
if winTile in self.kingTiles:
continue
if winTile > const.BOUNDARY:
base_score = 10
break
elif base_score < winTile % 10:
base_score = winTile % 10
elif finalTile > const.BOUNDARY:
base_score = 10
else:
base_score = finalTile % 10
#十三幺
if self.game_mode == const.SPECIAL_GAME_MODE:
if utility.getThirteenOrphans(handTilesButKing, kingTilesNum):
# if self.is_win_limit(finalTile, win_op) == False:
# return False , base_score, result_list
result_list[5] = 1
DEBUG_MSG("room:{},curround:{} isThirteenOrphans".format(
self.roomID, self.current_round))
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
#2N
result_list = [0] * 6
is7Pair, isBaoTou, kongNum = utility.checkIs7Pair(
handCopyTiles, handTilesButKing, kingTilesNum, self.kingTiles,
finalTile)
if is7Pair:
DEBUG_MSG(
"room:{},curround:{} is7Pair isBaoTou:{} kongNum:{}".format(
self.roomID, self.current_round, isBaoTou, kongNum))
result_list[2] = 1
if kongNum > 0:
result_list[3] = 1
if isBaoTou and self.king_num == 1:
if win_op != const.OP_DRAW_WIN:
return False, base_score, result_list
# kingKongList = [1 if op == const.OP_DISCARD else -1 for op in utility.serialKingKong(p.op_r, self.kingTiles)]
# result_list.extend(kingKongList)
DEBUG_MSG("room:{},curround:{} is7Pair diaojiang".format(
self.roomID, self.current_round))
if self.game_mode != const.SPECIAL_GAME_MODE:
return True, 20, result_list
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
elif kingTilesNum <= 0:
DEBUG_MSG(
"room:{},curround:{} is7Pair not diaojiang kingNum:0".
format(self.roomID, self.current_round))
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
DEBUG_MSG(
"room:{},curround:{} is7Pair not diaojiang kingNum>0".format(
self.roomID, self.current_round))
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
#3N2
result_list = [0] * 6
if kingTilesNum <= 0: #无财神(只要满足能胡就可以胡)
DEBUG_MSG("room:{},curround:{} kingTilesNum <= 0".format(
self.roomID, self.current_round))
if utility.meld_with_pair_need_num(
handTilesButKing) <= kingTilesNum:
# if self.is_win_limit(finalTile, win_op) == False:
# return False , base_score, result_list
if self.game_mode == const.SPECIAL_GAME_MODE:
if utility.getTileColorType(handTilesButKing,
uptiles) == const.SAME_SUIT:
result_list[1] = 1
elif utility.checkIsOneDragon(handTilesButKing):
result_list[4] = 1
else:
result_list[0] = 1
DEBUG_MSG("room:{},curround:{} 3N2 kingNum:0".format(
self.roomID, self.current_round))
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
DEBUG_MSG(
"room:{},curround:{} 3 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list
else: #有财神
if utility.winWith3N2NeedKing(handTilesButKing) <= kingTilesNum:
result_list[0] = 1
DEBUG_MSG(
"room:{},curround:{} 3N win_op:{} finalTile:{}".format(
self.roomID, self.current_round, win_op, finalTile))
# if self.is_win_limit(finalTile, win_op) == False:
# return False , base_score, result_list
isMouseGeneral = utility.isMouseGeneral(
handTiles, handTilesButKing, kingTilesNum, self.kingTiles,
finalTile)
if isMouseGeneral and win_op != const.OP_DRAW_WIN:
DEBUG_MSG(
"room:{},curround:{} 3N win_op:{} isMouseGeneral:{}".
format(self.roomID, self.current_round, win_op,
isMouseGeneral))
return False, base_score, result_list
elif isMouseGeneral and win_op == const.OP_DRAW_WIN:
return True, 20, result_list
return True, (base_score + utility.multiplyCalc(
self.game_mode, win_op, result_list)) * [
2 if win_op == const.OP_DRAW_WIN else 1
][0], result_list
DEBUG_MSG(
"room:{},curround:{} 4 handTiles:{} finalTile:{} win_op:{} idx:{}"
.format(self.roomID, self.current_round, handTiles, finalTile,
win_op, idx))
return False, base_score, result_list