joker/cards.go

173 lines
3.4 KiB
Go

package cards
import "sort"
// Cards is a slice of Cards.
type Cards []Card
// StandardCards is a slice of standard cards.
var StandardCards = Cards{
Card{FaceAce, SuitHearts},
Card{Face2, SuitHearts},
Card{Face3, SuitHearts},
Card{Face4, SuitHearts},
Card{Face5, SuitHearts},
Card{Face6, SuitHearts},
Card{Face7, SuitHearts},
Card{Face8, SuitHearts},
Card{Face9, SuitHearts},
Card{Face10, SuitHearts},
Card{FaceJack, SuitHearts},
Card{FaceQueen, SuitHearts},
Card{FaceKing, SuitHearts},
Card{FaceAce, SuitDiamonds},
Card{Face2, SuitDiamonds},
Card{Face3, SuitDiamonds},
Card{Face4, SuitDiamonds},
Card{Face5, SuitDiamonds},
Card{Face6, SuitDiamonds},
Card{Face7, SuitDiamonds},
Card{Face8, SuitDiamonds},
Card{Face9, SuitDiamonds},
Card{Face10, SuitDiamonds},
Card{FaceJack, SuitDiamonds},
Card{FaceQueen, SuitDiamonds},
Card{FaceKing, SuitDiamonds},
Card{FaceAce, SuitClubs},
Card{Face2, SuitClubs},
Card{Face3, SuitClubs},
Card{Face4, SuitClubs},
Card{Face5, SuitClubs},
Card{Face6, SuitClubs},
Card{Face7, SuitClubs},
Card{Face8, SuitClubs},
Card{Face9, SuitClubs},
Card{Face10, SuitClubs},
Card{FaceJack, SuitClubs},
Card{FaceQueen, SuitClubs},
Card{FaceKing, SuitClubs},
Card{FaceAce, SuitSpades},
Card{Face2, SuitSpades},
Card{Face3, SuitSpades},
Card{Face4, SuitSpades},
Card{Face5, SuitSpades},
Card{Face6, SuitSpades},
Card{Face7, SuitSpades},
Card{Face8, SuitSpades},
Card{Face9, SuitSpades},
Card{Face10, SuitSpades},
Card{FaceJack, SuitSpades},
Card{FaceQueen, SuitSpades},
Card{FaceKing, SuitSpades},
}
func (c Cards) Len() int {
return len(c)
}
func (c Cards) Less(i, j int) bool {
return c[i].Value() < c[j].Value()
}
func (c Cards) Swap(i, j int) {
c[i], c[j] = c[j], c[i]
}
// Copy returns a copy of the supplied cards.
func (c Cards) Copy() Cards {
cc := make(Cards, len(c))
copy(cc, c)
return cc
}
// Remove returns the supplied cards excluding the card at the specified index.
func (c Cards) Remove(i int) Cards {
cc := c.Copy()
return append(cc[:i], cc[i+1:]...)
}
// Contains returns whether the supplied cards contain the specified card.
func (c Cards) Contains(card Card) bool {
for _, compcard := range c {
if compcard.Equal(card) {
return true
}
}
return false
}
// Count returns the number of occurrences of the specified card.
func (c Cards) Count(card Card) int {
var n int
for _, compcard := range c {
if compcard.Equal(card) {
n++
}
}
return n
}
// Equal returns whether the supplied cards are equal to another set of cards.
func (c Cards) Equal(cards Cards) bool {
if len(c) != len(cards) {
return false
}
for _, compcard := range c {
if c.Count(compcard) != cards.Count(compcard) {
return false
}
}
return true
}
// Sorted returns the supplied cards in order.
func (c Cards) Sorted() Cards {
cc := c.Copy()
sort.Sort(cc)
return cc
}
// Reversed returns the supplied cards in reverse order.
func (c Cards) Reversed() Cards {
l := len(c)
cc := make(Cards, l)
for i := 0; i < l; i++ {
cc[i] = c[l-i-1]
}
return cc
}
// Low returns the lowest valued card.
func (c Cards) Low() Card {
if len(c) == 0 {
return Card{}
}
l := c[0]
for _, comp := range c[1:] {
if comp.Value() < l.Value() {
l = comp
}
}
return l
}
// High returns the highest valued card.
func (c Cards) High() Card {
if len(c) == 0 {
return Card{}
}
h := c[0]
for _, comp := range c[1:] {
if comp.Value() > h.Value() {
h = comp
}
}
return h
}