981 lines
22 KiB
Go
981 lines
22 KiB
Go
package dezhoupoker
|
||
|
||
import (
|
||
"sort"
|
||
)
|
||
|
||
//----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
type KindOfCardFigureUpEx struct {
|
||
}
|
||
|
||
var KindOfCardFigureUpExSington = &KindOfCardFigureUpEx{}
|
||
|
||
func (this *KindOfCardFigureUpEx) FigureUpByCard(cards []int32) *CardsInfo {
|
||
if len(cards) == 0 {
|
||
return nil
|
||
}
|
||
var tempCard []int
|
||
for _, v := range cards {
|
||
tempCard = append(tempCard, int(v))
|
||
}
|
||
|
||
//按照升序排序
|
||
sort.Ints(tempCard)
|
||
|
||
var cardDataManager CardDataManager
|
||
cardDataManager.Init()
|
||
for i := 0; i < len(tempCard); i++ {
|
||
cardDataManager.AddCard(int32(tempCard[i]))
|
||
}
|
||
cardDataManager.ReCal()
|
||
|
||
//根据value 排序
|
||
cardsInfo := this.CalCardKind(&cardDataManager)
|
||
if cardsInfo != nil && len(cards) > 5 {
|
||
cardsInfo.CalValue()
|
||
}
|
||
return cardsInfo
|
||
}
|
||
|
||
func (this *KindOfCardFigureUpEx) CalCardKind(cardDataManager *CardDataManager) *CardsInfo {
|
||
|
||
card_info := this.IsRoyalFlush(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
card_info = this.IsStraightFlush(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsFourKind(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsFullhouse(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsFlush(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsStraight(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsThreeKind(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsTwoPair(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsOnePair(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
card_info = this.IsHighCard(cardDataManager)
|
||
if card_info != nil {
|
||
return card_info
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
//皇家同花顺 KindOfCard_RoyalFlush
|
||
func (this *KindOfCardFigureUpEx) IsRoyalFlush(cardDataManager *CardDataManager) *CardsInfo {
|
||
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount == 0 {
|
||
return nil
|
||
}
|
||
|
||
var cur_poker CardData
|
||
cur_poker.Init(cardDataManager.CardDataPool[cardCount-1].Card)
|
||
var rst_kind_card []int32
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
for i := cardCount - 2; i >= 0; i-- {
|
||
if cardDataManager.CardDataPool[i].Card != cur_poker.Card-1 ||
|
||
cardDataManager.CardDataPool[i].Color != cur_poker.Color {
|
||
rst_kind_card = nil
|
||
|
||
cur_poker.Init(cardDataManager.CardDataPool[i].Card)
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
continue
|
||
}
|
||
|
||
cur_poker.Init(cardDataManager.CardDataPool[i].Card)
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
if len(rst_kind_card) >= 4 {
|
||
break
|
||
}
|
||
}
|
||
|
||
if len(rst_kind_card) < 4 {
|
||
return nil
|
||
}
|
||
|
||
if cur_poker.Value != POKER_10 {
|
||
return nil
|
||
}
|
||
//已经找到10，J,Q,K, 找同色 A
|
||
for i := 0; i < cardCount; i++ {
|
||
if cardDataManager.CardDataPool[i].Value == POKER_A && cardDataManager.CardDataPool[i].Color == cur_poker.Color {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_RoyalFlush,
|
||
}
|
||
//牌型对应的牌
|
||
//A
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardDataPool[i].Card)
|
||
//KQJ 10
|
||
for i := 0; i < len(rst_kind_card); i++ {
|
||
cardInfo.KindCards = append(cardInfo.KindCards, rst_kind_card[i])
|
||
}
|
||
return cardInfo
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
//同花顺 KindOfCard_StraightFlush
|
||
func (this *KindOfCardFigureUpEx) IsStraightFlush(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount == 0 {
|
||
return nil
|
||
}
|
||
|
||
var cur_poker CardData
|
||
cur_poker.Init(cardDataManager.CardDataPool[cardCount-1].Card)
|
||
var rst_kind_card []int32
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
for i := cardCount - 2; i >= 0; i-- {
|
||
if cardDataManager.CardDataPool[i].Card != cur_poker.Card-1 || cur_poker.Color != cardDataManager.CardDataPool[i].Card/PER_CARD_COLOR_MAX {
|
||
rst_kind_card = nil
|
||
|
||
cur_poker.Init(cardDataManager.CardDataPool[i].Card)
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
continue
|
||
}
|
||
|
||
cur_poker.Init(cardDataManager.CardDataPool[i].Card)
|
||
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
if len(rst_kind_card) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
|
||
if len(rst_kind_card) == 5 {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_StraightFlush,
|
||
}
|
||
|
||
//牌型对应的牌
|
||
for i := 0; i < len(rst_kind_card); i++ {
|
||
cardInfo.KindCards = append(cardInfo.KindCards, rst_kind_card[i])
|
||
}
|
||
return cardInfo
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
//四条：先比四条，四条相同比单张。 KindOfCard_FourKind
|
||
func (this *KindOfCardFigureUpEx) IsFourKind(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 4 {
|
||
return nil
|
||
}
|
||
|
||
for typeCardValue, typeCardCount := range cardDataManager.CardValueCount {
|
||
if typeCardCount == 4 {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_FourKind,
|
||
}
|
||
|
||
//4张 牌型牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value == typeCardValue {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
|
||
if cardCount >= 5 {
|
||
//第5张牌型牌
|
||
fithCard := int32(0)
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Card != cardInfo.KindCards[0] {
|
||
if curCard.Value == POKER_A {
|
||
fithCard = curCard.Card
|
||
break
|
||
} else {
|
||
if fithCard < curCard.Value {
|
||
fithCard = curCard.Card
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cardInfo.KindCards = append(cardInfo.KindCards, fithCard)
|
||
}
|
||
return cardInfo
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
//葫芦：先比三条，三条相同比对子 KindOfCard_Fullhouse
|
||
func (this *KindOfCardFigureUpEx) IsFullhouse(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 5 {
|
||
return nil
|
||
}
|
||
|
||
card2Value := INVALIDE_CARD
|
||
card3Value := INVALIDE_CARD
|
||
card3Count := int32(0)
|
||
|
||
for cardValue, cardCount := range cardDataManager.CardValueCount {
|
||
if cardCount == 3 {
|
||
card3Count++
|
||
if card3Value == POKER_A {
|
||
continue
|
||
}
|
||
|
||
if card3Value < cardValue || cardValue == POKER_A {
|
||
card3Value = cardValue
|
||
}
|
||
} else if cardCount == 2 {
|
||
if card2Value == POKER_A {
|
||
continue
|
||
}
|
||
|
||
if card2Value < cardValue || cardValue == POKER_A {
|
||
card2Value = cardValue
|
||
}
|
||
}
|
||
}
|
||
|
||
//总共7张，如果有两个3条，就必然不会有2对.如果有两个3条，把较小的哪个当做两对
|
||
if card3Count >= 2 {
|
||
for cardValue, cardCount := range cardDataManager.CardValueCount {
|
||
if cardCount == 3 {
|
||
if card3Value != cardValue {
|
||
card2Value = cardValue
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if card2Value != INVALIDE_CARD && card3Value != INVALIDE_CARD {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_Fullhouse,
|
||
}
|
||
|
||
//3对
|
||
for i := 0; i < cardCount; i++ {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Value == card3Value {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
|
||
//2对
|
||
for i := 0; i < cardCount; i++ {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Value == card2Value {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
|
||
return cardInfo
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
//同花：比最大的单张，如相同则依次比剩余的单张。 KindOfCard_Flush
|
||
func (this *KindOfCardFigureUpEx) IsFlush(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 5 {
|
||
return nil
|
||
}
|
||
|
||
sameColorCount := int32(0)
|
||
sameColorValue := int32(0)
|
||
|
||
for colorValue, colorCount := range cardDataManager.CardColorCount {
|
||
if colorCount > sameColorCount {
|
||
sameColorCount = colorCount
|
||
sameColorValue = colorValue
|
||
}
|
||
}
|
||
|
||
if sameColorCount < 5 {
|
||
return nil
|
||
}
|
||
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_Flush,
|
||
}
|
||
|
||
bHasPoker_A := false
|
||
var temp_rst []int
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Color == sameColorValue {
|
||
temp_rst = append(temp_rst, int(curCard.Card))
|
||
|
||
if curCard.Value == POKER_A {
|
||
bHasPoker_A = true
|
||
}
|
||
}
|
||
}
|
||
sort.Ints(temp_rst)
|
||
|
||
if bHasPoker_A {
|
||
cardInfo.KindCards = append(cardInfo.KindCards, int32(temp_rst[0]))
|
||
|
||
data_len := len(temp_rst)
|
||
for i := data_len - 1; i >= 0; i-- {
|
||
cardInfo.KindCards = append(cardInfo.KindCards, int32(temp_rst[i]))
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
data_len := len(temp_rst)
|
||
for i := data_len - 1; i >= 0; i-- {
|
||
cardInfo.KindCards = append(cardInfo.KindCards, int32(temp_rst[i]))
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
return cardInfo
|
||
}
|
||
|
||
//顺子：比顺子的大小。A2345是最小的顺子,AKQJ10是最大的顺子。 KindOfCard_Straight
|
||
func (this *KindOfCardFigureUpEx) IsStraight(cardDataManager *CardDataManager) *CardsInfo {
|
||
card_info := this.IsStraightNormal(cardDataManager)
|
||
if card_info == nil {
|
||
card_info = this.IsStraightMax(cardDataManager)
|
||
}
|
||
return card_info
|
||
}
|
||
func (this *KindOfCardFigureUpEx) IsStraightNormal(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 5 {
|
||
return nil
|
||
}
|
||
|
||
var cur_poker CardData
|
||
cur_poker.Init(cardDataManager.CardData2Pool[cardCount-1].Card)
|
||
var rst_kind_card []int32
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
for i := cardCount - 2; i >= 0; i-- {
|
||
if cardDataManager.CardData2Pool[i].Value == cur_poker.Value {
|
||
continue
|
||
}
|
||
if cardDataManager.CardData2Pool[i].Value != cur_poker.Value-1 {
|
||
rst_kind_card = nil
|
||
|
||
cur_poker.Init(cardDataManager.CardData2Pool[i].Card)
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
continue
|
||
}
|
||
|
||
cur_poker.Init(cardDataManager.CardData2Pool[i].Card)
|
||
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
if len(rst_kind_card) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
|
||
if len(rst_kind_card) == 5 {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_Straight,
|
||
}
|
||
cardInfo.KindCards = rst_kind_card
|
||
return cardInfo
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
func (this *KindOfCardFigureUpEx) IsStraightMax(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount == 0 {
|
||
return nil
|
||
}
|
||
|
||
var cur_poker CardData
|
||
cur_poker.Init(cardDataManager.CardData2Pool[cardCount-1].Card)
|
||
var rst_kind_card []int32
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
for i := cardCount - 2; i >= 0; i-- {
|
||
if cardDataManager.CardData2Pool[i].Value == cur_poker.Value {
|
||
continue
|
||
}
|
||
if cardDataManager.CardData2Pool[i].Value != cur_poker.Value-1 {
|
||
rst_kind_card = nil
|
||
|
||
cur_poker.Init(cardDataManager.CardData2Pool[i].Card)
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
continue
|
||
}
|
||
|
||
cur_poker.Init(cardDataManager.CardData2Pool[i].Card)
|
||
|
||
rst_kind_card = append(rst_kind_card, cur_poker.Card)
|
||
|
||
if len(rst_kind_card) >= 4 {
|
||
break
|
||
}
|
||
}
|
||
if len(rst_kind_card) < 4 {
|
||
return nil
|
||
}
|
||
|
||
if cur_poker.Value == POKER_10 && cardDataManager.CardData2Pool[0].Value == POKER_A {
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_Straight,
|
||
}
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardData2Pool[0].Card)
|
||
cardInfo.KindCards = append(cardInfo.KindCards, rst_kind_card...)
|
||
return cardInfo
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
//三条：先比三条，三条相同比单张 KindOfCard_ThreeKind
|
||
func (this *KindOfCardFigureUpEx) IsThreeKind(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 3 {
|
||
return nil
|
||
}
|
||
|
||
santiaoValue := int32(INVALIDE_CARD)
|
||
for cardValue, cardCount := range cardDataManager.CardValueCount {
|
||
if cardCount == 3 {
|
||
santiaoValue = cardValue
|
||
}
|
||
}
|
||
if santiaoValue == INVALIDE_CARD {
|
||
return nil
|
||
}
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_ThreeKind,
|
||
}
|
||
|
||
//前3张
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Value == santiaoValue {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
|
||
if cardDataManager.CardData2Pool[0].Value == POKER_A && santiaoValue != POKER_A {
|
||
if cardCount >= 4 {
|
||
//第4张牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardData2Pool[0].Card)
|
||
}
|
||
|
||
if cardCount >= 5 {
|
||
//第5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value != santiaoValue && curCard.Value != POKER_A {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//第4张 第 5 张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value != santiaoValue {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return cardInfo
|
||
}
|
||
|
||
//两对：先比大对，再比小对，都相同则比单张。 KindOfCard_TwoPair
|
||
func (this *KindOfCardFigureUpEx) IsTwoPair(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 4 {
|
||
return nil
|
||
}
|
||
|
||
var card2Value []int
|
||
for cardValue, cardCount := range cardDataManager.CardValueCount {
|
||
if cardCount == 2 {
|
||
card2Value = append(card2Value, int(cardValue))
|
||
}
|
||
}
|
||
if len(card2Value) < 2 {
|
||
return nil
|
||
}
|
||
sort.Ints(card2Value)
|
||
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_TwoPair,
|
||
}
|
||
|
||
if len(card2Value) == 3 {
|
||
if card2Value[0] == int(POKER_A) {
|
||
//删除中间
|
||
card2Value = append(card2Value[:1], card2Value[2:]...)
|
||
} else {
|
||
//删除第一个
|
||
card2Value = append(card2Value[:0], card2Value[1:]...)
|
||
}
|
||
}
|
||
if card2Value[0] == int(POKER_A) {
|
||
card2Value[0], card2Value[1] = card2Value[1], card2Value[0]
|
||
}
|
||
for j := 1; j >= 0; j-- {
|
||
//2对
|
||
for i := 0; i < cardCount; i++ {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Value == int32(card2Value[j]) {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
}
|
||
|
||
if cardCount >= 5 {
|
||
//第5张牌
|
||
if cardDataManager.CardData2Pool[0].Value == POKER_A && int32(card2Value[1]) != POKER_A {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardData2Pool[0].Card)
|
||
} else {
|
||
//第5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value != int32(card2Value[0]) && curCard.Value != int32(card2Value[1]) {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return cardInfo
|
||
}
|
||
|
||
//一对：先比对子，对子相同则依次比单张。 KindOfCard_OnePair
|
||
func (this *KindOfCardFigureUpEx) IsOnePair(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount < 2 {
|
||
return nil
|
||
}
|
||
|
||
card1Value := INVALIDE_CARD
|
||
for cardValue, cardCount := range cardDataManager.CardValueCount {
|
||
if cardCount == 2 {
|
||
card1Value = cardValue
|
||
break
|
||
}
|
||
}
|
||
if card1Value == INVALIDE_CARD {
|
||
return nil
|
||
}
|
||
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_OnePair,
|
||
}
|
||
|
||
//1对
|
||
for i := 0; i < cardCount; i++ {
|
||
curCard := cardDataManager.CardDataPool[i]
|
||
|
||
if curCard.Value == card1Value {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
}
|
||
}
|
||
|
||
//第3 ~ 5张牌
|
||
if cardDataManager.CardData2Pool[0].Value == POKER_A && card1Value != POKER_A {
|
||
//牌型牌
|
||
//第 3 张
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardData2Pool[0].Card)
|
||
|
||
//第4 ~ 5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value != card1Value && curCard.Value != POKER_A {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//第3 ~ 5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
if curCard.Value != card1Value {
|
||
//牌型牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return cardInfo
|
||
}
|
||
|
||
//高牌：先比最大的牌，如相同则依次比剩余的单张 KindOfCard_HighCard
|
||
func (this *KindOfCardFigureUpEx) IsHighCard(cardDataManager *CardDataManager) *CardsInfo {
|
||
cardCount := len(cardDataManager.CardDataPool)
|
||
if cardCount == 0 {
|
||
return nil
|
||
}
|
||
|
||
cardInfo := &CardsInfo{
|
||
Kind: KindOfCard_HighCard,
|
||
}
|
||
|
||
if cardDataManager.CardData2Pool[0].Value == POKER_A {
|
||
//牌型牌
|
||
//第 1 张牌
|
||
cardInfo.KindCards = append(cardInfo.KindCards, cardDataManager.CardData2Pool[0].Card)
|
||
|
||
//第2 ~ 5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
//第1 ~ 5张牌
|
||
for i := cardCount - 1; i >= 0; i-- {
|
||
curCard := cardDataManager.CardData2Pool[i]
|
||
|
||
cardInfo.KindCards = append(cardInfo.KindCards, curCard.Card)
|
||
if len(cardInfo.KindCards) >= 5 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
return cardInfo
|
||
}
|
||
|
||
func (this *KindOfCardFigureUpEx) IsTing(cards []int32, kind int32) bool {
|
||
for i := int32(0); i < POKER_CNT; i++ {
|
||
if hasCard(cards, i) {
|
||
continue
|
||
}
|
||
|
||
var tempCard []int
|
||
for _, v := range cards {
|
||
tempCard = append(tempCard, int(v))
|
||
}
|
||
tempCard = append(tempCard, int(i))
|
||
//按照升序排序
|
||
sort.Ints(tempCard)
|
||
|
||
var cardDataManager CardDataManager
|
||
cardDataManager.Init()
|
||
for i := 0; i < len(tempCard); i++ {
|
||
cardDataManager.AddCard(int32(tempCard[i]))
|
||
}
|
||
cardDataManager.ReCal()
|
||
|
||
ci := this.CalCardKind(&cardDataManager)
|
||
if ci != nil && ci.Kind == kind {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func (this *KindOfCardFigureUpEx) IsTingKinds(cards []int32, kinds []int32) bool {
|
||
for _, k := range kinds {
|
||
if this.IsTing(cards, k) {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func (this *KindOfCardFigureUpEx) TingCount(cards, exclude []int32, kind int32) int {
|
||
cnt := 0
|
||
for i := int32(0); i < POKER_CNT; i++ {
|
||
if hasCard(exclude, i) {
|
||
continue
|
||
}
|
||
if hasCard(cards, i) {
|
||
continue
|
||
}
|
||
|
||
var tempCard []int
|
||
for _, v := range cards {
|
||
tempCard = append(tempCard, int(v))
|
||
}
|
||
tempCard = append(tempCard, int(i))
|
||
//按照升序排序
|
||
sort.Ints(tempCard)
|
||
|
||
var cardDataManager CardDataManager
|
||
cardDataManager.Init()
|
||
for i := 0; i < len(tempCard); i++ {
|
||
cardDataManager.AddCard(int32(tempCard[i]))
|
||
}
|
||
cardDataManager.ReCal()
|
||
|
||
ci := this.CalCardKind(&cardDataManager)
|
||
if ci != nil && ci.Kind == kind {
|
||
cnt++
|
||
}
|
||
}
|
||
|
||
return cnt
|
||
}
|
||
|
||
func (this *KindOfCardFigureUpEx) TingKindsCount(cards, exclude, kinds []int32) int {
|
||
cnt := 0
|
||
for _, k := range kinds {
|
||
cnt += this.TingCount(cards, exclude, k)
|
||
}
|
||
return cnt
|
||
}
|
||
|
||
func hasCard(cards []int32, c int32) bool {
|
||
for _, _c := range cards {
|
||
if _c == c {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func IsOverPair(ci *CardsInfo, handCard []int32, commonCard []int32) bool {
|
||
if ci == nil || ci.Kind != KindOfCard_OnePair {
|
||
return false
|
||
}
|
||
if len(handCard) != 2 {
|
||
return false
|
||
}
|
||
|
||
if handCard[0]%PER_CARD_COLOR_MAX != handCard[1]%PER_CARD_COLOR_MAX {
|
||
return false
|
||
}
|
||
|
||
max := CardValueMap[handCard[0]%PER_CARD_COLOR_MAX]
|
||
for _, c := range commonCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v > max {
|
||
return false
|
||
}
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
func IsUnderPair(ci *CardsInfo, handCard []int32, commonCard []int32) bool {
|
||
if ci == nil || ci.Kind != KindOfCard_OnePair {
|
||
return false
|
||
}
|
||
if len(handCard) != 2 {
|
||
return false
|
||
}
|
||
|
||
if handCard[0]%PER_CARD_COLOR_MAX != handCard[1]%PER_CARD_COLOR_MAX {
|
||
return false
|
||
}
|
||
|
||
pv := CardValueMap[handCard[0]%PER_CARD_COLOR_MAX]
|
||
for _, c := range commonCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v < pv {
|
||
return false
|
||
}
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
func IsTopPair(ci *CardsInfo, handCard []int32, commonCard []int32) bool {
|
||
if ci == nil || ci.Kind != KindOfCard_OnePair {
|
||
return false
|
||
}
|
||
if len(handCard) != 2 {
|
||
return false
|
||
}
|
||
|
||
pv := CardValueMap[ci.KindCards[0]%PER_CARD_COLOR_MAX]
|
||
max := 0
|
||
for _, c := range commonCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v > max {
|
||
max = v
|
||
}
|
||
}
|
||
|
||
if pv != max {
|
||
return false
|
||
}
|
||
|
||
for _, c := range handCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v == max {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func IsMiddlePair(ci *CardsInfo, handCard []int32, commonCard []int32) bool {
|
||
if ci == nil || ci.Kind != KindOfCard_OnePair {
|
||
return false
|
||
}
|
||
if len(handCard) != 2 {
|
||
return false
|
||
}
|
||
|
||
pv := CardValueMap[ci.KindCards[0]%PER_CARD_COLOR_MAX]
|
||
max := 0
|
||
min := 13
|
||
for _, c := range commonCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v > max {
|
||
max = v
|
||
}
|
||
if v < min {
|
||
min = v
|
||
}
|
||
}
|
||
|
||
if pv <= min || pv >= max {
|
||
return false
|
||
}
|
||
|
||
for _, c := range handCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v == pv {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func IsButtomPair(ci *CardsInfo, handCard []int32, commonCard []int32) bool {
|
||
if ci == nil || ci.Kind != KindOfCard_OnePair {
|
||
return false
|
||
}
|
||
if len(handCard) != 2 {
|
||
return false
|
||
}
|
||
|
||
pv := CardValueMap[ci.KindCards[0]%PER_CARD_COLOR_MAX]
|
||
min := 13
|
||
for _, c := range commonCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v < min {
|
||
min = v
|
||
}
|
||
}
|
||
|
||
if pv != min {
|
||
return false
|
||
}
|
||
|
||
for _, c := range handCard {
|
||
v := CardValueMap[c%PER_CARD_COLOR_MAX]
|
||
if v == min {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
func KindOfCardIsBetter(handCard []int32, commonCard []int32) bool {
|
||
ok, _, _ := KindOfCardIsBetterEx(handCard, commonCard)
|
||
return ok
|
||
}
|
||
|
||
//牌型是否较上个阶段有所提升
|
||
func KindOfCardIsBetterEx(handCard []int32, commonCard []int32) (bool, *CardsInfo, *CardsInfo) {
|
||
var pre, cur *CardsInfo
|
||
switch len(commonCard) {
|
||
case 3:
|
||
pre = KindOfCardFigureUpExSington.FigureUpByCard(commonCard)
|
||
cur = KindOfCardFigureUpExSington.FigureUpByCard(append(handCard, commonCard...))
|
||
case 4:
|
||
pre = KindOfCardFigureUpExSington.FigureUpByCard(commonCard)
|
||
cur = KindOfCardFigureUpExSington.FigureUpByCard(append(handCard, commonCard...))
|
||
case 5:
|
||
pre = KindOfCardFigureUpExSington.FigureUpByCard(commonCard)
|
||
cur = KindOfCardFigureUpExSington.FigureUpByCard(append(handCard, commonCard...))
|
||
}
|
||
if pre != nil && cur != nil {
|
||
if cur.Kind > pre.Kind {
|
||
return true, pre, cur
|
||
}
|
||
}
|
||
return false, pre, cur
|
||
}
|