From d47c249bd1fe9e05ac9c0347fb42a548a50b198b Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Fri, 19 Jan 2018 16:15:47 -0800 Subject: [PATCH 01/16] Use __str__ instead of __repr__. --- src/card.py | 2 +- src/game.py | 7 ++----- src/player.py | 13 ++++++++----- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/card.py b/src/card.py index ff86f53..9fa68ee 100644 --- a/src/card.py +++ b/src/card.py @@ -16,7 +16,7 @@ def __init__(self, name, type, cost, play, score): self.play = play self.score = score - def __repr__(self): + def __str__(self): return self.name diff --git a/src/game.py b/src/game.py index a402f53..174906d 100644 --- a/src/game.py +++ b/src/game.py @@ -1,7 +1,6 @@ from enum import Enum import kingdom import player -import card class Phase(Enum): @@ -13,16 +12,14 @@ class Phase(Enum): class Game(object): def __init__(self, supply): self.kingdom = kingdom.Kingdom(supply) - self.players = [ - player.Player([card.Estate]*3 + [card.Copper]*7), - player.Player([card.Estate]*3 + [card.Copper]*7)] + self.players = [player.Player(), player.Player()] for p in self.players: p.draw(5) self.play = [] self.trash = [] self.setup_turn(0) - def __repr__(self): + def __str__(self): result = "" result += "Kingdom:\n" + str(self.kingdom) + "\n" result += "Play:\n" + str(self.play) + "\n" diff --git a/src/player.py b/src/player.py index b93af14..0ff437c 100644 --- a/src/player.py +++ b/src/player.py @@ -1,19 +1,22 @@ import util import random +import card class Player(object): - def __init__(self, deck): + def __init__(self): self.deck = [] - self.discard = deck + self.discard = [card.Estate, card.Estate, card.Estate, + card.Copper, card.Copper, card.Copper, card.Copper, + card.Copper, card.Copper, card.Copper] self.hand = [] self.score = 0 - def __repr__(self): + def __str__(self): result = "" result += "Hand:\n" - for card in self.hand: - result += repr(card) + " " + for c in self.hand: + result += str(c) + " " result += "\n" result += "Deck: %d cards\n" % len(self.deck) result += "Discard: %d cards\n" % len(self.discard) From cf0dbbb7fcf37f87ee3cf5a2f79a9b7c9e6ca126 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sat, 10 Mar 2018 17:54:43 -0800 Subject: [PATCH 02/16] Fix some bugs. --- src/card.py | 31 +++++++++++++++++++++++++------ src/kingdom.py | 29 ++++++++++++++++++++++------- src/pile.py | 6 ------ src/player.py | 7 ++++--- 4 files changed, 51 insertions(+), 22 deletions(-) delete mode 100644 src/pile.py diff --git a/src/card.py b/src/card.py index 9fa68ee..f89955c 100644 --- a/src/card.py +++ b/src/card.py @@ -1,6 +1,9 @@ from enum import Enum +cards = [] + + class Type(Enum): Victory = 0 Treasure = 1 @@ -15,6 +18,7 @@ def __init__(self, name, type, cost, play, score): self.cost = cost self.play = play self.score = score + cards.append(self) def __str__(self): return self.name @@ -34,11 +38,26 @@ def VP(amount): # Victory -Estate = Card("Estate", [Type.Victory], 2, None, VP(1)) -Duchy = Card("Duchy", [Type.Victory], 2, None, VP(1)) -Province = Card("Province", [Type.Victory], 2, None, VP(1)) +def Estate(): + return Card("Estate", [Type.Victory], 2, None, VP(1)) + + +def Duchy(): + return Card("Duchy", [Type.Victory], 2, None, VP(1)) + + +def Province(): + return Card("Province", [Type.Victory], 2, None, VP(1)) + # Treasure -Copper = Card("Copper", [Type.Treasure], 0, Coin(1), None) -Silver = Card("Silver", [Type.Treasure], 3, Coin(2), None) -Gold = Card("Gold", [Type.Treasure], 6, Coin(3), None) +def Copper(): + return Card("Copper", [Type.Treasure], 0, Coin(1), None) + + +def Silver(): + return Card("Silver", [Type.Treasure], 3, Coin(2), None) + + +def Gold(): + return Card("Gold", [Type.Treasure], 6, Coin(3), None) diff --git a/src/kingdom.py b/src/kingdom.py index 5993dd9..ee8c8e5 100644 --- a/src/kingdom.py +++ b/src/kingdom.py @@ -1,14 +1,29 @@ -import pile import card class Kingdom(object): def __init__(self, supply): self.supply = [ - pile.Pile(card.Estate, 8), - pile.Pile(card.Duchy, 8), - pile.Pile(card.Province, 8), - pile.Pile(card.Copper, 46), - pile.Pile(card.Silver, 40), - pile.Pile(card.Gold, 30), + Pile(card.Estate, 8), + Pile(card.Duchy, 8), + Pile(card.Province, 8), + Pile(card.Copper, 46), + Pile(card.Silver, 40), + Pile(card.Gold, 30), ] + supply + + def __str__(self): + result = "" + for pile in self.supply: + if len(pile) == 0: + result += "Empty\n" + else: + result += str(pile[0]) + " - " + "%d\n" % len(pile) + return result + + +def Pile(cardF, count): + result = [] + for i in range(count): + result.append(cardF()) + return result diff --git a/src/pile.py b/src/pile.py deleted file mode 100644 index b8e53fd..0000000 --- a/src/pile.py +++ /dev/null @@ -1,6 +0,0 @@ - - -class Pile(object): - def __init__(self, card, count): - self.card = card - self.count = count diff --git a/src/player.py b/src/player.py index 0ff437c..e3162e6 100644 --- a/src/player.py +++ b/src/player.py @@ -6,9 +6,10 @@ class Player(object): def __init__(self): self.deck = [] - self.discard = [card.Estate, card.Estate, card.Estate, - card.Copper, card.Copper, card.Copper, card.Copper, - card.Copper, card.Copper, card.Copper] + self.discard = [card.Estate(), card.Estate(), card.Estate(), + card.Copper(), card.Copper(), card.Copper(), + card.Copper(), card.Copper(), card.Copper(), + card.Copper()] self.hand = [] self.score = 0 From 9a7a74368f79a004d26b970c9d5d2027755790d7 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sat, 10 Mar 2018 17:56:40 -0800 Subject: [PATCH 03/16] Delete this python bs. --- src/card.py | 63 -------------------------------------------------- src/game.py | 45 ------------------------------------ src/kingdom.py | 29 ----------------------- src/player.py | 43 ---------------------------------- src/util.py | 5 ---- 5 files changed, 185 deletions(-) delete mode 100644 src/card.py delete mode 100644 src/game.py delete mode 100644 src/kingdom.py delete mode 100644 src/player.py delete mode 100644 src/util.py diff --git a/src/card.py b/src/card.py deleted file mode 100644 index f89955c..0000000 --- a/src/card.py +++ /dev/null @@ -1,63 +0,0 @@ -from enum import Enum - - -cards = [] - - -class Type(Enum): - Victory = 0 - Treasure = 1 - Action = 2 - Curse = 4 - - -class Card(object): - def __init__(self, name, type, cost, play, score): - self.name = name - self.type = type - self.cost = cost - self.play = play - self.score = score - cards.append(self) - - def __str__(self): - return self.name - - -def PlusCoin(amount, game): - game.coin += amount - return game - - -def Coin(amount): - return lambda game: PlusCoin(amount, game) - - -def VP(amount): - return lambda game, owner: amount - - -# Victory -def Estate(): - return Card("Estate", [Type.Victory], 2, None, VP(1)) - - -def Duchy(): - return Card("Duchy", [Type.Victory], 2, None, VP(1)) - - -def Province(): - return Card("Province", [Type.Victory], 2, None, VP(1)) - - -# Treasure -def Copper(): - return Card("Copper", [Type.Treasure], 0, Coin(1), None) - - -def Silver(): - return Card("Silver", [Type.Treasure], 3, Coin(2), None) - - -def Gold(): - return Card("Gold", [Type.Treasure], 6, Coin(3), None) diff --git a/src/game.py b/src/game.py deleted file mode 100644 index 174906d..0000000 --- a/src/game.py +++ /dev/null @@ -1,45 +0,0 @@ -from enum import Enum -import kingdom -import player - - -class Phase(Enum): - Action = 0 - Buy = 1 - Cleanup = 2 - - -class Game(object): - def __init__(self, supply): - self.kingdom = kingdom.Kingdom(supply) - self.players = [player.Player(), player.Player()] - for p in self.players: - p.draw(5) - self.play = [] - self.trash = [] - self.setup_turn(0) - - def __str__(self): - result = "" - result += "Kingdom:\n" + str(self.kingdom) + "\n" - result += "Play:\n" + str(self.play) + "\n" - result += "Trash:\n" + str(self.trash) + "\n" - for i, p in enumerate(self.players): - result += "Player %d:\n" % i - result += str(p) + "\n" - return result - - def setup_turn(self, player): - self.turn_player = player - self.active_player = player - self.phase = Phase.Action - self.actions = 1 - self.coin = 0 - self.buys = 1 - - def cleanup_turn(self): - self.players[player].cleanup(self.play) - - -g = Game([]) -print g diff --git a/src/kingdom.py b/src/kingdom.py deleted file mode 100644 index ee8c8e5..0000000 --- a/src/kingdom.py +++ /dev/null @@ -1,29 +0,0 @@ -import card - - -class Kingdom(object): - def __init__(self, supply): - self.supply = [ - Pile(card.Estate, 8), - Pile(card.Duchy, 8), - Pile(card.Province, 8), - Pile(card.Copper, 46), - Pile(card.Silver, 40), - Pile(card.Gold, 30), - ] + supply - - def __str__(self): - result = "" - for pile in self.supply: - if len(pile) == 0: - result += "Empty\n" - else: - result += str(pile[0]) + " - " + "%d\n" % len(pile) - return result - - -def Pile(cardF, count): - result = [] - for i in range(count): - result.append(cardF()) - return result diff --git a/src/player.py b/src/player.py deleted file mode 100644 index e3162e6..0000000 --- a/src/player.py +++ /dev/null @@ -1,43 +0,0 @@ -import util -import random -import card - - -class Player(object): - def __init__(self): - self.deck = [] - self.discard = [card.Estate(), card.Estate(), card.Estate(), - card.Copper(), card.Copper(), card.Copper(), - card.Copper(), card.Copper(), card.Copper(), - card.Copper()] - self.hand = [] - self.score = 0 - - def __str__(self): - result = "" - result += "Hand:\n" - for c in self.hand: - result += str(c) + " " - result += "\n" - result += "Deck: %d cards\n" % len(self.deck) - result += "Discard: %d cards\n" % len(self.discard) - return result - - def cleanup(self, play): - util.move_list(play, self.discard) - util.move_list(self.hand, self.discard) - self.draw(5) - - def shuffle(self): - util.move_list(self.discard, self.deck) - random.shuffle(self.deck) - - def draw(self, count): - if count == 0: - return - if not self.deck: - if not self.discard: - return - self.shuffle() - self.hand.append(self.deck.pop()) - self.draw(count - 1) diff --git a/src/util.py b/src/util.py deleted file mode 100644 index b121a76..0000000 --- a/src/util.py +++ /dev/null @@ -1,5 +0,0 @@ - - -def move_list(src, dst): - while len(src) > 0: - dst.append(src.pop()) From 4e36c33d46a4a317aee9ba4be70f29deeb1564bf Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sun, 11 Mar 2018 20:54:46 -0700 Subject: [PATCH 04/16] Adds start of dominion engine implementation. --- src/dominion/dominion.go | 52 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 src/dominion/dominion.go diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go new file mode 100644 index 0000000..3f33bb9 --- /dev/null +++ b/src/dominion/dominion.go @@ -0,0 +1,52 @@ +package dominion + +type Game struct { + Players []*Player + Trash []*Card +} + +func NewGame(players int) *Game { + result := &Game{} + for i := 0; i < players; i++ { + result.Players = append(result.Players, NewPlayer(nil)) + } + return result +} + +type Player struct { + Actions int + Coin int + Buys int + Deck []Card + Hand []Card + Discard []Card + Play []Card +} + +func NewPlayer(deck []Card) *Player { + return &Player{Deck: deck} +} + +type Type int64 + +const ( + Victory Type = 1 << iota + Treasure + Action + Curse +) + +type Card struct { + Name string + Type Type + Cost int + Score int + Play func(*Game) +} + +type Choice struct { + Make func(*Game) + Description string +} + +type Decision []Choice From 4211ff952e8bb86a4920901b4bc34386e76e42a0 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Tue, 13 Mar 2018 16:53:01 -0700 Subject: [PATCH 05/16] Adds the basic cards. --- src/dominion/basic.go | 11 +++++++++++ src/dominion/dominion.go | 17 +++++++++-------- 2 files changed, 20 insertions(+), 8 deletions(-) create mode 100644 src/dominion/basic.go diff --git a/src/dominion/basic.go b/src/dominion/basic.go new file mode 100644 index 0000000..2995242 --- /dev/null +++ b/src/dominion/basic.go @@ -0,0 +1,11 @@ +package dominion + +var ( + Estate = &Card{Name: "Estate", Type: Victory, Cost: 0, Score: 1} + Duchy = &Card{Name: "Duchy", Type: Victory, Cost: 5, Score: 3} + Provence = &Card{Name: "Provence", Type: Victory, Cost: 8, Score: 6} + + Copper = &Card{Name: "Copper", Type: Treasure, Cost: 0, Score: 0} + Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0} + Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0} +) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 3f33bb9..6c24acd 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -1,8 +1,9 @@ package dominion type Game struct { - Players []*Player - Trash []*Card + Players []*Player + Trash []*Card + Decisions []*Decision } func NewGame(players int) *Game { @@ -17,13 +18,13 @@ type Player struct { Actions int Coin int Buys int - Deck []Card - Hand []Card - Discard []Card - Play []Card + Deck []*Card + Hand []*Card + Discard []*Card + Play []*Card } -func NewPlayer(deck []Card) *Player { +func NewPlayer(deck []*Card) *Player { return &Player{Deck: deck} } @@ -49,4 +50,4 @@ type Choice struct { Description string } -type Decision []Choice +type Decision []*Choice From 7d9321b9e0830f472dcdb9d9a53b7434b851f634 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Wed, 14 Mar 2018 17:13:46 -0700 Subject: [PATCH 06/16] Adds code to start a basic game. --- src/dominion/basic.go | 2 ++ src/dominion/dominion.go | 58 ++++++++++++++++++++++++++++++++++++---- src/main.go | 11 ++++++++ 3 files changed, 66 insertions(+), 5 deletions(-) create mode 100644 src/main.go diff --git a/src/dominion/basic.go b/src/dominion/basic.go index 2995242..308379e 100644 --- a/src/dominion/basic.go +++ b/src/dominion/basic.go @@ -8,4 +8,6 @@ var ( Copper = &Card{Name: "Copper", Type: Treasure, Cost: 0, Score: 0} Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0} Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0} + + StartDeck = []*Card{Estate, Estate, Estate, Copper, Copper, Copper, Copper, Copper, Copper, Copper} ) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 6c24acd..bf2d17f 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -1,5 +1,12 @@ package dominion +import ( + "fmt" + "strings" + + "github.com/fatih/color" +) + type Game struct { Players []*Player Trash []*Card @@ -9,7 +16,15 @@ type Game struct { func NewGame(players int) *Game { result := &Game{} for i := 0; i < players; i++ { - result.Players = append(result.Players, NewPlayer(nil)) + result.Players = append(result.Players, NewPlayer(StartDeck)) + } + return result +} + +func (g *Game) String() string { + var result string + for i, p := range g.Players { + result += fmt.Sprintf("Player %d:\n", i) + p.String() + "\n" } return result } @@ -18,16 +33,24 @@ type Player struct { Actions int Coin int Buys int - Deck []*Card - Hand []*Card - Discard []*Card - Play []*Card + Deck Cards + Hand Cards + Discard Cards + Play Cards } func NewPlayer(deck []*Card) *Player { return &Player{Deck: deck} } +func (p *Player) String() string { + var result string + result += "Deck: " + p.Deck.String() + "\n" + result += "Hand: " + p.Hand.String() + "\n" + result += "Play: " + p.Play.String() + "\n" + return result +} + type Type int64 const ( @@ -45,6 +68,31 @@ type Card struct { Play func(*Game) } +func (c *Card) String() string { + switch c.Type { + case Victory: + return color.New(color.FgGreen).SprintFunc()(c.Name) + case Treasure: + return color.New(color.FgYellow).SprintFunc()(c.Name) + case Action: + return color.New(color.FgWhite).SprintFunc()(c.Name) + case Curse: + return color.New(color.FgMagenta).SprintFunc()(c.Name) + default: + return c.Name + } +} + +type Cards []*Card + +func (cs Cards) String() string { + var cards []string + for _, c := range cs { + cards = append(cards, c.String()) + } + return strings.Join(cards, ", ") +} + type Choice struct { Make func(*Game) Description string diff --git a/src/main.go b/src/main.go new file mode 100644 index 0000000..01207c8 --- /dev/null +++ b/src/main.go @@ -0,0 +1,11 @@ +package main + +import ( + "fmt" + d "github.com/jdoliner/dominion/src/dominion" +) + +func main() { + g := d.NewGame(2) + fmt.Printf("%+v\n", g) +} From b02d854b0abb18c4203d8e60d0150bae79724c5e Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Tue, 17 Apr 2018 14:18:26 -0700 Subject: [PATCH 07/16] Add Kingdom struct. --- src/dominion/dominion.go | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index bf2d17f..90077da 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -9,8 +9,9 @@ import ( type Game struct { Players []*Player - Trash []*Card + Trash Cards Decisions []*Decision + Kingdom *Kingdom } func NewGame(players int) *Game { @@ -93,6 +94,18 @@ func (cs Cards) String() string { return strings.Join(cards, ", ") } +type Kingdom struct { + Piles []Cards +} + +func (k *Kingdom) String() string { + var piles []string + for _, p := range k.Piles { + piles = append(piles, p.String()) + } + return strings.Join(piles, "\n") +} + type Choice struct { Make func(*Game) Description string From 537cca9a5aa91bd3ea0301c7173ac9418226c53e Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sun, 13 May 2018 15:14:30 -0700 Subject: [PATCH 08/16] Basic -> core. --- src/dominion/{basic.go => core.go} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/dominion/{basic.go => core.go} (100%) diff --git a/src/dominion/basic.go b/src/dominion/core.go similarity index 100% rename from src/dominion/basic.go rename to src/dominion/core.go From ad8d6446f09fd29f003435b6efb448e6fc232dd0 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sun, 13 May 2018 15:55:31 -0700 Subject: [PATCH 09/16] Adds drawing and shuffling. --- src/dominion/dominion.go | 40 +++++---------------------- src/dominion/player.go | 60 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+), 33 deletions(-) create mode 100644 src/dominion/player.go diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 90077da..386a7f9 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -8,16 +8,19 @@ import ( ) type Game struct { - Players []*Player - Trash Cards - Decisions []*Decision - Kingdom *Kingdom + Players []*Player + Trash Cards + Kingdom *Kingdom + Turn int + ActivePlayer int } func NewGame(players int) *Game { result := &Game{} for i := 0; i < players; i++ { result.Players = append(result.Players, NewPlayer(StartDeck)) + result.Players[i].Shuffle() + result.Players[i].Draw(5) } return result } @@ -30,28 +33,6 @@ func (g *Game) String() string { return result } -type Player struct { - Actions int - Coin int - Buys int - Deck Cards - Hand Cards - Discard Cards - Play Cards -} - -func NewPlayer(deck []*Card) *Player { - return &Player{Deck: deck} -} - -func (p *Player) String() string { - var result string - result += "Deck: " + p.Deck.String() + "\n" - result += "Hand: " + p.Hand.String() + "\n" - result += "Play: " + p.Play.String() + "\n" - return result -} - type Type int64 const ( @@ -105,10 +86,3 @@ func (k *Kingdom) String() string { } return strings.Join(piles, "\n") } - -type Choice struct { - Make func(*Game) - Description string -} - -type Decision []*Choice diff --git a/src/dominion/player.go b/src/dominion/player.go new file mode 100644 index 0000000..7c76e16 --- /dev/null +++ b/src/dominion/player.go @@ -0,0 +1,60 @@ +package dominion + +import ( + "github.com/golang/go/src/math/rand" +) + +type Player struct { + Actions int + Coin int + Buys int + Deck Cards + Hand Cards + Discard Cards + Play Cards +} + +func NewPlayer(deck []*Card) *Player { + return &Player{Deck: deck} +} + +func (p *Player) String() string { + var result string + result += "Deck: " + p.Deck.String() + "\n" + result += "Hand: " + p.Hand.String() + "\n" + result += "Play: " + p.Play.String() + "\n" + return result +} + +func (p *Player) Shuffle() { + rand.Shuffle(len(p.Deck), func(i, j int) { p.Deck[i], p.Deck[j] = p.Deck[j], p.Deck[i] }) +} + +func (p *Player) Reshuffle() { + p.Deck = append(p.Deck, p.Discard...) + p.Discard = nil + p.Shuffle() +} + +func (p *Player) Draw(n int) { + l := len(p.Deck) + if l < n { + if l > 0 { + p.Draw(l) + } + if len(p.Discard) > 0 { + p.Reshuffle() + p.Draw(n - l) + } + return + } + p.Hand = append(p.Hand, p.Deck[:n]...) + p.Deck = p.Deck[n:] +} + +type Choice struct { + Make func(*Game) + Description string +} + +type Decision []*Choice From 05485746d3dec7b2c5622d9b18d9c3d8e85b7ad8 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Sun, 13 May 2018 16:36:54 -0700 Subject: [PATCH 10/16] Adds functions for playing cards. --- src/dominion/dominion.go | 4 ++++ src/dominion/player.go | 30 ++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 386a7f9..5a223f3 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -42,6 +42,10 @@ const ( Curse ) +func (t Type) Is(u Type) bool { + return t&u != 0 +} + type Card struct { Name string Type Type diff --git a/src/dominion/player.go b/src/dominion/player.go index 7c76e16..afac8a6 100644 --- a/src/dominion/player.go +++ b/src/dominion/player.go @@ -1,6 +1,8 @@ package dominion import ( + "sort" + "github.com/golang/go/src/math/rand" ) @@ -52,6 +54,34 @@ func (p *Player) Draw(n int) { p.Deck = p.Deck[n:] } +// Play p.Hand[card] +func (p *Player) PlayCards(cards ...int) { + sort.Ints(cards) + var hand Cards + for i, c := range p.Hand { + if len(cards) == 0 { + break + } + if i == cards[0] { + p.Play = append(p.Play, c) + } else { + hand = append(hand, c) + } + cards = cards[1:] + } + p.Hand = hand +} + +func (p *Player) PlayTreasures() { + var ts []int + for i, c := range p.Hand { + if c.Type.Is(Treasure) { + ts = append(ts, i) + } + } + p.PlayCards(ts...) +} + type Choice struct { Make func(*Game) Description string From 1abcf68b0ff5284c4ca24958c24700aa52cbca5a Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Mon, 14 May 2018 10:48:06 -0700 Subject: [PATCH 11/16] Adds start of kingdom code. --- src/dominion/core.go | 3 ++- src/dominion/dominion.go | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/dominion/core.go b/src/dominion/core.go index 308379e..784d5ca 100644 --- a/src/dominion/core.go +++ b/src/dominion/core.go @@ -9,5 +9,6 @@ var ( Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0} Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0} - StartDeck = []*Card{Estate, Estate, Estate, Copper, Copper, Copper, Copper, Copper, Copper, Copper} + StartDeck = Cards{Estate, Estate, Estate, Copper, Copper, Copper, Copper, Copper, Copper, Copper} + StartKingdom = []Cards{} ) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 5a223f3..07c7936 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -22,6 +22,7 @@ func NewGame(players int) *Game { result.Players[i].Shuffle() result.Players[i].Draw(5) } + result.Kingdom = &Kingdom{Piles: StartKingdom} return result } @@ -30,6 +31,7 @@ func (g *Game) String() string { for i, p := range g.Players { result += fmt.Sprintf("Player %d:\n", i) + p.String() + "\n" } + result += g.Kingdom.String() + "\n" return result } From 70a5f8bc6c7603feb176914ed200f6d55bdbc257 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Fri, 18 May 2018 18:26:07 -0700 Subject: [PATCH 12/16] Adds kingdom code. --- src/dominion/core.go | 12 +++++++++--- src/dominion/dominion.go | 42 ++++++---------------------------------- 2 files changed, 15 insertions(+), 39 deletions(-) diff --git a/src/dominion/core.go b/src/dominion/core.go index 784d5ca..e3f13c4 100644 --- a/src/dominion/core.go +++ b/src/dominion/core.go @@ -3,12 +3,18 @@ package dominion var ( Estate = &Card{Name: "Estate", Type: Victory, Cost: 0, Score: 1} Duchy = &Card{Name: "Duchy", Type: Victory, Cost: 5, Score: 3} - Provence = &Card{Name: "Provence", Type: Victory, Cost: 8, Score: 6} + Province = &Card{Name: "Provence", Type: Victory, Cost: 8, Score: 6} Copper = &Card{Name: "Copper", Type: Treasure, Cost: 0, Score: 0} Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0} Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0} - StartDeck = Cards{Estate, Estate, Estate, Copper, Copper, Copper, Copper, Copper, Copper, Copper} - StartKingdom = []Cards{} + StartDeck = Cards{ + Estate, Estate, Estate, + Copper, Copper, Copper, Copper, Copper, Copper, Copper, + } + StartKingdom = []Cards{ + NewCards(Estate, 8), NewCards(Duchy, 8), NewCards(Province, 8), + NewCards(Copper, 46), NewCards(Silver, 40), NewCards(Gold, 30), + } ) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 07c7936..42dd147 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -3,8 +3,6 @@ package dominion import ( "fmt" "strings" - - "github.com/fatih/color" ) type Game struct { @@ -31,6 +29,7 @@ func (g *Game) String() string { for i, p := range g.Players { result += fmt.Sprintf("Player %d:\n", i) + p.String() + "\n" } + result += "Kingdom:\n" result += g.Kingdom.String() + "\n" return result } @@ -48,39 +47,6 @@ func (t Type) Is(u Type) bool { return t&u != 0 } -type Card struct { - Name string - Type Type - Cost int - Score int - Play func(*Game) -} - -func (c *Card) String() string { - switch c.Type { - case Victory: - return color.New(color.FgGreen).SprintFunc()(c.Name) - case Treasure: - return color.New(color.FgYellow).SprintFunc()(c.Name) - case Action: - return color.New(color.FgWhite).SprintFunc()(c.Name) - case Curse: - return color.New(color.FgMagenta).SprintFunc()(c.Name) - default: - return c.Name - } -} - -type Cards []*Card - -func (cs Cards) String() string { - var cards []string - for _, c := range cs { - cards = append(cards, c.String()) - } - return strings.Join(cards, ", ") -} - type Kingdom struct { Piles []Cards } @@ -88,7 +54,11 @@ type Kingdom struct { func (k *Kingdom) String() string { var piles []string for _, p := range k.Piles { - piles = append(piles, p.String()) + if len(p) > 0 { + piles = append(piles, fmt.Sprintf("[%s x %d]", p[0].String(), len(p))) + } else { + piles = append(piles, "[ ]") + } } return strings.Join(piles, "\n") } From 61e3df2b54e73735d909040ed842e3180eb81c08 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Fri, 18 May 2018 21:12:36 -0700 Subject: [PATCH 13/16] Relocates and extends cards. Basic game controls. --- src/dominion/card.go | 50 ++++++++++++++++++++++++++++++++++++++++ src/dominion/core.go | 12 +++++++--- src/dominion/dominion.go | 22 ++++++++++++++---- 3 files changed, 76 insertions(+), 8 deletions(-) create mode 100644 src/dominion/card.go diff --git a/src/dominion/card.go b/src/dominion/card.go new file mode 100644 index 0000000..e91e41d --- /dev/null +++ b/src/dominion/card.go @@ -0,0 +1,50 @@ +package dominion + +import ( + "strings" + + "github.com/fatih/color" +) + +// Card represents a dominion card. It does not represent an actual instance +// of a card in a player's hand, it represents the game data for a card. +type Card struct { + Name string + Type Type + Cost int + Score int + Play func(*Game) +} + +func (c *Card) String() string { + switch c.Type { + case Victory: + return color.New(color.FgGreen).SprintFunc()(c.Name) + case Treasure: + return color.New(color.FgYellow).SprintFunc()(c.Name) + case Action: + return color.New(color.FgWhite).SprintFunc()(c.Name) + case Curse: + return color.New(color.FgMagenta).SprintFunc()(c.Name) + default: + return c.Name + } +} + +type Cards []*Card + +func NewCards(c *Card, n int) Cards { + var result Cards + for i := 0; i < n; i++ { + result = append(result, c) + } + return result +} + +func (cs Cards) String() string { + var cards []string + for _, c := range cs { + cards = append(cards, c.String()) + } + return strings.Join(cards, ", ") +} diff --git a/src/dominion/core.go b/src/dominion/core.go index e3f13c4..a5242f7 100644 --- a/src/dominion/core.go +++ b/src/dominion/core.go @@ -5,9 +5,9 @@ var ( Duchy = &Card{Name: "Duchy", Type: Victory, Cost: 5, Score: 3} Province = &Card{Name: "Provence", Type: Victory, Cost: 8, Score: 6} - Copper = &Card{Name: "Copper", Type: Treasure, Cost: 0, Score: 0} - Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0} - Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0} + Copper = &Card{Name: "Copper", Type: Treasure, Cost: 0, Score: 0, Play: PlusCoin(1)} + Silver = &Card{Name: "Silver", Type: Treasure, Cost: 3, Score: 0, Play: PlusCoin(2)} + Gold = &Card{Name: "Gold", Type: Treasure, Cost: 6, Score: 0, Play: PlusCoin(3)} StartDeck = Cards{ Estate, Estate, Estate, @@ -18,3 +18,9 @@ var ( NewCards(Copper, 46), NewCards(Silver, 40), NewCards(Gold, 30), } ) + +func PlusCoin(coin int) func(*Game) { + return func(g *Game) { + g.ActivePlayer().Coin += coin + } +} diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index 42dd147..a583bdf 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -6,11 +6,11 @@ import ( ) type Game struct { - Players []*Player - Trash Cards - Kingdom *Kingdom - Turn int - ActivePlayer int + Players []*Player + active int8 // index into slice above + Trash Cards + Kingdom *Kingdom + Turn int } func NewGame(players int) *Game { @@ -34,6 +34,18 @@ func (g *Game) String() string { return result } +func (g *Game) ActivePlayer() *Player { + return g.Players[g.active] +} + +func (g *Game) EndTurn() { + g.active++ + if g.active == 2 { + g.active = 0 + g.Turn++ + } +} + type Type int64 const ( From f42ccd1d36bac18cc2f3f3344c5ef07915b044f2 Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Mon, 28 May 2018 13:44:11 -0700 Subject: [PATCH 14/16] Adds first test. --- src/dominion/dominion_test.go | 39 +++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 src/dominion/dominion_test.go diff --git a/src/dominion/dominion_test.go b/src/dominion/dominion_test.go new file mode 100644 index 0000000..4f438cf --- /dev/null +++ b/src/dominion/dominion_test.go @@ -0,0 +1,39 @@ +package dominion + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func countCards(cs Cards) map[string]int { + result := make(map[string]int) + for _, c := range cs { + result[c.Name]++ + } + return result +} + +func TestGame(t *testing.T) { + g := NewGame(2) + assert.Equal(t, 2, len(g.Players)) + assert.Equal(t, 0, g.active) + assert.Equal(t, 0, g.Turn) + p1Start, p2Start := countCards(append(g.Players[0].Deck, g.Players[0].Hand...)), countCards(append(g.Players[1].Deck, g.Players[1].Hand...)) + assert.Equal(t, 3, p1Start["Estate"]) + assert.Equal(t, 7, p1Start["Copper"]) + assert.Equal(t, 3, p2Start["Estate"]) + assert.Equal(t, 7, p2Start["Copper"]) + assert.Equal(t, 5, len(g.Players[0].Hand)) + assert.Equal(t, 5, len(g.Players[1].Hand)) + assert.Equal(t, 5, len(g.Players[0].Deck)) + assert.Equal(t, 5, len(g.Players[1].Deck)) + + g.ActivePlayer().PlayTreasures() + hand, play := countCards(g.ActivePlayer().Hand), countCards(g.ActivePlayer().Play) + assert.Equal(t, 0, hand["Copper"]) + assert.Equal(t, 0, play["Estate"]) + assert.Equal(t, 5, hand["Estate"]+play["Copper"]) + fmt.Printf("%v", g.ActivePlayer()) +} From 47c25aaf7dea38c6e6adfb4c4acde2fbad967cbf Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Mon, 28 May 2018 13:44:25 -0700 Subject: [PATCH 15/16] Adds more player functionality. --- src/dominion/card.go | 5 +++++ src/dominion/dominion.go | 2 +- src/dominion/player.go | 11 ++++++++++- src/main.go | 4 ++++ 4 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/dominion/card.go b/src/dominion/card.go index e91e41d..a40dc95 100644 --- a/src/dominion/card.go +++ b/src/dominion/card.go @@ -48,3 +48,8 @@ func (cs Cards) String() string { } return strings.Join(cards, ", ") } + +func (cs Cards) MoveTo(dst Cards) { + dst = append(dst, cs...) + cs = nil +} diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index a583bdf..e1706d5 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -7,7 +7,7 @@ import ( type Game struct { Players []*Player - active int8 // index into slice above + active int // index into slice above Trash Cards Kingdom *Kingdom Turn int diff --git a/src/dominion/player.go b/src/dominion/player.go index afac8a6..254c0c1 100644 --- a/src/dominion/player.go +++ b/src/dominion/player.go @@ -1,6 +1,7 @@ package dominion import ( + "fmt" "sort" "github.com/golang/go/src/math/rand" @@ -54,6 +55,11 @@ func (p *Player) Draw(n int) { p.Deck = p.Deck[n:] } +func (p *Player) Cleanup() { + p.Hand.MoveTo(p.Discard) + p.Play.MoveTo(p.Discard) +} + // Play p.Hand[card] func (p *Player) PlayCards(cards ...int) { sort.Ints(cards) @@ -64,10 +70,13 @@ func (p *Player) PlayCards(cards ...int) { } if i == cards[0] { p.Play = append(p.Play, c) + cards = cards[1:] } else { hand = append(hand, c) } - cards = cards[1:] + } + if len(cards) != 0 { + panic(fmt.Sprintf("%d is out of range of hand (len %d)", cards[0], len(p.Hand))) } p.Hand = hand } diff --git a/src/main.go b/src/main.go index 01207c8..2682b31 100644 --- a/src/main.go +++ b/src/main.go @@ -8,4 +8,8 @@ import ( func main() { g := d.NewGame(2) fmt.Printf("%+v\n", g) + g.ActivePlayer().PlayTreasures() + fmt.Printf("%+v\n", g) + g.ActivePlayer().Cleanup() + fmt.Printf("%+v\n", g) } From 5716788d32e4dcfd9db3346dc2a67e6128c273ca Mon Sep 17 00:00:00 2001 From: Joe Doliner Date: Mon, 28 May 2018 15:40:25 -0700 Subject: [PATCH 16/16] More testing. --- src/dominion/dominion.go | 2 ++ src/dominion/dominion_test.go | 1 + 2 files changed, 3 insertions(+) diff --git a/src/dominion/dominion.go b/src/dominion/dominion.go index e1706d5..896b45e 100644 --- a/src/dominion/dominion.go +++ b/src/dominion/dominion.go @@ -39,6 +39,8 @@ func (g *Game) ActivePlayer() *Player { } func (g *Game) EndTurn() { + g.ActivePlayer().Cleanup() + g.ActivePlayer().Draw(5) g.active++ if g.active == 2 { g.active = 0 diff --git a/src/dominion/dominion_test.go b/src/dominion/dominion_test.go index 4f438cf..c58a40d 100644 --- a/src/dominion/dominion_test.go +++ b/src/dominion/dominion_test.go @@ -35,5 +35,6 @@ func TestGame(t *testing.T) { assert.Equal(t, 0, hand["Copper"]) assert.Equal(t, 0, play["Estate"]) assert.Equal(t, 5, hand["Estate"]+play["Copper"]) + g.EndTurn() fmt.Printf("%v", g.ActivePlayer()) }