go-poker/pokercore/pokercore.go

package pokercore

import (
	"encoding/binary"
	"fmt"
	"sort"

	crand "crypto/rand"

	"github.com/logrusorgru/aurora/v4"

	log "github.com/sirupsen/logrus"

	"strings"
)

type Suit rune

func (s Suit) String() string {
	return string(s)
}

type Rank rune

func (r Rank) String() string {
	return string(r)
}

const (
	CLUB    Suit = '\u2663' // ♣
	SPADE   Suit = '\u2660' // ♠
	DIAMOND Suit = '\u2666' // ♦
	HEART   Suit = '\u2665' // ♥
)

const (
	ACE   Rank = 'A'
	DEUCE Rank = '2'
	THREE Rank = '3'
	FOUR  Rank = '4'
	FIVE  Rank = '5'
	SIX   Rank = '6'
	SEVEN Rank = '7'
	EIGHT Rank = '8'
	NINE  Rank = '9'
	TEN   Rank = 'T'
	JACK  Rank = 'J'
	QUEEN Rank = 'Q'
	KING  Rank = 'K'
)

type Card struct {
	Rank Rank
	Suit Suit
}

type Cards []Card

func (r Rank) Int(x AcesHighOrLow) int {
	return int(rankToScore(r, x))
}

func (r Rank) HandScore(x AcesHighOrLow) HandScore {
	return HandScore(r.Int(x))
}

func (c Cards) SortByRank(x AcesHighOrLow) Cards {

	newCards := make(Cards, len(c))
	copy(newCards, c)

	sort.Slice(newCards, func(i, j int) bool {
		return rankToScore(newCards[i].Rank, x) > rankToScore(newCards[j].Rank, x)
	})
	return newCards
}

type TestGenerationIteration struct {
	Deck *Deck
	Seed int64
}

func (c Cards) PrintToTerminal() {
	fmt.Printf("%s", c.FormatCardsForTerminal())
}

func (c Cards) FormatCardsForTerminal() string {
	var cardstrings []string
	for i := 0; i < len(c); i++ {
		cardstrings = append(cardstrings, c[i].FormatForTerminal())
	}
	return strings.Join(cardstrings, ",")
}

func (c Card) FormatForTerminal() string {
	var rank string
	var suit string
	color := aurora.Red
	switch c.Suit {
	case Suit(DIAMOND):
		color = aurora.Blue
	case Suit(HEART):
		color = aurora.Red
	case Suit(CLUB):
		color = aurora.Green
	case Suit(SPADE):
		color = aurora.Black
	}

	rank = fmt.Sprintf("%s", aurora.Bold(color(c.Rank.String())))
	suit = fmt.Sprintf("%s", aurora.Bold(color(c.Suit.String())))
	return fmt.Sprintf("%s%s", rank, suit)
}

func cryptoUint64() (v uint64) {
	err := binary.Read(crand.Reader, binary.BigEndian, &v)
	if err != nil {
		log.Fatal(err)
	}
	log.Debugf("crand cryptosource is returning Uint64: %d", v)
	return v
}

func (c *Card) String() string {
	return fmt.Sprintf("%s%s", string(c.Rank), string(c.Suit))
}

func (c Cards) HighestRank(x AcesHighOrLow) Rank {
	c = c.SortByRank(x)
	return c[0].Rank
}

func (s Cards) String() (output string) {
	var cardstrings []string
	for i := 0; i < len(s); i++ {
		cardstrings = append(cardstrings, s[i].String())
	}
	output = strings.Join(cardstrings, ",")
	return output
}

func generate() {
	log.SetLevel(log.DebugLevel)
}

func proto() {
	myDeck := NewDeck()
	myDeck.ShuffleDeterministically(42)
	myHand := myDeck.Deal(2)
	//spew.Dump(myHand)
	fmt.Printf("my hand: %s\n", myHand)
	cmty := myDeck.Deal(5)
	fmt.Printf("community: %s\n", cmty)
}

func contains(ranks []Rank, rank Rank) bool {
	for _, r := range ranks {
		if r == rank {
			return true
		}
	}
	return false
}

func unique(intSlice []int) []int {
	keys := make(map[int]bool)
	list := []int{}
	for _, entry := range intSlice {
		if _, value := keys[entry]; !value {
			keys[entry] = true
			list = append(list, entry)
		}
	}
	return list
}