Five Card Draw for Gophers

package poker

type deck [52]string

var suits = []string{"S", "H", "D", "C"}
var cards = []string{"A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"}

func newDeck() *deck {
    d := &deck{}
    for i, s := range suits {
        for j, c := range cards {
            d[i*13+j] = c + s
        }
    }
    return d
}

// shuffles the deck in place
func (d *deck) shuffle() {
    for i := len(d) - 1; i > 0; i-- {
        j := rand.Intn(i + 1)
        d[i], d[j] = d[j], d[i]
    }
}

const (
    stateReady = iota
    stateDealt
)

type Game interface {
    // Deal initializes the game, returning the player's initial hand and new balance
    Deal() (Hand, int, error)

    // Exchange accepts a slice of integers corresponding to indicies for cards in the given hand
    // It discards those cards from the hand and replaces them with new cards from the deck
    // It returns the final hand and the new balance
    Exchange([]int) (Hand, int)
}

type game struct {
    deck    *deck
    state   int
    anty    int
    balance int
    hand    Hand
    mutex   *sync.Mutex
}

func NewGame(anty int, balance int) Game {
    return &game{
        deck:    newDeck(),
        state:   stateReady,
        anty:    anty,
        balance: balance,
        mutex:   &sync.Mutex{},
    }
}

func (g *game) Deal() (Hand, int, error) {
    g.mutex.Lock()
    defer g.mutex.Unlock()
    if g.balance < g.anty {
        return Hand{}, g.balance, ErrNoBalance
    }
    g.deck.shuffle()
    g.balance -= g.anty
    g.hand = newHand(g.deck[0:5])
    g.state = stateDealt
    return g.hand, g.balance, nil
}

func (g *game) Exchange(cards []int) (Hand, int) {
    g.mutex.Lock()
    defer g.mutex.Unlock()
    if g.state != stateDealt {
        return g.hand, g.balance
    }
    hand := g.hand
    for i, n := range cards {
        if n >= len(hand) {
            continue
        }
        hand[n] = g.deck[i+5]
    }
    res := hand.Score()
    g.balance += payout[res]
    if payout[res] > 0 {
        g.balance += g.anty
    }
    g.state = stateReady
    return hand, g.balance
}

const (
    Hand_RoyalFlush    = "Royal Flush"
    Hand_StraightFlush = "Straight Flush"
    Hand_Quads         = "Four of a Kind"
    Hand_FullHouse     = "Full House"
    Hand_Flush         = "Flush"
    Hand_Straight      = "Straight"
    Hand_Trips         = "Three of a Kind"
    Hand_TwoPair       = "Two Pair"
    Hand_Jacks         = "Jacks or Higher"
    Hand_Nothing       = "Nothing"
)

type Hand [5]string

// Score scores the hand
func (h Hand) Score() string {
    if len(h[0]) < 1 {
        return Hand_Nothing
    }
    if h.isFlush() {
        if h.isRoyal() {
            return Hand_RoyalFlush
        }
        if h.isStraight() {
            return Hand_StraightFlush
        }
        return Hand_Flush
    }
    if h.isStraight() {
        return Hand_Straight
    }
    pairs, trips, quads, highPair := h.detectDupes()
    if quads > 0 {
        return Hand_Quads
    }
    if trips > 0 {
        if pairs > 0 {
            return Hand_FullHouse
        }
        return Hand_Trips
    }
    if pairs > 1 {
        return Hand_TwoPair
    }
    if pairs == 1 && highPair {
        return Hand_Jacks
    }
    return Hand_Nothing
}

// Table based test to ensure correct scoring of hands
func TestScoreHand(t *testing.T) {
    var tests = map[string]string{
        "AS KS QS JS TS": Hand_RoyalFlush,
        "JD TD AD QD KD": Hand_RoyalFlush,
        "KS QS JS TS 9S": Hand_StraightFlush,
        "KS KH KD KC 9S": Hand_Quads,
        "KS 9S KH KD KC": Hand_Quads,
        "KS 9S KH KD 9C": Hand_FullHouse,
        "TS 8S QS JS 4S": Hand_Flush,
        "AS KD QS JS TS": Hand_Straight,
        "AS AH AD JS TS": Hand_Trips,
        "AS AH JS AD 4S": Hand_Trips,
        "AS AH JS JD 4S": Hand_TwoPair,
        "AS JD 4S AH JS": Hand_TwoPair,
        "AS JD AH JS 4S": Hand_TwoPair,
        "AS AD 8H JS 4S": Hand_Jacks,
        "JS JD 8H 9S 4S": Hand_Jacks,
        "TS TD 8H 9S 4S": Hand_Nothing,
    }
    for c, exp := range tests {
        h := newHand(strings.Split(c, " "))
        res := h.Score()
        if exp != res {
            t.Log("Unexpected Result", h, res, "!=", exp)
            t.Fail()
        }
    }
}