1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
package game
import (
"log"
"math/rand"
"strconv"
"strings"
)
type Deck struct {
PileOfCardsBase
}
func NewDeck() *Deck {
d := Deck{PileOfCardsBase{[]*Card{}}}
return &d
}
func (d *Deck) Shuffle(r *rand.Rand) {
r.Shuffle(d.Size(), func(i, j int) {
d.cards[i], d.cards[j] = d.cards[j], d.cards[i]
})
}
func (d *Deck) Draw(amount int) []*Card {
if d.Size() < amount {
drawn := d.cards
d.cards = []*Card{}
return drawn
}
drawn := d.cards[0:amount]
d.cards = d.cards[amount:]
return drawn
}
func (d *Deck) DrawOne() *Card {
drawn := d.Draw(1)
if len(drawn) == 0 {
return nil
}
return drawn[0]
}
func NewDeckFrom(cards PileOfCards) *Deck {
d := NewDeck()
cards.MoveInto(d)
return d
}
func NewDeckFromCardPaths(cardPaths []string) *Deck {
d := NewDeck()
for _, cardPath := range cardPaths {
card := NewCard(cardPath)
d.AddCard(card)
}
return d
}
func NewDeckFromDeckList(deckList string) *Deck {
cardPaths := []string{}
// trim last trailing newline
deckList = strings.Trim(deckList, "\n")
lines := strings.SplitSeq(deckList, "\n")
for line := range lines {
tokens := strings.SplitN(line, " ", 2)
cardPath := tokens[1]
amount, err := strconv.Atoi(tokens[0])
if err != nil {
log.Fatal(err)
}
for range amount {
cardPaths = append(cardPaths, cardPath)
}
}
return NewDeckFromCardPaths(cardPaths)
}
func NewRandomDeck(n int, sets []SetIdentifier) *Deck {
deck := NewDeck()
pool := NewDeck()
for _, set := range sets {
NewDeckFromCardPaths(set.CardPaths()).MoveInto(pool)
}
cards := NewRandomPackFromPool(pool, n)
cards.MoveInto(deck)
return deck
}
|
