def can_play_normal_cards(self, cards, idx):
DEBUG_MSG("can_nomal_play_cards")
discardType = utility.getNormalCardsType(utility.rightShiftCards(cards))
controllerType = utility.getNormalCardsType(utility.rightShiftCards(self.controller_discard_list))
if discardType == 0 or discardType == 1:
DEBUG_MSG("error discard type.")
return False
#自由出牌
if self.controller_idx == idx: #其他玩家要不起 ,如果牌打完 controller_idx 转移到了 对家身上
DEBUG_MSG("free to play.")
return True
#牌型 判断是否 压过前一次出的牌
DEBUG_MSG("controllerType:{0},discardType:{1}.".format(controllerType, discardType))
if controllerType == discardType:
return utility.cmpSameTypeCards(utility.rightShiftCards(self.controller_discard_list), utility.rightShiftCards(cards), discardType)
else:
if controllerType < 8 and discardType < 8: #两个非炸弹
return False
elif controllerType < 8 and discardType >= 8 : #炸普通牌
return True
elif discardType < 8 and controllerType >= 8 : #普通牌不能 大过 炸
return False
selBombLine = 0
contrBombLine = 0
if discardType == 8:
selBombLine = len(cards)
elif discardType == 9:
selBombLine = 6
elif discardType == 10:
selBombLine = 7
else:
selBombLine = utility.getSerialBombLine(utility.rightShiftCards(cards))
if controllerType == 8:
contrBombLine = len(self.controller_discard_list)
elif controllerType == 9:
contrBombLine = 6
elif controllerType == 10:
contrBombLine = 7
else:
contrBombLine = utility.getSerialBombLine(utility.rightShiftCards(self.controller_discard_list))
DEBUG_MSG("selBombLine:{0},contrBombLine:{1},cards:{2},controller_discard_list:{3} ".format(selBombLine, contrBombLine,cards,self.controller_discard_list))
if selBombLine > contrBombLine: #线数大
return True
elif selBombLine < contrBombLine: #线数小
return False
else: #线数相等
# 相同线数 连炸 小于 同样数字炸弹
if discardType == 8 and controllerType == 11:
return True
elif discardType == 11 and controllerType == 8:
return False
if len(cards) > len(self.controller_discard_list):
return True
return False
def can_play_cards(self, playerCards, cards, idx, curRound):
if len(cards) <= 0:
return False, cards, 0
if self.game_hei3 == 0 and curRound != 1 and sum(
[len(i) for i in self.players_discard_list]) == 0:
if const.HEI_THREE not in cards:
return False, cards, 1
if not utility.getCanPlay(cards, playerCards, self.game_plays,
self.key_card):
return False, cards, 0
if not self.check_has_card(playerCards, cards):
DEBUG_MSG("palyer not has all cards.")
return False, cards, 0
if self.game_mode == 2:
normalCards, keyCards = utility.classifyCards(cards, self.key_card)
normalCardsShift = utility.rightShiftCards(normalCards)
keyCardsShift = utility.rightShiftCards(keyCards)
if len(normalCards) == 0 and len(keyCards) == 4:
return True, cards, 0
typeList = []
if self.wait_idx == self.controller_idx:
typeList = utility.getInsteadCardsType(normalCardsShift,
keyCardsShift)
else:
controllerType = utility.getNormalCardsType(
utility.rightShiftCards(self.controller_discard_list),
playerCards, len(playerCards), self.game_plays,
self.game_end, 0, self.key_card)
if utility.checkIsKeyCardBomb(normalCardsShift, keyCardsShift):
controllerType = const.TYPE_BOMB
typeList.append(controllerType)
else:
if not utility.IsCardsTypeSame(
normalCardsShift, keyCardsShift, controllerType):
typeList = utility.getInsteadCardsType(
normalCardsShift, keyCardsShift)
else:
typeList.append(controllerType)
DEBUG_MSG("normalCards:{0}, keyCards:{1}".format(
normalCards, keyCards))
DEBUG_MSG("normalCardsShift:{0}, keyCardsShift:{1}".format(
normalCardsShift, keyCardsShift))
DEBUG_MSG("getInsteadCardsType:{0}".format(
utility.getInsteadCardsType(normalCardsShift, keyCardsShift)))
for i in range(len(typeList)):
makeDisCardPoker = utility.makeCard(cards, typeList[i],
self.key_card)
DEBUG_MSG("makeDiscardPoker:{0}".format(makeDisCardPoker))
if self.can_play_normal_cards(makeDisCardPoker, idx,
playerCards):
return True, makeDisCardPoker, 0
else:
if self.can_play_normal_cards(cards, idx, playerCards):
return True, cards, 0
return False, cards, 0
def getTipsCards(self):
selfCards = sorted(self.players_list[self.current_idx].tiles)
selfRightShiftCards = sorted(utility.rightShiftCards(selfCards))
preCards = utility.rightShiftCards(self.controller_discard_list)
preCardsType = utility.getTileType(preCards)
tips = utility.cardSubSort(selfCards)
tips_temp = []
for i in tips:
cardType = utility.getTileType(i)
if cardType == preCardsType and utility.compareTile(i, preCards):
tips_temp.append(i)
elif cardType > preCardsType and cardType == const.TYPE_BOMB:
tips_temp.append(i)
DEBUG_MSG("getTipsCards tips_temp:{}".format(tips_temp))
return tips_temp
def can_play_cards(self, playerCards, cards, idx):
if len(cards) <= 0:
return False, cards
if not self.check_has_card(playerCards, cards):
DEBUG_MSG("palyer not has all cards.")
return False, cards
if self.can_play_normal_cards(cards, idx):
return True, cards
elif self.room_mode == 1:
notJokers, jokers = utility.classifyCards(cards)
notJokerShift = utility.rightShiftCards(notJokers)
jokerShift = utility.rightShiftCards(jokers)
makeDisCardPoker = utility.makeCard(cards, utility.getInsteadCardsType(notJokerShift, jokerShift))
DEBUG_MSG("notJokers:{0}, jokers:{1}".format(notJokers, jokers))
DEBUG_MSG("notJokerShift:{0}, jokerShift:{1}".format(notJokerShift, jokerShift))
DEBUG_MSG("makeDiscardPoker:{}".format(makeDisCardPoker))
if self.can_play_normal_cards(makeDisCardPoker, idx):
return True,makeDisCardPoker
return False, cards
def getTripleTipsSingle(self, idx, minCard):
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getTripleTips cards: {}".format(cards))
if len(cards) != 3:
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
if len(shiftCards2NumDict) == 1:
tipsList.append([cards[0]])
return tipsList
def countCard(self, ard_list, instead_card_list):
cardType = utility.getNormalCardsType(utility.rightShiftCards(instead_card_list))
DEBUG_MSG("countCard:{0}".format(cardType))
if cardType == 8:
line = len(instead_card_list)
self.bombNumDict.setdefault(line, 0)
self.bombNumDict[line] += 1
DEBUG_MSG("8:{0},{1}".format(line, self.bombNumDict))
elif cardType == 9:
self.bombNumDict.setdefault(6, 0)
self.bombNumDict[6] += 1
DEBUG_MSG("9:{0},{1}".format(6, self.bombNumDict))
elif cardType == 10:
self.bombNumDict.setdefault(7, 0)
self.bombNumDict[7] += 1
DEBUG_MSG("10:{0},{1}".format(7, self.bombNumDict))
elif cardType == 11:
card2NumDict = utility.getCard2NumDict(utility.rightShiftCards(instead_card_list))
line = len(card2NumDict) + len(instead_card_list)/len(card2NumDict)
self.bombNumDict.setdefault(line, 0)
self.bombNumDict[line] += 1
DEBUG_MSG("11:{0},{1}".format(line, self.bombNumDict))
def getDoubleTips(self, idx, minCard, isOnlyPair):
# 对子提示
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getDoubleTips cards: {}".format(cards))
if len(cards) + keyCardNum < 2:
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# 仅一对优先
for i in range(len(shiftCards) - 1):
if shiftCards[i] == shiftCards[i + 1] and (
not minCard or shiftCards[i] > minCard
) and shiftCards2NumDict[shiftCards[i]] == 2:
tipsList.append([cards[i], cards[i + 1]])
# 三张
if not isOnlyPair:
for i in range(len(shiftCards) - 1):
if shiftCards[i] == shiftCards[i + 1] and (not minCard or shiftCards[i] > minCard) and \
shiftCards2NumDict[
shiftCards[i]] == 3:
tipsList.append([cards[i], cards[i + 1]])
DEBUG_MSG("dui zi tipsList: {}".format(tipsList))
# 带癞子的情况
keyTipList = []
if self.game_mode == 2 and keyCardNum > 0:
oneKeyList = []
for card in shiftCards2NumDict:
if shiftCards2NumDict[card] == 1 and card > minCard:
oneKeyList.append(card)
if len(oneKeyList) > 0:
for i in range(len(oneKeyList)):
keySuggestList = []
keySuggestList.append(keyCard)
for j in range(len(shiftCards)):
if oneKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
keyTipList.append(keySuggestList)
if keyCardNum >= 2 and (keyCard >> 3) > minCard:
keyTempList = []
keyTempList.append(keyCard)
keyTempList.append(keyCard)
keyTipList.append(keyTempList)
tipsList.extend(keyTipList)
return tipsList
def cal_hand_line(self, cards):
notBigJokers, smallJokers, bigJokers = self.classifyJokerCards(cards)
smallJokerNum = len(smallJokers)
bigJokerNum = len(bigJokers)
card2NumDict = utility.getCard2NumDict(
utility.rightShiftCards(notBigJokers))
serialList, singleList = self.splitBombList(card2NumDict, bigJokerNum)
for i in range(bigJokerNum + 1):
for j in range(len(serialList)):
serial = serialList[j]
for k in range(len(serial) - 3 + 1): #len(serial) 个 减去 k 个组成炸弹
for x in range(k): #左 删除 x, 右 删除 k-x-1
left = x
right = k - x - 1
pass
def getSingleTips(self, idx, minCard, isOnlySingle):
# 单张提示
tipsList = []
allTipsList = []
cards = []
for i, p in enumerate(self.players_list):
if p and i == idx:
cards = copy.deepcopy(p.cards)
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# 单张优先
for i in range(len(shiftCards)):
if (not minCard or shiftCards[i] > minCard
) and shiftCards2NumDict[shiftCards[i]] == 1:
tipsList.append([cards[i]])
allTipsList.append(cards[i] >> 3)
# 对子
if not isOnlySingle:
for i in range(len(shiftCards)):
if (not minCard or shiftCards[i] > minCard
) and shiftCards2NumDict[shiftCards[i]] == 2 and (
shiftCards[i] not in allTipsList):
tipsList.append([cards[i]])
allTipsList.append(cards[i] >> 3)
# 三张
if not isOnlySingle:
for i in range(len(shiftCards)):
if (not minCard or shiftCards[i] > minCard
) and shiftCards2NumDict[shiftCards[i]] == 3 and (
shiftCards[i] not in allTipsList):
tipsList.append([cards[i]])
allTipsList.append(cards[i] >> 3)
DEBUG_MSG("dan zhang tipsList: {0}".format(tipsList))
return tipsList
def getTripleTips(self, idx, minCard):
# 三张提示
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getTripleTips cards: {}".format(cards))
if len(cards) < 3:
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# 炸弹是否可以拆
threeKeyList = []
bomb_open = self.game_plays[3]
for card in shiftCards2NumDict:
if bomb_open == 0 and shiftCards2NumDict[card] == 4:
threeKeyList.append(card)
if shiftCards2NumDict[card] == 3:
threeKeyList.append(card)
threeKeyList = sorted(threeKeyList)
for i in range(len(threeKeyList)):
serialNum = 0
suggestList = []
for j in range(len(shiftCards)):
if serialNum == 3:
break
if threeKeyList[i] == shiftCards[j]:
suggestList.append(cards[j])
serialNum += 1
tipsList.append(suggestList)
# 带癞子的情况
keyTipList = []
if self.game_mode == 2 and keyCardNum > 0:
oneKeyList = []
twoKeyList = []
for card in shiftCards2NumDict:
if card > minCard:
if shiftCards2NumDict[card] == 1:
oneKeyList.append(card)
if shiftCards2NumDict[card] == 2:
twoKeyList.append(card)
if keyCardNum >= 2 and len(oneKeyList) > 0:
for i in range(len(oneKeyList)):
keySuggestList = [keyCard, keyCard]
for j in range(len(shiftCards)):
if oneKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
keyTipList.append(keySuggestList)
if keyCardNum >= 1 and len(twoKeyList) > 0:
for i in range(len(twoKeyList)):
keySuggestList = [keyCard]
for j in range(len(shiftCards)):
if twoKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
keySuggestList.append(cards[j + 1])
break
keyTipList.append(keySuggestList)
if keyCardNum >= 3:
keyTempList = [keyCard, keyCard, keyCard]
keyTipList.append(keyTempList)
tipsList.extend(keyTipList)
DEBUG_MSG("san zhang tipsList: {}".format(tipsList))
return tipsList
def getBombTips(self, idx, controllerCards):
# 炸弹提示
tipsList = []
discardKeyNum = 0
if len(controllerCards) == 0:
bombCard = 0
discardKeyNum = 99
else:
for i in range(len(controllerCards)):
if controllerCards[i] in const.INSTEAD:
discardKeyNum += 1
bombCard = controllerCards[0] >> 3
if discardKeyNum == 4: # 纯癞子炸弹最大
return tipsList
bombKeyList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
DEBUG_MSG("getBombTips cards: {}".format(cards))
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
if self.game_mode == 2 and keyCardNum > 0 and (discardKeyNum > 0
or discardKeyNum == 99):
oneKeyList = []
twoKeyList = []
threeKeyList = []
for card in shiftCards2NumDict:
if card > bombCard:
if shiftCards2NumDict[card] == 1:
oneKeyList.append(card)
if shiftCards2NumDict[card] == 2:
twoKeyList.append(card)
if shiftCards2NumDict[card] == 3:
threeKeyList.append(card)
oneKeyList = sorted(oneKeyList)
twoKeyList = sorted(twoKeyList)
threeKeyList = sorted(threeKeyList)
if keyCardNum >= 1 and len(threeKeyList) > 0:
for i in range(len(threeKeyList)):
keySuggestList = [keyCard]
for j in range(len(shiftCards)):
if threeKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
keySuggestList.append(cards[j + 1])
keySuggestList.append(cards[j + 2])
break
tipsList.append(keySuggestList)
if keyCardNum >= 2 and len(twoKeyList) > 0:
for i in range(len(twoKeyList)):
keySuggestList = [keyCard, keyCard]
for j in range(len(shiftCards)):
if twoKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
keySuggestList.append(cards[j + 1])
break
tipsList.append(keySuggestList)
if keyCardNum >= 3 and len(oneKeyList) > 0:
for i in range(len(oneKeyList)):
keySuggestList = [keyCard, keyCard, keyCard]
for j in range(len(shiftCards)):
if oneKeyList[i] == shiftCards[j]:
keySuggestList.append(cards[j])
tipsList.append(keySuggestList)
shiftCardsKeyList = list(shiftCards2NumDict.keys())
for i in range(len(shiftCardsKeyList)):
if (bombCard < shiftCardsKeyList[i] or discardKeyNum > 0
) and shiftCards2NumDict[shiftCardsKeyList[i]] == 4:
bombKeyList.append(shiftCardsKeyList[i])
for i in range(len(bombKeyList)):
suggestList = []
for j in range(len(shiftCards)):
if bombKeyList[i] == shiftCards[j]:
suggestList.append(cards[j])
tipsList.append(suggestList)
if keyCardNum == 4:
keyList = [keyCard, keyCard, keyCard, keyCard]
tipsList.append(keyList)
DEBUG_MSG("zha dan tipsList: {}".format(tipsList))
return tipsList
def getFourBring(self, idx, controllerCards, bringNum):
minCard = 0
if len(controllerCards) != 0:
controllerDict = utility.getCard2NumDict(controllerCards)
for card in controllerDict:
if controllerDict[card] == 4:
minCard = card
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getFourBring cards: {}".format(cards))
if len(cards) < len(controllerCards):
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
fourCardList = []
for card in shiftCards2NumDict:
if shiftCards2NumDict[card] == 4 and card > minCard:
fourCardList.append(card)
if len(fourCardList) > 0:
cardsBack = []
shiftCardsBack = []
for i in range(len(fourCardList)):
for j in range(len(shiftCards) - 1):
if fourCardList[i] != shiftCards[j]:
shiftCardsBack.append(shiftCards[j])
cardsBack.append(cards[j])
cardsBackDict = utility.getCard2NumDict(shiftCardsBack)
fourBringCardList = []
for i in range(1, 4):
for card in cardsBackDict:
if cardsBackDict[card] == i:
for j in range(len(shiftCards)):
if card == shiftCards[j]:
fourBringCardList.append(cards[j])
if len(fourBringCardList) > 0:
for i in range(len(fourBringCardList) - (bringNum - 1)):
suggestList = []
suggestList.append(fourBringCardList[i])
suggestList.append(fourBringCardList[i + 1])
if bringNum == 3:
suggestList.append(fourBringCardList[i + 2])
for j in range(len(fourCardList)):
tempList = []
for k in range(len(shiftCards)):
if fourCardList[j] == shiftCards[k]:
tempList.append(cards[k])
tempList.extend(suggestList)
tipsList.append(tempList)
# 带癞子的情况 四带二，四带三
if self.game_mode == 2 and keyCardNum > 0:
card2ListDict = utility.getListDict(cards)
for i in range(minCard + 1, 15):
tempList = []
cardsListBack = []
if i not in card2ListDict.keys():
continue
elif (len(card2ListDict[i]) == 1 and keyCardNum >= 3) or (len(
card2ListDict[i]) == 2 and keyCardNum >= 2) or (len(
card2ListDict[i]) == 3 and keyCardNum >= 1):
tempList.extend(card2ListDict[i])
for j in range(4 - len(card2ListDict[i])):
tempList.append(keyCard)
for j in range(4 - len(card2ListDict[i])):
cardsListBack.append(keyCard)
for k in range(len(cards)):
if cards[k] not in tempList:
cardsListBack.append(cards[k])
for j in range(len(cardsListBack) - bringNum + 1):
suggestList = []
suggestList.extend(tempList)
suggestList.append(cardsListBack[j])
suggestList.append(cardsListBack[j + 1])
if bringNum == 3:
suggestList.append(cardsListBack[j + 2])
if len(suggestList) == 6 or len(suggestList) == 7:
tipsList.append(suggestList)
DEBUG_MSG("si dai er huo san :{}".format(tipsList))
return tipsList
def getTipsPlane(self, idx, controllerCards):
minCard = 0
planeCardNum = 0
# 判断飞机的最小牌
if len(controllerCards) != 0:
tripleCardsList = []
controllerDict = utility.getCard2NumDict(controllerCards)
controllerKeyList = list(controllerDict.keys())
planeCardNum = int(len(controllerCards) / 5)
for i in range(len(controllerKeyList)):
if controllerDict[controllerKeyList[i]] >= 3:
tripleCardsList.append(controllerKeyList[i])
tripleCardsList = sorted(tripleCardsList)
for i in range(len(tripleCardsList) - 1):
if (tripleCardsList[i] + 1) == tripleCardsList[i + 1]:
minCard = tripleCardsList[i + 1]
break
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getTipsPlane cards: {}".format(cards))
if len(cards) < len(controllerCards):
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# 手牌三张和四张
threeKeyList = []
fourKeyList = []
tripleList = []
bomb_open = self.game_plays[3]
for card in shiftCards2NumDict:
if minCard < card:
if bomb_open == 0:
if shiftCards2NumDict[card] >= 3:
threeKeyList.append(card)
else:
if shiftCards2NumDict[card] == 3:
threeKeyList.append(card)
if shiftCards2NumDict[card] == 4:
fourKeyList.append(card)
threeKeyList = sorted(threeKeyList)
for i in range(len(threeKeyList) - planeCardNum + 1):
tempList = []
for j in range(1, planeCardNum):
if threeKeyList[i] + j == threeKeyList[i + j]:
if j == 1:
tempList.append(threeKeyList[i])
tempList.append(threeKeyList[i + j])
else:
tempList.append(threeKeyList[i + j])
if len(tempList) == planeCardNum and len(tempList) > 0:
tripleList.append(tempList)
for i in range(len(tripleList)):
suggestList = []
cardsBack = []
shiftCardsBack = []
if len(fourKeyList) != 0 and bomb_open == 1:
for j in range(len(fourKeyList)):
for k in range(len(shiftCards) - 1):
if fourKeyList[j] != shiftCards[k]:
cardsBack.append(cards[k])
shiftCardsBack.append(shiftCards[k])
else:
cardsBack = cards[:]
shiftCardsBack = shiftCards[:]
for j in range(len(tripleList[i])):
tripleNum = 0
for k in range(len(shiftCardsBack) - 1)[::-1]:
if tripleList[i][j] == shiftCardsBack[k]:
suggestList.append(cardsBack[k])
del shiftCardsBack[k]
del cardsBack[k]
tripleNum += 1
if tripleNum == 3:
break
for j in range(len(shiftCardsBack) - planeCardNum * 2 + 1):
bringCardNum = 0
suggestListBack = suggestList[:]
for k in range(j, len(shiftCardsBack)):
suggestListBack.append(cardsBack[k])
bringCardNum += 1
if bringCardNum == 2 * planeCardNum:
break
tipsList.append(suggestListBack)
# 带癞子的情况
if self.game_mode == 2 and keyCardNum > 0:
cardsListBack = []
if len(fourKeyList) != 0 and bomb_open == 1:
for j in range(len(fourKeyList)):
for k in range(len(shiftCards) - 1):
if fourKeyList[j] != shiftCards[k]:
cardsListBack.append(cards[k])
else:
cardsListBack = cards[:]
card2ListDict = utility.getListDict(cardsListBack)
playerCardNum = 0
if self.game_cardnum == 15:
playerCardNum = 13
else:
playerCardNum = 14
for i in range(minCard + 1, playerCardNum):
useKeyCardNum = keyCardNum
pairCardNum = 0
suggestList = []
tripleList = []
cardsList = cardsListBack[:]
for j in range(planeCardNum):
if (i + j) not in card2ListDict.keys():
useKeyCardNum -= 3
pairCardNum += 1
suggestList.append(keyCard)
suggestList.append(keyCard)
suggestList.append(keyCard)
elif len(card2ListDict[i + j]) >= 3:
pairCardNum += 1
suggestList.append(card2ListDict[i + j][0])
suggestList.append(card2ListDict[i + j][1])
suggestList.append(card2ListDict[i + j][2])
tripleList.append(card2ListDict[i + j][0])
tripleList.append(card2ListDict[i + j][1])
tripleList.append(card2ListDict[i + j][2])
elif len(card2ListDict[i + j]) == 2:
useKeyCardNum -= 1
pairCardNum += 1
suggestList.append(card2ListDict[i + j][0])
suggestList.append(card2ListDict[i + j][1])
suggestList.append(keyCard)
tripleList.append(card2ListDict[i + j][0])
tripleList.append(card2ListDict[i + j][1])
elif len(card2ListDict[i + j]) == 1:
useKeyCardNum -= 2
pairCardNum += 1
suggestList.append(card2ListDict[i + j][0])
suggestList.append(keyCard)
suggestList.append(keyCard)
tripleList.append(card2ListDict[i + j][0])
if useKeyCardNum < 0:
pairCardNum -= 1
break
if pairCardNum == planeCardNum and useKeyCardNum != keyCardNum:
for j in range(useKeyCardNum):
cardsList.append(keyCard)
cardsTempList = []
for j in range(len(cardsList)):
if cardsList[j] not in tripleList:
cardsTempList.append(cardsList[j])
for j in range(len(cardsTempList) - planeCardNum * 2):
suggestListBack = suggestList[:]
for k in range(planeCardNum * 2):
suggestListBack.append(cardsTempList[j + k])
suggestListBack = sorted(suggestListBack)
tipsList.append(suggestListBack)
DEBUG_MSG("fei ji tipsList:{}".format(tipsList))
return tipsList
def getTripleBring(self, idx, cardsNum, controllerCards):
tipsList = []
minCard = 2
# 判断上家三带二的坐子(三)
if len(controllerCards) != 0:
controllerDict = utility.getCard2NumDict(controllerCards)
controllerKeyList = sorted(controllerDict.keys())
for i in range(len(controllerKeyList)):
if controllerDict[controllerKeyList[i]] >= 3:
minCard = controllerKeyList[i]
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getTripleBring cards: {}".format(cards))
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# 分离出list中的单张，对子，三张和炸弹
oneKeyList = []
twoKeyList = []
threeKeyList = []
fourKeyList = []
bomb_open = self.game_plays[3]
for card in shiftCards2NumDict:
if minCard < card:
if bomb_open == 0:
if shiftCards2NumDict[card] >= 3:
threeKeyList.append(card)
else:
if shiftCards2NumDict[card] == 3:
threeKeyList.append(card)
if shiftCards2NumDict[card] == 1:
oneKeyList.append(card)
if shiftCards2NumDict[card] == 2:
twoKeyList.append(card)
if shiftCards2NumDict[card] == 4:
fourKeyList.append(card)
# 写出各种三带二的情况
for i in range(len(threeKeyList)):
cardsTemp = []
shiftCardsTemp = []
for j in range(len(shiftCards)):
if threeKeyList[i] != shiftCards[j]:
cardsTemp.append(cards[j])
shiftCardsTemp.append(shiftCards[j])
cardsBack = []
shiftCardsBack = []
if bomb_open == 1 and len(fourKeyList) > 0:
for j in range(len(fourKeyList)):
for k in range(len(shiftCardsTemp)):
if fourKeyList[j] != shiftCardsTemp[k]:
cardsBack.append(cardsTemp[k])
shiftCardsBack.append(shiftCardsTemp[k])
else:
cardsBack = cardsTemp
shiftCardsBack = shiftCardsTemp
suggestList = []
threeNum = 0
for j in range(len(shiftCards)):
if threeKeyList[i] == shiftCards[j]:
suggestList.append(cards[j])
threeNum += 1
if threeNum == 3:
break
bringList = []
for j in range(len(shiftCardsBack) - 1):
tempList = []
tempList.append(cardsBack[j])
tempList.append(cardsBack[j + 1])
bringList.append(tempList)
for j in range(len(bringList)):
suggestListBack = suggestList[:]
suggestListBack.extend(bringList[j])
tipsList.append((suggestListBack))
# 带癞子的情况
if self.game_mode == 2 and keyCardNum > 0:
if len(oneKeyList) > 0 and keyCardNum >= 2:
for i in range(len(oneKeyList)):
shiftCardsTemp = []
cardsTemp = []
for j in range(len(shiftCards)):
if oneKeyList[i] != shiftCards[j]:
cardsTemp.append(cards[j])
shiftCardsTemp.append(shiftCards[j])
shiftCardsBack = []
cardsBack = []
if bomb_open == 1 and len(fourKeyList) > 0:
for j in range(len(fourKeyList)):
for k in range(len(shiftCardsTemp)):
if fourKeyList[j] != shiftCardsTemp[k]:
shiftCardsBack.append(shiftCardsTemp[k])
cardsBack.append(cardsTemp[k])
else:
cardsBack = cardsTemp[:]
shiftCardsBack = shiftCardsTemp[:]
suggestList = []
for j in range(len(shiftCards)):
if oneKeyList[i] == shiftCards[j]:
suggestList.append(cards[j])
suggestList.append(keyCard)
suggestList.append(keyCard)
bringList = []
for j in range(len(shiftCardsBack) - 1):
tempList = []
tempList.append(cardsBack[j])
tempList.append(cardsBack[j + 1])
bringList.append(tempList)
for j in range(len(bringList)):
suggestListBack = suggestList[:]
suggestListBack.extend(bringList[j])
tipsList.append(suggestListBack)
if len(twoKeyList) > 0 and keyCardNum >= 1:
for i in range(len(twoKeyList)):
shiftCardsTemp = []
cardsTemp = []
for j in range(len(shiftCards)):
if twoKeyList[i] != shiftCards[j]:
cardsTemp.append(cards[j])
shiftCardsTemp.append(shiftCards[j])
shiftCardsBack = []
cardsBack = []
if bomb_open == 1 and len(fourKeyList) > 0:
for j in range(len(fourKeyList)):
for k in range(len(shiftCardsTemp)):
if fourKeyList[j] != shiftCardsTemp[k]:
shiftCardsBack.append(shiftCardsTemp[k])
cardsBack.append(cardsTemp[k])
else:
cardsBack = cardsTemp[:]
shiftCardsBack = shiftCardsTemp[:]
suggestList = []
for j in range(len(shiftCards)):
if twoKeyList[i] == shiftCards[j]:
suggestList.append(cards[j])
suggestList.append(keyCard)
bringList = []
for j in range(len(shiftCardsBack) - 1):
tempList = []
tempList.append(cardsBack[j])
tempList.append(cardsBack[j + 1])
bringList.append(tempList)
for j in range(len(bringList)):
suggestListBack = suggestList[:]
suggestListBack.extend(bringList[j])
tipsList.append(suggestListBack)
DEBUG_MSG("san dai er tipsList:{}".format(tipsList))
return tipsList
def getSingleSerialTips(self, idx, serialNum, minCard):
# 顺子提示
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
# DEBUG_MSG("getSingleSerialTips cards: {}".format(cards))
if len(cards) < serialNum:
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# DEBUG_MSG("getSingleSerialTips shiftCards:{}".format(shiftCards))
# 炸弹是否可以拆
cardsBack = []
bomb_open = self.game_plays[3] # 炸弹是否可以拆
if bomb_open == 1:
for i, card in enumerate(shiftCards):
if shiftCards2NumDict[card] < 4:
cardsBack.append(cards[i])
else:
cardsBack = cards[:]
cards2ListDict = utility.getListDict(cardsBack)
# DEBUG_MSG("getSingleSerialTips cards2ListDict:{}".format(cards2ListDict))
# 组成顺子
for i in range((minCard + 1), (14 - serialNum + 1) + 1):
singleSerialNum = 0
for j in range(serialNum):
if (i + j) in cards2ListDict and len(
cards2ListDict[i + j]) >= 1:
singleSerialNum += 1
else:
break
if singleSerialNum >= serialNum:
suggestList = []
for j in range(serialNum):
suggestList.append(cards2ListDict[i + j][0])
tipsList.append(suggestList)
# 带癞子的情况
if self.game_mode == 2 and keyCardNum > 0:
for i in range(minCard + 1, 14 - serialNum + 2):
useKeyCardNum = keyCardNum
singleSerialNum = 0
suggestList = []
for j in range(serialNum):
if (i + j) not in cards2ListDict.keys():
useKeyCardNum -= 1
singleSerialNum += 1
suggestList.append(keyCard)
elif len(cards2ListDict[i + j]) >= 1:
singleSerialNum += 1
suggestList.append(cards2ListDict[i + j][0])
elif len(cards2ListDict[i + j]) < 1:
useKeyCardNum -= 1
singleSerialNum += 1
suggestList.append(keyCard)
if useKeyCardNum < 0:
singleSerialNum -= 1
break
if singleSerialNum == serialNum and useKeyCardNum != keyCardNum:
suggestList = sorted(suggestList)
tipsList.append(suggestList)
DEBUG_MSG("shun zi tipsList:{}".format(tipsList))
return tipsList
def doOperation(self, avt_mb, aid, tile_list):
idx = -1
for i, p in enumerate(self.players_list):
if p and p.mb == avt_mb:
idx = i
# tile = tile_list[0]
DEBUG_MSG("room:{0},curround:{1} idx:{2} doOperation current_idx:{3} aid:{4} tile_list:{5}".format(self.roomID, self.current_round, idx, self.current_idx, aid, tile_list))
"""
当前控牌玩家摸牌后向服务端确认的操作
"""
if self.dismiss_room_ts != 0 and int(time.time() - self.dismiss_room_ts) < const.DISMISS_ROOM_WAIT_TIME:
# 说明在准备解散投票中,不能进行其他操作
DEBUG_MSG("room:{0},curround:{1} idx:{2} doOperationFailed dismiss_room_ts:{3}".format(self.roomID, self.current_round, idx, self.dismiss_room_ts))
avt_mb.doOperationFailed(const.OP_ERROR_VOTE)
return
if self.state != const.ROOM_PLAYING:
DEBUG_MSG("room:{0},curround:{1} idx:{2} doOperationFailed state:{3}".format(self.roomID, self.current_round, idx, self.state))
avt_mb.doOperationFailed(const.OP_ERROR_STATE)
return
# DEBUG_MSG("doOperation idx:{0},self.current_idx:{1},self.wait_op_info_list:{2}".format(idx, self.current_idx, self.wait_op_info_list))
if len(tile_list) == 0 and aid == const.OP_DISCARD:
avt_mb.doOperationFailed(const.OP_ERROR_ILLEGAL)
return
if idx != self.current_idx:
avt_mb.doOperationFailed(const.OP_ERROR_NOT_CURRENT)
return
p = self.players_list[idx]
# if aid == const.OP_DISCARD and self.can_discard(idx, tile):
# self.all_discard_tiles.append(tile)
# p.discardTile(tile)
# elif aid == const.OP_CONCEALED_KONG and self.can_concealed_kong(idx, tile):
# p.concealedKong(tile)
# elif aid == const.OP_KONG_WREATH and self.can_kong_wreath(p.tiles, tile):
# p.kongWreath(tile)
# elif aid == const.OP_CONTINUE_KONG and self.can_continue_kong(idx, tile):
# p.continueKong(tile)
# elif aid == const.OP_PASS:
# # 自己摸牌的时候可以杠或者胡时选择过, 则什么都不做. 继续轮到该玩家打牌.
# pass
# elif aid == const.OP_DRAW_WIN: #普通自摸胡
# is_win, score, result = self.can_win(list(p.tiles), p.last_draw, const.OP_DRAW_WIN, idx)
# DEBUG_MSG("room:{0},curround:{1} idx:{2} do OP_DRAW_WIN==>{3}, {4}, {5}".format(self.roomID, self.current_round, idx, is_win, score, result))
# if is_win:
# p.draw_win(tile, score, result)
# else:
# avt_mb.doOperationFailed(const.OP_ERROR_ILLEGAL)
# self.current_idx = self.nextIdx
# self.beginRound()
# elif aid == const.OP_WREATH_WIN: #自摸8张花胡
# is_win, score, result = self.can_win(list(p.tiles), p.last_draw, const.OP_WREATH_WIN, idx)
# DEBUG_MSG("room:{0},curround:{1} idx:{2} do OP_WREATH_WIN==>{3}, {4}, {5}".format(self.roomID, self.current_round, idx, is_win, score, result))
# if is_win:
# p.draw_win(tile, score, result)
# else:
# avt_mb.doOperationFailed(const.OP_ERROR_ILLEGAL)
# self.current_idx = self.nextIdx
# self.beginRound()
# else:
# avt_mb.doOperationFailed(const.OP_ERROR_ILLEGAL)
# self.current_idx = self.nextIdx
# self.beginRound()
self.deskPokerList[idx] = tile_list
curtile_list = utility.rightShiftCards(tile_list)
last_list = utility.rightShiftCards(self.controller_discard_list)
for i in range(self.player_num):
self.current_idx = self.nextIdx
if self.current_idx in self.win_list:
self.deskPokerList[self.current_idx] = []
continue
else:
break
DEBUG_MSG("room:{0},curround:{1} idx:{2} curtile_list:{3} last_list:{4} curPrizeList{5}".format(self.roomID, self.current_round, idx, curtile_list, last_list, self.curPrizeList))
if aid == const.OP_DISCARD and utility.compareTile(curtile_list, last_list):
self.curround_score += utility.getDiscardScore(curtile_list)
bombScore = utility.getBombScore(curtile_list)
if bombScore > 0:
self.cal_score(idx, self.win_list, const.OP_DISCARD, bombScore)
self.curPrizeList[idx] += int(bombScore / 30)
if len(self.round_end_list) != len(self.win_list):
end_idx = self.win_list[len(self.win_list) - 1]
self.round_end_list.append(end_idx)
p.discardTile(tile_list)
elif aid == const.OP_PASS:
# 客户端判定没有大过上家的牌
self.op_pass_flag += 1
if self.op_pass_flag == self.player_num - len(self.round_end_list) - 1:
# 这里是其他人都要不起，再次轮到自己出牌
self.controller_discard_list = []
self.round_start = True
if len(self.round_end_list) == len(self.win_list):
self.players_list[self.current_idx].add_score(self.curround_score)
self.curScoreList[self.current_idx] += self.curround_score
else:
end_idx = self.win_list[len(self.win_list) - 1]
self.curScoreList[end_idx] += self.curround_score
self.players_list[end_idx].add_score(self.curround_score)
self.round_end_list.append(end_idx)
self.curround_score = 0
# elif self.op_pass_flag == self.player_num - len(self.win_list) - 1:
# end_idx = self.win_list[len(self.win_list) - 1]
# self.round_end_list.append(end_idx)
# self.controller_discard_list = []
# self.round_start = True
# self.curScoreList[self.current_idx] += self.curround_score
# self.players_list[self.current_idx].add_score(self.curround_score)
# self.curround_score = 0
DEBUG_MSG("room:{0},curround:{1} idx:{2}OP_PASS curround_score:{3}".format(self.roomID, self.current_round, idx, self.curround_score))
def delay_callback():
self.broadcastOperation(idx, aid, [], self.curround_score, self.curScoreList)
self.add_timer(const.DELAY_OP_PASS, delay_callback)
else:
DEBUG_MSG("room:{0},curround:{1} idx:{2} doOperationFailed".format(self.roomID, self.current_round, idx))
avt_mb.doOperationFailed(const.OP_ERROR_ILLEGAL)
return
if len(self.win_list) < self.player_num - 1:
DEBUG_MSG("room:{0},curround:{1} idx:{2} curround_score:{3}".format(self.roomID, self.current_round, idx, self.curround_score))
def delay_callback():
self.waitForOperation(self.current_idx, const.OP_DISCARD, 0, self.round_start)
if aid == const.OP_PASS:
self.add_timer(const.DELAY_OP_PASS, delay_callback)
else:
self.waitForOperation(self.current_idx, const.OP_DISCARD, 0, self.round_start)
def can_play_normal_cards(self, cards, idx, playerCards):
DEBUG_MSG("can_nomal_play_cards")
if self.wait_idx == self.controller_idx:
discardType = utility.getNormalCardsType(
utility.rightShiftCards(cards), playerCards, len(playerCards),
self.game_plays, self.game_end, 0, self.key_card)
else:
discardType = utility.getNormalCardsType(
utility.rightShiftCards(cards), playerCards, len(playerCards),
self.game_plays, self.game_end, 1, self.key_card)
controllerType = utility.getNormalCardsType(
utility.rightShiftCards(self.controller_discard_list), playerCards,
len(playerCards), self.game_plays, self.game_end, 0, self.key_card)
# if self.controller_idx == idx:
# self.cotroller_type = 100
# else:
# self.cotroller_type = controllerType
DEBUG_MSG("discardType: {0} controllerType: {1}".format(
discardType, controllerType))
if discardType == const.TYPE_NO_CARD or discardType == const.TYPE_INVALID:
DEBUG_MSG("error discard type.")
return False
if discardType == const.TYPE_TRIPLE and len(
playerCards) != const.TYPE_PAIR:
return False
if discardType == const.TYPE_TRIPLE_ONE and len(
playerCards) != const.TYPE_SERIAL_PAIR:
return False
#自由出牌
if self.controller_idx == idx: #其他玩家要不起 ,如果牌打完 controller_idx 转移到了 对家身上
DEBUG_MSG("free to play.")
return True
#牌型 判断是否 压过前一次出的牌
DEBUG_MSG("controllerType:{0},discardType:{1}.".format(
controllerType, discardType))
if controllerType == discardType:
if len(self.controller_discard_list) != len(cards):
if controllerType == const.TYPE_PLANE_ONE and self.game_end[
3] == 1 and len(utility.rightShiftCards(cards)) == len(
playerCards):
return utility.cmpSameTypeCards(
self.controller_discard_list, cards, discardType)
return False
return utility.cmpSameTypeCards(self.controller_discard_list,
cards, discardType)
elif self.game_end[1] == 1 and len(
utility.rightShiftCards(cards)
) == len(playerCards) and controllerType == const.TYPE_TRIPLE_TWO and (
discardType == const.TYPE_TRIPLE_ONE
or discardType == const.TYPE_TRIPLE):
return utility.cmpSameTypeCards(self.controller_discard_list,
cards, discardType)
elif self.game_end[3] == 1 and len(
utility.rightShiftCards(cards)
) == len(
playerCards
) and controllerType == const.TYPE_PLANE_ONE and discardType == const.TYPE_SERIAL_TRIPLE:
return utility.cmpSameTypeCards(self.controller_discard_list,
cards, discardType)
elif discardType > controllerType:
if discardType == const.TYPE_BOMB:
return True
else:
return False
return False
def getSerialPairTips(self, idx, pairNum, minCard, isSelfDiscard):
tipsList = []
cards, keyCardNum, keyCard = self.getHandCards(idx)
if 28 in cards and self.game_hei3 == 1 and minCard == 2:
tipsList.append([28])
del cards[cards.index(28)]
# DEBUG_MSG("getSerialPairTips cards: {}".format(cards))
if len(cards) < pairNum * 2:
return tipsList
shiftCards = utility.rightShiftCards(cards)
shiftCards2NumDict = utility.getCard2NumDict(shiftCards)
# DEBUG_MSG("getSerialPairTips shiftCards: {}".format(shiftCards))
# DEBUG_MSG("getSerialPairTips shiftCards2NumDict: {}".format(shiftCards2NumDict))
cardsBack = []
bomb_open = self.game_plays[3] # 炸弹是否可以拆
if bomb_open == 1:
for i, card in enumerate(shiftCards):
if shiftCards2NumDict[card] < 4:
cardsBack.append(cards[i])
else:
cardsBack = cards[:]
cards2ListDict = utility.getListDict(cardsBack)
# DEBUG_MSG("getSerialPairTips cards2ListDict: {}".format(cards2ListDict))
# playerCardNum = 0
if self.game_cardnum == 15:
playerCardNum = 13
else:
playerCardNum = 14
playerCardNum = playerCardNum - pairNum + 1
# DEBUG_MSG("minCard ：{} {}".format(minCard,playerCardNum))
for i in range((minCard + 1), playerCardNum + 1):
pairCardNum = 0
if isSelfDiscard:
for j in range(playerCardNum):
if (i + j) in cards2ListDict and len(
cards2ListDict[i + j]) >= 2:
pairCardNum += 1
else:
break
else:
for j in range(pairNum):
if (i + j) in cards2ListDict and len(
cards2ListDict[i + j]) >= 2:
pairCardNum += 1
else:
break
# DEBUG_MSG("getSerialPairTips pairCardNum: {}".format(pairCardNum))
if pairCardNum >= pairNum:
suggestList = []
for j in range(pairCardNum):
suggestList.append(cards2ListDict[i + j][0])
suggestList.append(cards2ListDict[i + j][1])
suggestList = sorted(suggestList)
tipsList.append(suggestList)
# 带癞子的情况
if self.game_mode == 2 and keyCardNum > 0:
for i in range(minCard + 1, playerCardNum - pairNum + 2):
userKeyCardNum = keyCardNum
pairCardNum = 0
suggestList = []
for j in range(pairNum):
if (i + j) not in cards2ListDict.keys():
userKeyCardNum -= 2
pairCardNum += 1
suggestList.append(keyCard)
suggestList.append(keyCard)
elif len(cards2ListDict[i + j]) >= 2:
pairCardNum += 1
suggestList.append(cards2ListDict[i + j][0])
suggestList.append(cards2ListDict[i + j][1])
elif len(cards2ListDict[i + j]) < 2:
userKeyCardNum -= 1
pairCardNum += 1
suggestList.append(cards2ListDict[i + j][0])
suggestList.append(keyCard)
if userKeyCardNum < 0:
pairCardNum -= 1
break
if pairCardNum == pairNum and userKeyCardNum != keyCardNum:
suggestList = sorted(suggestList)
tipsList.append(suggestList)
DEBUG_MSG("lian dui tipsList:{}".format(tipsList))
return tipsList
def getTipsCards(self, idx):
DEBUG_MSG("getTipsCards controller_idx: {0}, idx: {1}".format(
self.controller_idx, idx))
DEBUG_MSG("getTipsCards controller_discard: {0}".format(
self.controller_discard_list))
tips = []
if self.controller_idx == idx: # 玩家自由出牌
self.controller_discard_list = []
tips = self.getSerialPairTips(idx, 2, 2, True) # 连对
tips.extend(self.getSingleSerialTips(idx, 5, 2)) # 顺子
tips.extend(self.getTripleBring(idx, 5, [])) # 三带二
tips.extend(self.getFourBring(idx, [], 2)) # 四带二
tips.extend(self.getFourBring(idx, [], 3)) # 四带三
tips.extend(self.getTipsPlane(idx, [])) # 飞机
# tips.extend(self.getTripleTips(idx, 2)) # 三张
tips.extend(self.getDoubleTips(idx, 0, True)) # 对子
tips.extend(self.getSingleTips(idx, 0, True)) # 单张
tips.extend(self.getBombTips(idx, [])) # 炸弹
tips.extend(self.getTripleTipsSingle(idx, 2)) # 三张
else: # 压过上家
discardCards = self.controller_discard_list
controllerCards = utility.rightShiftCards(discardCards)
controllerCardsType = utility.getNormalCardsType(
controllerCards, [], 0, self.game_plays, self.game_end, 0, 0)
controllerCards = sorted(controllerCards)
DEBUG_MSG("last cards {0}, last cardsType {1}".format(
controllerCards, controllerCardsType))
if controllerCardsType == const.TYPE_SINGLE: # 单张
tips = self.getSingleTips(idx, controllerCards[0], False)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_PAIR: # 对子
tips = self.getDoubleTips(idx, controllerCards[0], False)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_SERIAL_PAIR: # 连对
tips = self.getSerialPairTips(idx,
int(len(controllerCards) / 2),
controllerCards[0], False)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_TRIPLE: # 三张
tips = self.getTripleTips(idx, controllerCards[0])
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_SERIAL_SINGLE: # 顺子
tips = self.getSingleSerialTips(idx, len(controllerCards),
controllerCards[0])
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_TRIPLE_TWO: # 三带二
tips = self.getTripleBring(idx, len(controllerCards),
controllerCards)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_FOUR_TWO: # 四带二
tips = self.getFourBring(idx, controllerCards, 2)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_FOUR_THREE: # 四带三
tips = self.getFourBring(idx, controllerCards, 3)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_PLANE_ONE: # 飞机
tips = self.getTipsPlane(idx, controllerCards)
tips.extend(self.getBombTips(idx, []))
elif controllerCardsType == const.TYPE_BOMB: # 炸弹
tips = self.getBombTips(idx, discardCards)
self.tipsList = tips[:]
DEBUG_MSG("tipsList {}".format(self.tipsList))
return self.tipsList
