Initial commit.
This commit is contained in:
Greyson Parrelli
@@ -0,0 +1,335 @@
|
||||
package game
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func deckIDs(p *Player, filter func(Card) bool) []string {
|
||||
var ids []string
|
||||
for _, c := range p.Deck {
|
||||
if filter == nil || filter(c) {
|
||||
ids = append(ids, c.ID)
|
||||
}
|
||||
}
|
||||
return ids
|
||||
}
|
||||
|
||||
func current(g *Game) *Player { return g.Players[g.Turn] }
|
||||
|
||||
func TestLobbyStartsWhenFull(t *testing.T) {
|
||||
g := New()
|
||||
if g.Phase != PhaseLobby {
|
||||
t.Fatalf("new game should be in lobby, got %s", g.Phase)
|
||||
}
|
||||
if _, err := g.AddPlayer("Alice"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if g.Phase != PhaseLobby {
|
||||
t.Fatal("game should wait for second player")
|
||||
}
|
||||
if _, err := g.AddPlayer("Bob"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if g.Phase != PhaseShop || g.Round != 1 {
|
||||
t.Fatalf("game should start round 1 shop, got phase=%s round=%d", g.Phase, g.Round)
|
||||
}
|
||||
if _, err := g.AddPlayer("Carol"); err == nil {
|
||||
t.Fatal("third player should be rejected while MaxPlayers=2")
|
||||
}
|
||||
for _, p := range g.Players {
|
||||
if p.Coins != CoinsPerRound {
|
||||
t.Fatalf("player should start with %d coins", CoinsPerRound)
|
||||
}
|
||||
}
|
||||
if len(g.ShopRow) != ShopRowSize {
|
||||
t.Fatalf("shop row should have %d cards", ShopRowSize)
|
||||
}
|
||||
for _, c := range g.ShopRow {
|
||||
if c.Tier != 1 {
|
||||
t.Fatalf("round 1 shop should deal tier 1 cards, got tier %d", c.Tier)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuyTakesCardAndRefills(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
p := current(g)
|
||||
want := g.ShopRow[0]
|
||||
deckBefore := len(g.ShopDecks[0])
|
||||
if err := g.Buy(p.ID, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p.Coins != CoinsPerRound-1 {
|
||||
t.Fatalf("buy should cost 1 coin, coins=%d", p.Coins)
|
||||
}
|
||||
if len(p.Deck) != 1 || p.Deck[0].ID != want.ID {
|
||||
t.Fatalf("bought card should be in deck")
|
||||
}
|
||||
if g.ShopRow[0].ID == "" || g.ShopRow[0].ID == want.ID {
|
||||
t.Fatal("shop slot should refill with a new card")
|
||||
}
|
||||
if len(g.ShopDecks[0]) != deckBefore-1 {
|
||||
t.Fatal("refill should come from the tier deck")
|
||||
}
|
||||
if current(g).ID == p.ID {
|
||||
t.Fatal("turn should pass after an action")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTurnValidation(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
other := g.Players[(g.Turn+1)%2]
|
||||
if err := g.Buy(other.ID, 0); err == nil {
|
||||
t.Fatal("acting out of turn should fail")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDiscardConvertsToApples(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
p := current(g)
|
||||
if err := g.Buy(p.ID, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Skip opponent back to p.
|
||||
if err := g.Buy(current(g).ID, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := g.Discard(p.ID, deckIDs(p, Card.IsPet)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p.Coins != CoinsPerRound-2 {
|
||||
t.Fatalf("discard should cost 1 coin, coins=%d", p.Coins)
|
||||
}
|
||||
if p.PetCount() != 0 || len(p.Deck) != 1 || p.Deck[0].Food != FoodApple {
|
||||
t.Fatalf("discarded pet should become an apple: %+v", p.Deck)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTradeInThreeMatchingSuits(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
p := current(g)
|
||||
// Hand p three same-suit tier-1 pets directly.
|
||||
for range 3 {
|
||||
c := g.pet("Fodder", 1)
|
||||
c.Suit = SuitMoon
|
||||
p.Deck = append(p.Deck, c)
|
||||
}
|
||||
nextDeckBefore := len(g.ShopDecks[1])
|
||||
if err := g.TradeStart(p.ID, deckIDs(p, nil)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if g.Pending == nil || g.Pending.Tier != 2 {
|
||||
t.Fatalf("trade should reveal two tier-2 cards: %+v", g.Pending)
|
||||
}
|
||||
if len(p.Deck) != 0 {
|
||||
t.Fatal("traded cards should leave the deck")
|
||||
}
|
||||
if current(g).ID != p.ID {
|
||||
t.Fatal("turn should not pass until the trade is chosen")
|
||||
}
|
||||
if err := g.Buy(p.ID, 0); err == nil {
|
||||
t.Fatal("other actions should be blocked while a trade is pending")
|
||||
}
|
||||
chosen := g.Pending.Options[0]
|
||||
rejected := g.Pending.Options[1]
|
||||
if err := g.TradeChoose(p.ID, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(p.Deck) != 1 || p.Deck[0].ID != chosen.ID {
|
||||
t.Fatal("chosen card should join the deck")
|
||||
}
|
||||
deck2 := g.ShopDecks[1]
|
||||
if len(deck2) != nextDeckBefore-1 {
|
||||
t.Fatalf("tier 2 deck should be down exactly one card, was %d now %d", nextDeckBefore, len(deck2))
|
||||
}
|
||||
if deck2[len(deck2)-1].ID != rejected.ID {
|
||||
t.Fatal("rejected card should go to the bottom of the tier deck")
|
||||
}
|
||||
if p.Coins != CoinsPerRound-1 {
|
||||
t.Fatalf("trade should cost 1 coin, coins=%d", p.Coins)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTradeRequiresMatchingSuit(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
p := current(g)
|
||||
a, b, c := g.pet("A", 1), g.pet("B", 1), g.pet("C", 1)
|
||||
a.Suit, b.Suit, c.Suit = SuitSun, SuitSun, SuitMoon
|
||||
p.Deck = append(p.Deck, a, b, c)
|
||||
if err := g.TradeStart(p.ID, []string{a.ID, b.ID, c.ID}); err == nil {
|
||||
t.Fatal("mismatched suits should be rejected")
|
||||
}
|
||||
if len(p.Deck) != 3 || p.Coins != CoinsPerRound {
|
||||
t.Fatal("failed trade must not mutate state")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTradeBlockedOnFinalRound(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
g.Round = MaxRounds
|
||||
p := current(g)
|
||||
for range 3 {
|
||||
c := g.pet("Fodder", 1)
|
||||
c.Suit = SuitMoon
|
||||
p.Deck = append(p.Deck, c)
|
||||
}
|
||||
if err := g.TradeStart(p.ID, deckIDs(p, nil)); err == nil {
|
||||
t.Fatal("trading should be impossible in the final round")
|
||||
}
|
||||
}
|
||||
|
||||
// spendAllCoins has both players pass until the shop ends.
|
||||
func spendAllCoins(t *testing.T, g *Game) {
|
||||
t.Helper()
|
||||
for g.Phase == PhaseShop {
|
||||
if err := g.Pass(current(g).ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestShopEndsIntoArrange(t *testing.T) {
|
||||
g, _, _ := testGame(t)
|
||||
spendAllCoins(t, g)
|
||||
if g.Phase != PhaseArrange {
|
||||
t.Fatalf("shop should end into arrange when no one is over the pet limit, got %s", g.Phase)
|
||||
}
|
||||
}
|
||||
|
||||
func TestForcedDiscardOverPetLimit(t *testing.T) {
|
||||
g, p1, _ := testGame(t)
|
||||
for range MaxPets + 2 {
|
||||
p1.Deck = append(p1.Deck, g.pet("Extra", 1))
|
||||
}
|
||||
spendAllCoins(t, g)
|
||||
if g.Phase != PhaseCleanup {
|
||||
t.Fatalf("player with %d pets must be forced to discard, got phase %s", MaxPets+2, g.Phase)
|
||||
}
|
||||
// Wrong count rejected.
|
||||
if err := g.CleanupDiscard(p1.ID, deckIDs(p1, Card.IsPet)[:1]); err == nil {
|
||||
t.Fatal("must discard exactly the excess")
|
||||
}
|
||||
if err := g.CleanupDiscard(p1.ID, deckIDs(p1, Card.IsPet)[:2]); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p1.PetCount() != MaxPets {
|
||||
t.Fatalf("expected %d pets after cleanup, got %d", MaxPets, p1.PetCount())
|
||||
}
|
||||
apples := 0
|
||||
for _, c := range p1.Deck {
|
||||
if c.Food == FoodApple {
|
||||
apples++
|
||||
}
|
||||
}
|
||||
if apples != 2 {
|
||||
t.Fatalf("discarded pets should become apples, got %d", apples)
|
||||
}
|
||||
if g.Phase != PhaseArrange {
|
||||
t.Fatalf("cleanup should flow into arrange, got %s", g.Phase)
|
||||
}
|
||||
}
|
||||
|
||||
func TestArrangeRejectsBadPermutation(t *testing.T) {
|
||||
g, p1, _ := testGame(t)
|
||||
p1.Deck = append(p1.Deck, g.pet("A", 1), g.pet("B", 2))
|
||||
spendAllCoins(t, g)
|
||||
if err := g.SubmitOrder(p1.ID, []string{p1.Deck[0].ID}); err == nil {
|
||||
t.Fatal("partial order should be rejected")
|
||||
}
|
||||
if err := g.SubmitOrder(p1.ID, []string{p1.Deck[0].ID, p1.Deck[0].ID}); err == nil {
|
||||
t.Fatal("duplicate IDs should be rejected")
|
||||
}
|
||||
if err := g.SubmitOrder(p1.ID, []string{p1.Deck[1].ID, p1.Deck[0].ID}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p1.Deck[0].Name != "B" {
|
||||
t.Fatal("submitted order should be applied to the deck")
|
||||
}
|
||||
}
|
||||
|
||||
// Full game: six rounds of pass-through shops and battles, trophy totals,
|
||||
// and game over with a winner.
|
||||
func TestFullGameFlow(t *testing.T) {
|
||||
g, p1, p2 := testGame(t)
|
||||
p1.Deck = append(p1.Deck, g.pet("Champ", 9))
|
||||
p2.Deck = append(p2.Deck, g.pet("Chump", 1))
|
||||
for round := 1; round <= MaxRounds; round++ {
|
||||
if g.Round != round || g.Phase != PhaseShop {
|
||||
t.Fatalf("expected shop of round %d, got round %d phase %s", round, g.Round, g.Phase)
|
||||
}
|
||||
if g.Turn != (round-1)%len(g.Players) {
|
||||
t.Fatalf("round %d should rotate the starting player, turn=%d", round, g.Turn)
|
||||
}
|
||||
for _, c := range g.ShopRow {
|
||||
if c.ID != "" && c.Tier != round {
|
||||
t.Fatalf("round %d shop dealt tier %d card", round, c.Tier)
|
||||
}
|
||||
}
|
||||
spendAllCoins(t, g)
|
||||
for _, p := range g.Players {
|
||||
if err := g.SubmitOrder(p.ID, deckIDs(p, nil)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if g.Phase != PhaseBattle {
|
||||
t.Fatalf("expected battle after both arrange, got %s", g.Phase)
|
||||
}
|
||||
if g.Battle.WinnerSeat != p1.Seat {
|
||||
t.Fatalf("round %d: seat 0 should win", round)
|
||||
}
|
||||
for _, p := range g.Players {
|
||||
if err := g.AcknowledgeBattle(p.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if g.Phase != PhaseGameOver {
|
||||
t.Fatalf("game should be over after %d rounds, got %s", MaxRounds, g.Phase)
|
||||
}
|
||||
// 1 trophy for rounds 1-5, 2 for round 6.
|
||||
if p1.Trophies != 7 {
|
||||
t.Fatalf("winner should have 7 trophies, got %d", p1.Trophies)
|
||||
}
|
||||
if g.WinnerSeat != p1.Seat {
|
||||
t.Fatalf("winner seat should be %d, got %d", p1.Seat, g.WinnerSeat)
|
||||
}
|
||||
}
|
||||
|
||||
func TestViewHidesSecrets(t *testing.T) {
|
||||
g, p1, p2 := testGame(t)
|
||||
p1.Deck = append(p1.Deck, g.pet("Secret", 3))
|
||||
v := g.ViewFor(p2.ID)
|
||||
if v.YouSeat != p2.Seat {
|
||||
t.Fatalf("view should identify the viewer's seat")
|
||||
}
|
||||
for _, pv := range v.Players {
|
||||
if pv.Seat == p1.Seat && pv.Deck != nil {
|
||||
t.Fatal("opponent deck contents must be hidden")
|
||||
}
|
||||
if pv.Seat == p1.Seat && pv.DeckSize != 1 {
|
||||
t.Fatal("opponent deck size should be visible")
|
||||
}
|
||||
}
|
||||
// Pending trade options hidden from the opponent.
|
||||
for range 3 {
|
||||
c := g.pet("Fodder", 1)
|
||||
c.Suit = SuitLeaf
|
||||
p1.Deck = append(p1.Deck, c)
|
||||
}
|
||||
g.Turn = p1.Seat
|
||||
var fodder []string
|
||||
for _, c := range p1.Deck {
|
||||
if c.Name == "Fodder" {
|
||||
fodder = append(fodder, c.ID)
|
||||
}
|
||||
}
|
||||
if err := g.TradeStart(p1.ID, fodder); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if opts := g.ViewFor(p2.ID).Pending.Options; opts[0].ID != "" || opts[1].ID != "" {
|
||||
t.Fatal("trade options must be hidden from opponents")
|
||||
}
|
||||
if opts := g.ViewFor(p1.ID).Pending.Options; opts[0].ID == "" {
|
||||
t.Fatal("trade options must be visible to the trader")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user