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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
package game
import (
"fmt"
"log"
"math/rand"
"strings"
)
type Draft struct {
players []*Player
cardsPerPack int
packSize int
packsPerPlayer int
sets []SetIdentifier
}
func NewDraftFromDesc(players []*Player, desc string) *Draft {
var setList string
s := strings.Split(desc, ":")
desc, setList = s[0], s[1]
if sets, err := SetListToSets(setList); err != nil {
log.Fatal(err)
} else {
return NewDraft(players, desc, sets)
}
// not reachable
return nil
}
func NewDraft(players []*Player, desc string, sets []SetIdentifier) *Draft {
d := &Draft{players: players, sets: sets}
d.parseDesc(desc)
log.Printf("created new draft %v\n", d)
return d
}
func (d *Draft) parseDesc(desc string) {
fmt.Sscanf(desc, "%dx[%d;%d]", &d.packsPerPlayer, &d.cardsPerPack, &d.packSize)
}
func (d *Draft) Valid() bool {
if d.packSize < d.cardsPerPack*len(d.players) {
return false
}
return true
}
// run the draft
// This method only returns after the draft has finished.
func (d *Draft) Run() {
pool := NewPileOfCards()
requiredCards := d.packsPerPlayer * d.packSize
for pool.Size() < requiredCards {
for _, set := range d.sets {
setDeck := NewDeck()
for _, c := range NewDeckFromCardPaths(set.CardPaths()).Cards() {
if c.IsBuyable() {
setDeck.AddCard(c)
}
}
setDeck.MoveInto(pool)
}
}
nPlayers := len(d.players)
packs := make([]PileOfCards, 0, nPlayers*d.packsPerPlayer)
for range len(d.players) * d.packsPerPlayer {
pack := NewRandomPackFromPool(pool, d.packSize)
packs = append(packs, pack)
}
log.Printf("%d %d %d\n", d.packsPerPlayer, d.cardsPerPack, len(d.players))
for i := range d.packsPerPlayer {
for j := range d.cardsPerPack * len(d.players) {
for k, player := range d.players {
pack := packs[i*nPlayers+(k+j)%nPlayers]
pickPrompt := newDraftPickPrompt(pack)
log.Printf("prompt %s for a pick from pack %d\n", player.Name, i*nPlayers+(k+j)%nPlayers)
pick := prompt(player.Ctrl, pickPrompt)
pick.resolve(player.gameState)
}
}
}
}
func (d *Draft) AddPlayer(p *Player) {
if p.Ctrl == nil {
log.Fatal("added player without control")
}
d.players = append(d.players, p)
}
type randomDraftAiCtrl struct {
ai *Player
pack PileOfCards
}
func (ctrl *randomDraftAiCtrl) Player() *Player {
return ctrl.ai
}
func (ctrl *randomDraftAiCtrl) Close() {
}
func (ctrl *randomDraftAiCtrl) SendNotification(n PlayerNotification) {
ctrl.pack = n.Context.(PileOfCards)
}
func (ctrl *randomDraftAiCtrl) RecvAction() Action {
availCards := ctrl.pack.Cards()
var pick int
if n := len(availCards); n > 1 {
pick = rand.Intn(n - 1)
} else {
pick = 0
}
return NewDraftPick(ctrl.ai, ctrl.pack, availCards[pick])
}
func (d *Draft) AddRandomAi() {
p := &Player{Id: -1, Name: "randomDraftAI", Deck: NewDeck()}
p.Ctrl = &randomDraftAiCtrl{ai: p}
d.players = append(d.players, p)
}
|
