samba/server/cacheta/poker/poker.go

package poker

import (
	"fmt"
	"math/rand"
	"samba/proto"
	"strings"
	"time"
	"unicode/utf8"
)

func init() {
	rand.Seed(time.Now().UnixNano())
}

// 1:第一副牌 2:第二副牌
type Ext int

const (
	Ext1 Ext = 1 // 第一副牌
	Ext2 Ext = 2 // 第二副牌
)

func (c Ext) String() string {
	switch c {
	case Ext1:
		return "1"
	case Ext2:
		return "2"
	default:
		return "unknown"
	}
}

type Color int

const (
	ColorUnknown Color = 0
	Spade        Color = 1 // 黑
	Heart        Color = 2 // 红
	Club         Color = 3 // 梅
	Diamond      Color = 4 // 方
)

func (c Color) String() string {
	switch c {
	case Spade:
		return "♠"
	case Heart:
		return "♥"
	case Club:
		return "♣"
	case Diamond:
		return "◆"
	default:
		return "unknown"
	}
}

func (c Color) Int() int { return int(c) }

type Point int

const (
	PointUnknown  Point = 0
	PointA        Point = 1
	Point2        Point = 2
	Point3        Point = 3
	Point4        Point = 4
	Point5        Point = 5
	Point6        Point = 6
	Point7        Point = 7
	Point8        Point = 8
	Point9        Point = 9
	Point10       Point = 10
	PointJ        Point = 11
	PointQ        Point = 12
	PointK        Point = 13
	PointMinJoker Point = 14
	PointMaxJoker Point = 15
)

func (p Point) String() string {
	switch p {
	case PointA:
		return "A"
	case Point2:
		return "2"
	case Point3:
		return "3"
	case Point4:
		return "4"
	case Point5:
		return "5"
	case Point6:
		return "6"
	case Point7:
		return "7"
	case Point8:
		return "8"
	case Point9:
		return "9"
	case Point10:
		return "10"
	case PointJ:
		return "J"
	case PointQ:
		return "Q"
	case PointK:
		return "K"
	case PointMinJoker:
		return "MinJoker"
	case PointMaxJoker:
		return "MaxJoker"
	default:
		return "unknown"
	}
}

func (p Point) Int() int { return int(p) }

type Poker struct {
	Color Color // 花色
	Point Point // 点数
	Ext   Ext   // 第几副牌
}

func NewPoker(value int) *Poker {
	pointColor := value % 1000
	e := Ext(value / 1000)
	return &Poker{Color: Color(pointColor / 100), Point: Point(pointColor % 100), Ext: e}
}

func NewPokerEx(c Color, p Point, e Ext) *Poker {
	return &Poker{c, p, e}
}

func (p *Poker) ToInt() int {
	return int(p.Ext)*1000 + int(p.Color*100) + int(p.Point)
}

// value会因为玩法规则导致不同牌的value一样
func (p *Poker) ToValue() int {
	c := int(Diamond * 100)
	if p.Color == Spade || p.Color == Club {
		c = int(Spade * 100)
	}
	return c + int(p.Point)
}

func (p *Poker) ToString() string {
	if p.Point != PointMinJoker && p.Point != PointMaxJoker {
		return p.Ext.String() + p.Color.String() + p.Point.String()
		//return p.Color.String() + p.Point.String()
	} else {
		return p.Point.String()
	}
}

func PokersToString(pokers []*Poker) string {
	s := ""
	if len(pokers) == 0 {
		return s
	}
	s = pokers[0].ToString()
	for i := 1; i < len(pokers); i++ {
		s += " " + pokers[i].ToString()
	}
	return s
}

// ♠4 ♥J ♥K ♣2 ♣3 ♣5 ♣7 ♣J ♣J
func StringToPoker(s string) *Poker {
	var c Color
	var p Point
	_, size := utf8.DecodeRuneInString(s)
	switch s[:size] {
	case "♠":
		c = Spade
	case "♥":
		c = Heart
	case "♣":
		c = Club
	case "◆":
		c = Diamond
	}
	switch s[size:] {
	case "A":
		p = PointA
	case "2":
		p = Point2
	case "3":
		p = Point3
	case "4":
		p = Point4
	case "5":
		p = Point5
	case "6":
		p = Point6
	case "7":
		p = Point7
	case "8":
		p = Point8
	case "9":
		p = Point9
	case "10":
		p = Point10
	case "J":
		p = PointJ
	case "Q":
		p = PointQ
	case "K":
		p = PointK
	}
	return NewPokerEx(c, p, Ext1)
}

func StringToPokers(s string) []*Poker {
	var pokers []*Poker
	parts := strings.Split(s, " ")
	for _, part := range parts {
		if part == "" {
			continue
		}
		pokers = append(pokers, StringToPoker(part))
	}
	return pokers
}

func HandPokersToPokers(handPoker proto.CachetaHandPoker) []*Poker {
	var pk []*Poker
	for _, g := range handPoker.Groups {
		for _, p := range g.Pokers {
			pk = append(pk, NewPoker(p))
		}
	}
	for _, p := range handPoker.Pokers {
		pk = append(pk, NewPoker(p))
	}
	return pk
}

func HandPokersToString(handPoker proto.CachetaHandPoker) string {
	var gp []*Poker
	gStr := ""
	for _, g := range handPoker.Groups {
		gp = gp[:0]
		for _, p := range g.Pokers {
			gp = append(gp, NewPoker(p))
		}
		gStr += PokersToString(gp) + " "
	}
	gp = gp[:0]
	for _, p := range handPoker.Pokers {
		gp = append(gp, NewPoker(p))
	}
	hStr := PokersToString(gp) + " "
	str := ""
	if gStr != "" {
		str += "组合:" + gStr + " "
	}
	if hStr != "" {
		str += "散牌:" + hStr
	}
	return str
}

func GroupsHighPokersToString(wildPoker *Poker, groups []*GroupPokers, highPokers []*Poker) string {
	gStr := ""
	for _, g := range groups {
		gStr += PokersToString(g.Pokers) + " "
	}
	hStr := PokersToString(highPokers) + " "
	str := ""
	if gStr != "" {
		str += "组合:" + gStr + " "
	}
	if hStr != "" {
		str += "散牌:" + hStr
	}
	return fmt.Sprintf("%s 万能牌:%s", str, wildPoker.ToString())
}