707 lines
14 KiB
Go
707 lines
14 KiB
Go
package baccarat
|
|
|
|
import (
|
|
"math/rand"
|
|
)
|
|
|
|
//开和
|
|
func (this *Poker) GetTIE() (cards []int32) {
|
|
for k := 0; k < 20; k++ {
|
|
banker := [3]int32{-1, -1, -1}
|
|
xian := [3]int32{-1, -1, -1}
|
|
for i := 0; i < 2; i++ {
|
|
c, _ := this.Next()
|
|
banker[i] = c
|
|
}
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
xc, _ := this.Next()
|
|
xian[0] = xc
|
|
bankNum := num(banker)
|
|
c := int(xian[0]%13 + 1)
|
|
if c >= 10 {
|
|
c = 0
|
|
}
|
|
nc := this.FindCard(int32(bankNum - c))
|
|
if nc == -1 {
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
xian[1] = nc
|
|
if isPair(xian) {
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
} else {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//开庄赢 没有对子
|
|
func (this *Poker) GetBankerWin() (cards []int32) {
|
|
banker := [3]int32{-1, -1, -1}
|
|
xian := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 20; k++ {
|
|
for i := 0; i < 2; i++ {
|
|
c, _ := this.Next()
|
|
banker[i] = c
|
|
}
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
for i := 0; i < 2; i++ {
|
|
c, _ := this.Next()
|
|
xian[i] = c
|
|
}
|
|
if isPair(xian) {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
bankerNum := num(banker)
|
|
xianNum := num(xian)
|
|
if bankerNum > xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else if bankerNum < xianNum {
|
|
cards = append(cards, banker[:]...)
|
|
cards = append(cards, xian[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
banker = [3]int32{-1, -1, -1}
|
|
xian = [3]int32{-1, -1, -1}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//开闲赢 没有对子
|
|
func (this *Poker) GetXianWin() (cards []int32) {
|
|
banker := [3]int32{-1, -1, -1}
|
|
xian := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 20; k++ {
|
|
for i := 0; i < 2; i++ {
|
|
c, _ := this.Next()
|
|
banker[i] = c
|
|
}
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
for i := 0; i < 2; i++ {
|
|
c, _ := this.Next()
|
|
xian[i] = c
|
|
}
|
|
if isPair(xian) {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
bankerNum := num(banker)
|
|
xianNum := num(xian)
|
|
if bankerNum > xianNum {
|
|
cards = append(cards, banker[:]...)
|
|
cards = append(cards, xian[:]...)
|
|
return
|
|
} else if bankerNum < xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
banker = [3]int32{-1, -1, -1}
|
|
xian = [3]int32{-1, -1, -1}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//开庄赢 带庄对
|
|
func (this *Poker) GetBankerAndBankerPair() (cards []int32) {
|
|
banker := [3]int32{-1, -1, -1}
|
|
irand := this.GetRandPair()
|
|
if irand == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
banker = [3]int32{npair[0], npair[1], -1}
|
|
bankerNum := num(banker)
|
|
for i := 0; i < 20; i++ {
|
|
xian := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 2; k++ {
|
|
c, _ := this.Next()
|
|
xian[k] = c
|
|
}
|
|
if isPair(xian) {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
xianNum := num(xian)
|
|
if bankerNum > xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(xian[:])
|
|
}
|
|
}
|
|
this.PutIn(banker[:])
|
|
return nil
|
|
}
|
|
|
|
//开庄赢 带闲对
|
|
func (this *Poker) GetBankerAndXianPair() (cards []int32) {
|
|
xian := [3]int32{-1, -1, -1}
|
|
irand := this.GetRandPair()
|
|
if irand == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
xian = [3]int32{npair[0], npair[1], -1}
|
|
|
|
xianNum := num(xian)
|
|
for i := 0; i < 20; i++ {
|
|
banker := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 2; k++ {
|
|
c, _ := this.Next()
|
|
banker[k] = c
|
|
}
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
bankerNum := num(banker)
|
|
if bankerNum > xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(banker[:])
|
|
}
|
|
}
|
|
this.PutIn(xian[:])
|
|
return nil
|
|
}
|
|
|
|
//开闲赢 带闲对
|
|
func (this *Poker) GetXianAndXianPair() (cards []int32) {
|
|
xian := [3]int32{-1, -1, -1}
|
|
imax := this.GetRandPair()
|
|
if imax == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{imax, imax})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
xian = [3]int32{npair[0], npair[1], -1}
|
|
xianNum := num(xian)
|
|
for i := 0; i < 20; i++ {
|
|
banker := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 2; k++ {
|
|
c, _ := this.Next()
|
|
banker[k] = c
|
|
}
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
bankerNum := num(banker)
|
|
if bankerNum < xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(banker[:])
|
|
}
|
|
}
|
|
this.PutIn(xian[:])
|
|
return nil
|
|
}
|
|
|
|
//开闲赢 带庄对
|
|
func (this *Poker) GetXianAndBankerPair() (cards []int32) {
|
|
banker := [3]int32{-1, -1, -1}
|
|
irand := this.GetRandPair()
|
|
if irand == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
banker = [3]int32{npair[0], npair[1], -1}
|
|
bankerNum := num(banker)
|
|
for i := 0; i < 20; i++ {
|
|
xian := [3]int32{-1, -1, -1}
|
|
for k := 0; k < 2; k++ {
|
|
c, _ := this.Next()
|
|
xian[k] = c
|
|
}
|
|
if isPair(xian) {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
xianNum := num(xian)
|
|
if bankerNum < xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(xian[:])
|
|
}
|
|
}
|
|
this.PutIn(banker[:])
|
|
return nil
|
|
}
|
|
|
|
//开和赢 带庄对
|
|
func (this *Poker) GetTieAndBankerPair() (cards []int32) {
|
|
banker := [3]int32{-1, -1, -1}
|
|
irand := this.GetRandPair()
|
|
if irand == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
banker = [3]int32{npair[0], npair[1], -1}
|
|
bankerNum := num(banker)
|
|
for i := 0; i < 20; i++ {
|
|
xian := [3]int32{-1, -1, -1}
|
|
//for k := 0; k < 2; k++ {
|
|
// c, _ := this.Next()
|
|
// xian[k] = c
|
|
//}
|
|
|
|
c, _ := this.Next()
|
|
xian[0] = c
|
|
bn := bankerNum
|
|
xn := c%13 + 1
|
|
if xn >= 10 {
|
|
xn = 0
|
|
}
|
|
if bankerNum < int(xn) {
|
|
bn += 10
|
|
}
|
|
another := this.FindCard(int32(bn) - xn)
|
|
if another == -1 {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
xian[1] = another
|
|
|
|
if isPair(xian) {
|
|
this.PutIn(xian[:])
|
|
continue
|
|
}
|
|
xianNum := num(xian)
|
|
if bankerNum == xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(xian[:])
|
|
}
|
|
}
|
|
this.PutIn(banker[:])
|
|
return nil
|
|
}
|
|
|
|
//开和赢 带闲对
|
|
func (this *Poker) GetTieAndXianPair() (cards []int32) {
|
|
xian := [3]int32{-1, -1, -1}
|
|
imax := this.GetRandPair()
|
|
if imax == -1 {
|
|
return nil
|
|
}
|
|
buf, npair := delSclice(this.buf, []int32{imax, imax})
|
|
if len(npair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
xian = [3]int32{npair[0], npair[1], -1}
|
|
xianNum := num(xian)
|
|
for i := 0; i < 20; i++ {
|
|
banker := [3]int32{-1, -1, -1}
|
|
c, _ := this.Next()
|
|
banker[0] = c
|
|
xn := xianNum
|
|
bn := c%13 + 1
|
|
if bn >= 10 {
|
|
bn = 0
|
|
}
|
|
if xianNum < int(bn) {
|
|
xn += 10
|
|
}
|
|
another := this.FindCard(int32(xn) - bn)
|
|
if another == -1 {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
banker[1] = another
|
|
if isPair(banker) {
|
|
this.PutIn(banker[:])
|
|
continue
|
|
}
|
|
bankerNum := num(banker)
|
|
if bankerNum == xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else {
|
|
this.PutIn(banker[:])
|
|
}
|
|
}
|
|
this.PutIn(xian[:])
|
|
return nil
|
|
}
|
|
|
|
//开庄赢 开庄对 闲对
|
|
func (this *Poker) GetBankerAndBankerXianPair() (cards []int32) {
|
|
irand := this.GetMinRandPair()
|
|
if irand == -1 {
|
|
return nil
|
|
}
|
|
imax := this.GetMaxPair(irand)
|
|
if imax == -1 {
|
|
return nil
|
|
}
|
|
|
|
buf, minpair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(minpair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
buf2, maxpair := delSclice(this.buf, []int32{imax, imax})
|
|
if len(maxpair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf2
|
|
banker := [3]int32{maxpair[0], maxpair[1], -1}
|
|
xian := [3]int32{minpair[0], minpair[1], -1}
|
|
|
|
bankerNum := num(banker)
|
|
xianNum := num(xian)
|
|
if bankerNum > xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else if bankerNum < xianNum {
|
|
cards = append(cards, banker[:]...)
|
|
cards = append(cards, xian[:]...)
|
|
return
|
|
}
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
return nil
|
|
}
|
|
|
|
//开闲赢 开庄对 闲对
|
|
func (this *Poker) GetXianAndBankerXianPair() (cards []int32) {
|
|
irand := this.GetMinRandPair()
|
|
if irand == 100 {
|
|
return nil
|
|
}
|
|
imax := this.GetMaxPair(irand)
|
|
if imax == -1 {
|
|
return nil
|
|
}
|
|
|
|
buf, minpair := delSclice(this.buf, []int32{irand, irand})
|
|
if len(minpair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
buf2, maxpair := delSclice(this.buf, []int32{imax, imax})
|
|
if len(maxpair) != 2 {
|
|
return nil
|
|
}
|
|
this.buf = buf2
|
|
xian := [3]int32{maxpair[0], maxpair[1], -1}
|
|
banker := [3]int32{minpair[0], minpair[1], -1}
|
|
|
|
bankerNum := num(banker)
|
|
xianNum := num(xian)
|
|
if bankerNum < xianNum {
|
|
cards = append(cards, xian[:]...)
|
|
cards = append(cards, banker[:]...)
|
|
return
|
|
} else if bankerNum > xianNum {
|
|
cards = append(cards, banker[:]...)
|
|
cards = append(cards, xian[:]...)
|
|
return
|
|
}
|
|
this.PutIn(banker[:])
|
|
this.PutIn(xian[:])
|
|
return nil
|
|
}
|
|
|
|
//开和 开庄对 闲对
|
|
func (this *Poker) GetTieAndBankerXianPair() (cards []int32) {
|
|
ifour := this.GetFourCards()
|
|
if ifour == -1 {
|
|
return nil
|
|
}
|
|
buf, ifours := delSclice(this.buf, []int32{ifour, ifour, ifour, ifour})
|
|
if len(ifours) != 4 {
|
|
return nil
|
|
}
|
|
this.buf = buf
|
|
return []int32{ifours[0], ifours[1], -1, ifours[2], ifours[3], -1}
|
|
}
|
|
func (this *Poker) GetFourCards() int32 {
|
|
ipairs := make(map[int32]int)
|
|
for _, v := range this.buf {
|
|
ipairs[v%13+1]++
|
|
}
|
|
isclice := make([]int32, 0)
|
|
for k, v := range ipairs {
|
|
if v >= 4 {
|
|
isclice = append(isclice, k)
|
|
}
|
|
}
|
|
if len(isclice) == 0 {
|
|
return -1
|
|
}
|
|
return isclice[rand.Intn(len(isclice))]
|
|
}
|
|
func (this *Poker) GetRandPair() int32 {
|
|
ipairs := make(map[int32]int)
|
|
randpair := make([]int32, 0)
|
|
for _, v := range this.buf {
|
|
i := v%13 + 1
|
|
ipairs[i]++
|
|
if ipairs[i] >= 2 {
|
|
isHave := false
|
|
for _, n := range randpair {
|
|
if n == i {
|
|
isHave = true
|
|
break
|
|
}
|
|
}
|
|
if !isHave {
|
|
randpair = append(randpair, i)
|
|
}
|
|
}
|
|
}
|
|
if len(randpair) == 0 {
|
|
return -1
|
|
}
|
|
optimal := make([]int32, 0)
|
|
for _, v := range randpair {
|
|
if v < 10 {
|
|
optimal = append(optimal, v)
|
|
}
|
|
}
|
|
if len(optimal) > 0 {
|
|
return optimal[rand.Intn(len(optimal))]
|
|
}
|
|
return randpair[rand.Intn(len(randpair))]
|
|
}
|
|
func (this *Poker) GetMinRandPair() int32 {
|
|
ipairs := make(map[int32]int)
|
|
randpair := make([]int32, 0)
|
|
for _, v := range this.buf {
|
|
i := v%13 + 1
|
|
if i == 1 || i == 2 || i == 6 || i == 7 {
|
|
ipairs[i]++
|
|
}
|
|
if ipairs[i] >= 2 {
|
|
randpair = append(randpair, i)
|
|
}
|
|
}
|
|
if len(randpair) == 0 {
|
|
return -1
|
|
}
|
|
return randpair[rand.Intn(len(randpair))]
|
|
}
|
|
func (this *Poker) GetMaxPair(irand int32) int32 {
|
|
ipairs := make(map[int32]int)
|
|
imaxpair := make([]int32, 0)
|
|
for _, v := range this.buf {
|
|
i := v%13 + 1
|
|
ipairs[i]++
|
|
if i < 10 && i > irand && ipairs[i] >= 2 {
|
|
imaxpair = append(imaxpair, i)
|
|
}
|
|
}
|
|
if len(imaxpair) == 0 {
|
|
return -1
|
|
}
|
|
return imaxpair[rand.Intn(len(imaxpair))]
|
|
}
|
|
func delSclice(y, d []int32) (ny, np []int32) {
|
|
ny = make([]int32, len(y))
|
|
np = make([]int32, 0)
|
|
copy(ny, y)
|
|
cmap := make(map[int32]int)
|
|
for i := 0; i < len(d); i++ {
|
|
for k, v := range ny {
|
|
c := v%13 + 1
|
|
color := rand.Int31n(4)
|
|
if cmap[color] >= 1 {
|
|
color++
|
|
color = color % 4
|
|
}
|
|
if c == d[i] && (v%52+1)/13 == color {
|
|
cmap[color]++
|
|
np = append(np, v%52)
|
|
ny = append(ny[:k], ny[k+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return ny, np
|
|
}
|
|
|
|
func num(cards [3]int32) (num int) {
|
|
for _, c := range cards {
|
|
temp := int(c%13 + 1)
|
|
if temp > 0 && temp < 10 {
|
|
num += temp
|
|
if num >= 10 {
|
|
num -= 10
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func isPair(cards [3]int32) bool {
|
|
a := cards[0]%13 + 1
|
|
b := cards[1]%13 + 1
|
|
c := cards[2]%13 + 1
|
|
if a != b && a != c && b != c {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
//单控补牌
|
|
func (this *Poker) SingleRepairCard(cards []int32) (bool, []int32) {
|
|
xianPoint := GetPointNum(cards[:], 0, 1) //闲家点数
|
|
bankerPoint := GetPointNum(cards[:], 3, 4) //庄家点数
|
|
if xianPoint == 8 || xianPoint == 9 ||
|
|
bankerPoint == 8 || bankerPoint == 9 {
|
|
return true, cards
|
|
}
|
|
|
|
xianRepair := make(map[int32]bool)
|
|
for i := int32(0); i <= 5; i++ {
|
|
xianRepair[i] = true
|
|
}
|
|
xianNotRepair := make([]int32, 0)
|
|
|
|
if bankerPoint == 3 {
|
|
xianNotRepair = append(xianNotRepair, 8)
|
|
} else if bankerPoint == 4 {
|
|
xianNotRepair = append(xianNotRepair, 8, 9, 0)
|
|
} else if bankerPoint == 5 {
|
|
xianNotRepair = append(xianNotRepair, 1, 2, 3, 8, 9, 0)
|
|
} else if bankerPoint == 6 {
|
|
xianNotRepair = append(xianNotRepair, 1, 2, 3, 4, 5, 8, 9, 0)
|
|
} else if bankerPoint == 7 {
|
|
if _, ok := xianRepair[xianPoint]; ok {
|
|
//闲必须补0
|
|
for i := 0; i < this.Count(); i++ {
|
|
c, _ := this.Next()
|
|
if (c%13 + 1) >= 10 {
|
|
cards[2] = c % 52
|
|
return true, cards
|
|
} else {
|
|
this.PutIn([]int32{c})
|
|
}
|
|
}
|
|
}
|
|
return true, cards
|
|
}
|
|
//庄补牌
|
|
bankerNeedCard := func() bool {
|
|
xianrepair := cards[2]
|
|
if xianrepair == -1 && bankerPoint == 6 {
|
|
return true
|
|
}
|
|
for i := 0; i < this.Count(); i++ {
|
|
c, _ := this.Next()
|
|
repair := c%13 + 1
|
|
bankerpt := bankerPoint
|
|
if repair < 10 {
|
|
bankerpt += repair
|
|
if bankerpt >= 10 {
|
|
bankerpt -= 10
|
|
}
|
|
}
|
|
xianpt := GetPointNum(cards[:], 0, 1, 2)
|
|
if (bankerPoint > xianPoint && bankerpt > xianpt) ||
|
|
(bankerPoint < xianPoint && bankerpt < xianpt) ||
|
|
(bankerPoint == xianPoint && bankerpt == xianpt) {
|
|
cards[5] = c % 52
|
|
return true
|
|
}
|
|
this.PutIn([]int32{c})
|
|
}
|
|
return false
|
|
}
|
|
//闲补牌
|
|
if _, ok := xianRepair[xianPoint]; ok {
|
|
for i := 0; i < this.Count(); i++ {
|
|
c, _ := this.Next()
|
|
repair := c%13 + 1
|
|
isHave := false
|
|
for _, v := range xianNotRepair {
|
|
rnew := repair
|
|
if rnew >= 10 {
|
|
rnew = 0
|
|
}
|
|
if rnew == v {
|
|
isHave = true
|
|
break
|
|
}
|
|
}
|
|
//三张牌一样
|
|
isSame := cards[0]%13+1 == cards[1]%13+1 && cards[0]%13+1 == repair && cards[1]%13+1 == repair
|
|
if !isHave {
|
|
//20%的概率 三张相同
|
|
r := rand.Intn(100)
|
|
if isSame && r < 80 {
|
|
this.PutIn([]int32{c})
|
|
continue
|
|
}
|
|
cards[2] = c % 52
|
|
if bankerNeedCard() {
|
|
return true, cards
|
|
} else {
|
|
cards[2] = -1
|
|
}
|
|
}
|
|
this.PutIn([]int32{c})
|
|
}
|
|
}
|
|
if bankerNeedCard() {
|
|
return true, cards
|
|
}
|
|
return false, cards
|
|
}
|