652 lines
13 KiB
Go
652 lines
13 KiB
Go
package tienlen
|
||
|
||
import (
|
||
"math/rand"
|
||
"sort"
|
||
"time"
|
||
)
|
||
|
||
//牌序- 2, A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3
|
||
//红桃- 51,50,49,48,47,46,45,44,43,42,41,40,39
|
||
//方片- 38,37,36,35,34,33,32,31,30,29,28,27,26
|
||
//梅花- 25,24,23,22,21,20,19,18,17,16,15,14,13
|
||
//黑桃- 12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
|
||
|
||
const (
|
||
POKER_CNT = 52
|
||
PER_CARD_COLOR_MAX = 13
|
||
Hand_CardNum = 13 //手牌
|
||
Card_Value_2 = 12 //特殊牌值2
|
||
Player_Num_Max = 4 //桌上最大人數
|
||
HongTao2 = 51
|
||
FangPian2 = 38
|
||
MeiHua2 = 25
|
||
HeiTao2 = 12
|
||
)
|
||
|
||
// 不同牌型分值
|
||
const (
|
||
hei2 = 0
|
||
fang2 = 3
|
||
hong2 = 5
|
||
zhadan = 20
|
||
liandui5 = 21
|
||
liandui4 = 18
|
||
liandui3 = 15
|
||
shunzi8 = 15
|
||
shunzi7 = 10
|
||
shunzi6 = 5
|
||
sanzhang = 3
|
||
)
|
||
|
||
const (
|
||
yl_hei2 = 0
|
||
yl_fang2 = 3
|
||
yl_hong2 = 5
|
||
yl_zhadan = 30
|
||
yl_liandui5 = 21
|
||
yl_liandui4 = 18
|
||
yl_liandui3 = 15
|
||
yl_shunzi8 = 15
|
||
yl_shunzi7 = 10
|
||
yl_shunzi6 = 5
|
||
yl_sanzhang = 15
|
||
)
|
||
|
||
type Card int
|
||
|
||
type Poker struct {
|
||
buf [POKER_CNT]Card
|
||
copyBuf [POKER_CNT]Card
|
||
tianhuBuf [POKER_CNT]Card
|
||
isTianhu bool
|
||
}
|
||
|
||
func (this *Poker) GetPokerBuf() [POKER_CNT]Card {
|
||
return this.buf
|
||
}
|
||
|
||
func (this *Poker) CopyPokerBuf() {
|
||
for i := 0; i < len(this.buf); i++ {
|
||
this.copyBuf[i] = this.buf[i]
|
||
}
|
||
}
|
||
|
||
func (this *Poker) UncopyPokerBuf() {
|
||
for i := 0; i < len(this.copyBuf); i++ {
|
||
this.buf[i] = this.copyBuf[i]
|
||
this.copyBuf[i] = Card(i)
|
||
}
|
||
}
|
||
|
||
func (this *Poker) TianhuPokerBuf() {
|
||
for i := 0; i < len(this.buf); i++ {
|
||
this.tianhuBuf[i] = this.buf[i]
|
||
}
|
||
this.isTianhu = true
|
||
}
|
||
|
||
func (this *Poker) UnTianhuPokerBuf() {
|
||
for i := 0; i < len(this.tianhuBuf); i++ {
|
||
this.buf[i] = this.tianhuBuf[i]
|
||
this.tianhuBuf[i] = Card(i)
|
||
}
|
||
this.isTianhu = false
|
||
}
|
||
|
||
func (this *Poker) IsTianhuPoker() bool {
|
||
return this.isTianhu
|
||
}
|
||
|
||
func NewPoker() *Poker {
|
||
p := &Poker{}
|
||
p.init()
|
||
return p
|
||
}
|
||
|
||
func (this *Poker) init() {
|
||
for i := int32(0); i < POKER_CNT; i++ {
|
||
this.buf[i] = Card(i)
|
||
}
|
||
rand.Seed(time.Now().UnixNano())
|
||
this.Shuffle()
|
||
}
|
||
|
||
func (this *Poker) Shuffle() {
|
||
for i := int32(0); i < POKER_CNT; i++ {
|
||
j := rand.Intn(int(i) + 1)
|
||
this.buf[i], this.buf[j] = this.buf[j], this.buf[i]
|
||
}
|
||
}
|
||
|
||
// GetCardsGrade 给手牌打分
|
||
func GetCardsGrade(cards []int32, yl bool) int {
|
||
grade := 0
|
||
cpCards := []int32{}
|
||
for _, card := range cards {
|
||
if card != InvalideCard {
|
||
cpCards = append(cpCards, card)
|
||
grade += Value(card) + 1 // 基础分
|
||
}
|
||
}
|
||
|
||
if Have2FourBomb(cpCards) || Have6StraightTwin(cpCards) || Have12Straight(cpCards) {
|
||
return 9999
|
||
}
|
||
|
||
//找单2
|
||
for i := 0; i < len(cpCards); i++ {
|
||
card := cpCards[i]
|
||
switch card {
|
||
case HongTao2:
|
||
if yl {
|
||
grade += yl_hong2
|
||
} else {
|
||
grade += hong2
|
||
}
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
case FangPian2:
|
||
if yl {
|
||
grade += yl_fang2
|
||
} else {
|
||
grade += fang2
|
||
}
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
case MeiHua2, HeiTao2:
|
||
if yl {
|
||
grade += yl_hei2
|
||
} else {
|
||
grade += hei2
|
||
}
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
}
|
||
}
|
||
|
||
// 找炸弹
|
||
if len(cpCards) >= 4 {
|
||
mapBomb := make(map[int32]int)
|
||
for _, card := range cpCards {
|
||
mapBomb[int32(Value(card))]++
|
||
}
|
||
bombValue := []int32{}
|
||
for card, num := range mapBomb {
|
||
if num == 4 {
|
||
bombValue = append(bombValue, card)
|
||
}
|
||
}
|
||
if len(bombValue) > 0 {
|
||
findCards := []int32{}
|
||
for _, card := range bombValue {
|
||
for i := int32(0); i < 4; i++ {
|
||
findCards = append(findCards, card+(i*PER_CARD_COLOR_MAX))
|
||
cpCards = DelSliceInt32(cpCards, card+(i*PER_CARD_COLOR_MAX))
|
||
}
|
||
}
|
||
if yl {
|
||
grade += len(bombValue) * yl_zhadan
|
||
} else {
|
||
grade += len(bombValue) * zhadan
|
||
}
|
||
}
|
||
}
|
||
|
||
//找五连
|
||
if len(cpCards) >= 10 {
|
||
sort.Slice(cpCards, func(i, j int) bool {
|
||
if cpCards[i] > cpCards[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
map5STwin := make(map[int32]int32)
|
||
for _, card := range cpCards {
|
||
map5STwin[int32(Value(card))]++
|
||
}
|
||
Value5STwin := []int32{}
|
||
for card, num := range map5STwin {
|
||
if num >= 2 {
|
||
Value5STwin = append(Value5STwin, card)
|
||
}
|
||
}
|
||
sort.Slice(Value5STwin, func(i, j int) bool {
|
||
if Value5STwin[i] > Value5STwin[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
if len(Value5STwin) > 0 {
|
||
tmpPairs := FindOneStraightWithWidth(5, Value5STwin)
|
||
if len(tmpPairs) > 0 {
|
||
findCards := []int32{}
|
||
for _, card := range tmpPairs {
|
||
delC := 0
|
||
for i := 0; i < len(cpCards); i++ {
|
||
if cpCards[i] == InvalideCard {
|
||
continue
|
||
}
|
||
if int32(Value(cpCards[i])) == card && (delC < 2) { //删除2次
|
||
findCards = append(findCards, card)
|
||
delC++
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
if yl {
|
||
grade += yl_liandui5
|
||
} else {
|
||
grade += liandui5
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//找四连
|
||
if len(cpCards) >= 8 {
|
||
sort.Slice(cpCards, func(i, j int) bool {
|
||
if cpCards[i] > cpCards[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
map4STwin := make(map[int32]int32)
|
||
for _, card := range cpCards {
|
||
map4STwin[int32(Value(card))]++
|
||
}
|
||
Value4STwin := []int32{}
|
||
for card, num := range map4STwin {
|
||
if num >= 2 {
|
||
Value4STwin = append(Value4STwin, card)
|
||
}
|
||
}
|
||
sort.Slice(Value4STwin, func(i, j int) bool {
|
||
if Value4STwin[i] > Value4STwin[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
if len(Value4STwin) > 0 {
|
||
tmpPairs := FindOneStraightWithWidth(4, Value4STwin)
|
||
if len(tmpPairs) > 0 {
|
||
findCards := []int32{}
|
||
for _, card := range tmpPairs {
|
||
delC := 0
|
||
for i := 0; i < len(cpCards); i++ {
|
||
if cpCards[i] != InvalideCard {
|
||
if int32(Value(cpCards[i])) == card && (delC < 2) { //删除2次
|
||
findCards = append(findCards, card)
|
||
delC++
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if yl {
|
||
grade += yl_liandui4
|
||
} else {
|
||
grade += liandui4
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//找三连
|
||
if len(cpCards) >= 6 {
|
||
sort.Slice(cpCards, func(i, j int) bool {
|
||
if cpCards[i] > cpCards[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
map3STwin := make(map[int32]int32)
|
||
for _, card := range cpCards {
|
||
map3STwin[int32(Value(card))]++
|
||
}
|
||
Value3STwin := []int32{}
|
||
for card, num := range map3STwin {
|
||
if num >= 2 {
|
||
Value3STwin = append(Value3STwin, card)
|
||
}
|
||
}
|
||
sort.Slice(Value3STwin, func(i, j int) bool {
|
||
if Value3STwin[i] > Value3STwin[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
if len(Value3STwin) > 0 {
|
||
tmpPairs := FindOneStraightWithWidth(3, Value3STwin)
|
||
if len(tmpPairs) > 0 {
|
||
findCards := []int32{}
|
||
for _, card := range tmpPairs {
|
||
delC := 0
|
||
for i := 0; i < len(cpCards); i++ {
|
||
if cpCards[i] == InvalideCard {
|
||
continue
|
||
}
|
||
if int32(Value(cpCards[i])) == card && (delC < 2) { //删除2次
|
||
findCards = append(findCards, card)
|
||
delC++
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
if yl {
|
||
grade += yl_liandui3
|
||
} else {
|
||
grade += liandui3
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//再找三连
|
||
if len(cpCards) >= 6 {
|
||
sort.Slice(cpCards, func(i, j int) bool {
|
||
if cpCards[i] > cpCards[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
map3STwin := make(map[int32]int32)
|
||
for _, card := range cpCards {
|
||
map3STwin[int32(Value(card))]++
|
||
}
|
||
Value3STwin := []int32{}
|
||
for card, num := range map3STwin {
|
||
if num >= 2 {
|
||
Value3STwin = append(Value3STwin, card)
|
||
}
|
||
}
|
||
sort.Slice(Value3STwin, func(i, j int) bool {
|
||
if Value3STwin[i] > Value3STwin[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
if len(Value3STwin) > 0 {
|
||
tmpPairs := FindOneStraightWithWidth(3, Value3STwin)
|
||
if len(tmpPairs) > 0 {
|
||
findCards := []int32{}
|
||
for _, card := range tmpPairs {
|
||
delC := 0
|
||
for i := 0; i < len(cpCards); i++ {
|
||
if cpCards[i] == InvalideCard {
|
||
continue
|
||
}
|
||
if int32(Value(cpCards[i])) == card && (delC < 2) { //删除2次
|
||
findCards = append(findCards, card)
|
||
delC++
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
if yl {
|
||
grade += yl_liandui3
|
||
} else {
|
||
grade += liandui3
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//找8顺子
|
||
if len(cpCards) >= 8 {
|
||
del, tmpCards, _ := delStraight(cpCards, 8)
|
||
if del {
|
||
if yl {
|
||
grade += yl_shunzi8
|
||
} else {
|
||
grade += shunzi8
|
||
}
|
||
cpCards = tmpCards
|
||
}
|
||
}
|
||
// 找三张
|
||
if len(cpCards) >= 3 {
|
||
mapTriple := make(map[int32]int)
|
||
for _, card := range cpCards {
|
||
mapTriple[int32(Value(card))]++
|
||
}
|
||
tripleValues := []int32{}
|
||
for card, num := range mapTriple {
|
||
if num == 3 {
|
||
tripleValues = append(tripleValues, card)
|
||
}
|
||
}
|
||
if len(tripleValues) > 0 {
|
||
findCards := []int32{}
|
||
for _, value := range tripleValues {
|
||
delC := 0
|
||
for i := 0; i < len(cpCards); i++ {
|
||
card := cpCards[i]
|
||
if card != InvalideCard {
|
||
if Value(card) == int(value) && (delC < 3) { //删除3次
|
||
findCards = append(findCards, card)
|
||
delC++
|
||
cpCards = append(cpCards[:i], cpCards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if yl {
|
||
grade += len(tripleValues) * yl_sanzhang
|
||
} else {
|
||
grade += len(tripleValues) * sanzhang
|
||
}
|
||
}
|
||
}
|
||
//找7顺子
|
||
if len(cpCards) >= 7 {
|
||
del, tmpCards, _ := delStraight(cpCards, 7)
|
||
if del {
|
||
if yl {
|
||
grade += yl_shunzi7
|
||
} else {
|
||
grade += shunzi7
|
||
}
|
||
cpCards = tmpCards
|
||
}
|
||
}
|
||
//找6顺子
|
||
if len(cpCards) >= 6 {
|
||
del, tmpCards, _ := delStraight(cpCards, 6)
|
||
if del {
|
||
if yl {
|
||
grade += yl_shunzi6
|
||
} else {
|
||
grade += shunzi6
|
||
}
|
||
cpCards = tmpCards
|
||
}
|
||
}
|
||
//再找6顺子
|
||
if len(cpCards) >= 6 {
|
||
del, tmpCards, _ := delStraight(cpCards, 6)
|
||
if del {
|
||
if yl {
|
||
grade += yl_shunzi6
|
||
} else {
|
||
grade += shunzi6
|
||
}
|
||
cpCards = tmpCards
|
||
}
|
||
}
|
||
return grade
|
||
}
|
||
|
||
// 发顺子（不包括2 最少3顺子）
|
||
func delStraight(cards []int32, value int) (bool, []int32, []int32) {
|
||
haveNeed := false
|
||
needCards := []int32{}
|
||
|
||
if cards == nil || len(cards) < value {
|
||
return haveNeed, cards, needCards
|
||
}
|
||
|
||
mapStraights := make(map[int32]int32)
|
||
for _, card := range cards {
|
||
if card != InvalideCard && Value(card) != Card_Value_2 {
|
||
mapStraights[int32(Value(card))]++
|
||
}
|
||
}
|
||
valueStraights := []int32{}
|
||
for cardValue, _ := range mapStraights {
|
||
valueStraights = append(valueStraights, cardValue)
|
||
}
|
||
if len(valueStraights) > 0 {
|
||
sort.Slice(valueStraights, func(i, j int) bool {
|
||
if valueStraights[i] > valueStraights[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
straights := FindStraightWithWidth(value, valueStraights)
|
||
if len(straights) > 0 {
|
||
randStraight := straights[rand.Intn(len(straights))] //随机一条顺子
|
||
for _, cardValue := range randStraight {
|
||
delC := 0
|
||
for i := 0; i < len(cards); i++ {
|
||
card := cards[i]
|
||
if card == InvalideCard {
|
||
continue
|
||
}
|
||
if int32(Value(card)) == cardValue && (delC < 1) { //删除1次
|
||
delC++
|
||
needCards = append(needCards, card)
|
||
cards = append(cards[:i], cards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
haveNeed = true
|
||
}
|
||
}
|
||
|
||
return haveNeed, cards, needCards
|
||
}
|
||
|
||
// 发连对（不包括2 最少2顺子）
|
||
func delStraightTwin(cards []int32, value int) (bool, []int32, []int32) {
|
||
haveNeed := false
|
||
needCards := []int32{}
|
||
|
||
if cards == nil || len(cards) < value {
|
||
return haveNeed, cards, needCards
|
||
}
|
||
|
||
mapStraights := make(map[int32]int32)
|
||
for _, card := range cards {
|
||
if card != InvalideCard && Value(card) != Card_Value_2 {
|
||
mapStraights[int32(Value(card))]++
|
||
}
|
||
}
|
||
valueStraights := []int32{}
|
||
for cardValue, count := range mapStraights {
|
||
if count >= 2 /*&& !common.InSliceInt32(valueStraights, cardValue)*/ {
|
||
valueStraights = append(valueStraights, cardValue)
|
||
}
|
||
}
|
||
if len(valueStraights) > 0 {
|
||
sort.Slice(valueStraights, func(i, j int) bool {
|
||
if valueStraights[i] > valueStraights[j] {
|
||
return false
|
||
}
|
||
return true
|
||
})
|
||
straights := FindStraightWithWidth(value, valueStraights)
|
||
if len(straights) > 0 {
|
||
randStraight := straights[rand.Intn(len(straights))] //随机一条顺子
|
||
for _, cardValue := range randStraight {
|
||
delC := 0
|
||
for i := 0; i < len(cards); i++ {
|
||
card := cards[i]
|
||
if card == InvalideCard {
|
||
continue
|
||
}
|
||
if int32(Value(card)) == cardValue && (delC < 2) { //删除2次
|
||
delC++
|
||
needCards = append(needCards, card)
|
||
cards = append(cards[:i], cards[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
haveNeed = true
|
||
}
|
||
}
|
||
|
||
return haveNeed, cards, needCards
|
||
}
|
||
|
||
func SendHandCard(poker *Poker) []int {
|
||
poker.Shuffle()
|
||
buf := poker.GetPokerBuf()
|
||
|
||
cardss := map[int][]int32{}
|
||
for i, card := range buf {
|
||
if int32(card) != InvalideCard {
|
||
index := i / 13
|
||
cardss[index] = append(cardss[index], int32(card))
|
||
}
|
||
}
|
||
|
||
type gradeInfo struct {
|
||
id int
|
||
grade int
|
||
cards []int32
|
||
}
|
||
grades := []gradeInfo{}
|
||
for i, card13 := range cardss {
|
||
cardTmp := make([]int32, 13)
|
||
copy(cardTmp, card13)
|
||
grade := GetCardsGrade(cardTmp, false)
|
||
gi := gradeInfo{
|
||
id: i,
|
||
grade: grade,
|
||
cards: card13,
|
||
}
|
||
grades = append(grades, gi)
|
||
}
|
||
|
||
sort.Slice(grades, func(i, j int) bool {
|
||
return grades[i].grade > grades[j].grade
|
||
})
|
||
|
||
//fmt.Println("grades: ", grades)
|
||
|
||
sortGrades := []int{}
|
||
for _, grade := range grades {
|
||
sortGrades = append(sortGrades, grade.grade)
|
||
}
|
||
return sortGrades
|
||
}
|
||
|
||
func MinSortCards(cs []int32) {
|
||
sort.Slice(cs, func(i, j int) bool {
|
||
vI := Value(cs[i])
|
||
vJ := Value(cs[j])
|
||
cI := Color(cs[i])
|
||
cJ := Color(cs[j])
|
||
if vI > vJ {
|
||
return false
|
||
} else if vI == vJ {
|
||
return cI < cJ
|
||
}
|
||
return true
|
||
})
|
||
}
|