373 lines
13 KiB
Go
373 lines
13 KiB
Go
package game
|
||
|
||
import "fmt"
|
||
|
||
// Suit is the colored trade-in symbol printed on pet cards. Three pets of
|
||
// the same suit can be traded (the "Triple" action) for a pick from the next
|
||
// tier's deck.
|
||
type Suit string
|
||
|
||
const (
|
||
SuitRed Suit = "red"
|
||
SuitBlue Suit = "blue"
|
||
SuitYellow Suit = "yellow"
|
||
)
|
||
|
||
// CardKind distinguishes pets from foods.
|
||
type CardKind string
|
||
|
||
const (
|
||
KindPet CardKind = "pet"
|
||
KindFood CardKind = "food"
|
||
)
|
||
|
||
// Food identifiers.
|
||
const (
|
||
FoodApple = "apple"
|
||
FoodHoney = "honey"
|
||
FoodGarlic = "garlic"
|
||
)
|
||
|
||
// EffectTrigger is when an effect fires.
|
||
type EffectTrigger string
|
||
|
||
const (
|
||
TriggerFaint EffectTrigger = "faint" // defeated in battle
|
||
TriggerSell EffectTrigger = "sell" // sold in the shop (the discard→apple action)
|
||
TriggerBuy EffectTrigger = "buy" // purchased (also fires on pets gained via Triple)
|
||
TriggerPlay EffectTrigger = "play" // revealed on the stack during battle
|
||
TriggerTriple EffectTrigger = "triple" // used as one of the three traded-in cards
|
||
TriggerHurt EffectTrigger = "hurt" // attacked and received damage
|
||
// TriggerBattlePrep fires right after the shop phase ends, as players
|
||
// begin ordering their decks.
|
||
TriggerBattlePrep EffectTrigger = "battlePrep"
|
||
// TriggerPassive marks always-on effects (e.g. Garlic's damage
|
||
// prevention); they're consulted contextually rather than fired.
|
||
TriggerPassive EffectTrigger = "passive"
|
||
)
|
||
|
||
// EffectAction is what the effect does.
|
||
type EffectAction string
|
||
|
||
const (
|
||
// ActionSummonTop puts Count cards (Effect.Card: "apple" or "bee") on
|
||
// top of a deck/stack — the owner's, or the enemy's when Target is
|
||
// "enemy". Battle-time.
|
||
ActionSummonTop EffectAction = "summonTop"
|
||
// ActionGainApple adds Count apples to the player's hand. Shop-time.
|
||
ActionGainApple EffectAction = "gainApple"
|
||
// ActionThrowRock rolls Count rock dice (faces: 0,0,1,1,2,2) and deals
|
||
// the total to the opposing pet in play. Battle-time.
|
||
ActionThrowRock EffectAction = "throwRock"
|
||
// ActionEatApple gives the pet itself +Count power (as if it ate
|
||
// apples), if it hasn't fainted. Battle-time. With Per set, Count is
|
||
// multiplied by a battle statistic (see Effect.Per).
|
||
ActionEatApple EffectAction = "eatApple"
|
||
// ActionRefreshGold returns Count spent coins to the player (never
|
||
// above the round's allowance). Shop-time.
|
||
ActionRefreshGold EffectAction = "refreshGold"
|
||
// ActionPreventDamage (passive) reduces every attack that hits this pet
|
||
// by Count damage.
|
||
ActionPreventDamage EffectAction = "preventDamage"
|
||
// ActionRecycleApples (faint) puts up to Count of this pet's attached
|
||
// apples back on top of its owner's deck.
|
||
ActionRecycleApples EffectAction = "recycleApples"
|
||
// ActionDelayedRocks (faint) sets the pet aside: when its owner plays
|
||
// their next pet, it throws Count rocks at EACH active pet — the
|
||
// enemy's and the owner's own.
|
||
ActionDelayedRocks EffectAction = "delayedRocks"
|
||
)
|
||
|
||
// Per multipliers for dynamic effect counts.
|
||
const PerFaintedBees = "faintedBees" // × friendly bees fainted this battle
|
||
|
||
// Effect is one trigger→action pair printed on a card.
|
||
type Effect struct {
|
||
Trigger EffectTrigger `json:"trigger"`
|
||
Action EffectAction `json:"action"`
|
||
Card string `json:"card,omitempty"` // summonTop: "apple" | "bee"
|
||
Count int `json:"count,omitempty"` // 0 means 1
|
||
Target string `json:"target,omitempty"` // summonTop: "" (self) | "enemy"
|
||
// Per multiplies Count by a battle statistic (e.g. PerFaintedBees).
|
||
Per string `json:"per,omitempty"`
|
||
// MinRound gates the effect to round >= MinRound (0 = always).
|
||
MinRound int `json:"minRound,omitempty"`
|
||
}
|
||
|
||
// count normalizes the zero value to 1.
|
||
func (e Effect) count() int {
|
||
if e.Count <= 0 {
|
||
return 1
|
||
}
|
||
return e.Count
|
||
}
|
||
|
||
// Card is a single physical card instance. IDs are unique per game.
|
||
type Card struct {
|
||
ID string `json:"id"`
|
||
Kind CardKind `json:"kind"`
|
||
Name string `json:"name"`
|
||
Tier int `json:"tier,omitempty"`
|
||
Power int `json:"power,omitempty"`
|
||
Suit Suit `json:"suit,omitempty"`
|
||
// Effects drive the engine; EffectText is the human-readable rule shown
|
||
// on the card face.
|
||
Effects []Effect `json:"effects,omitempty"`
|
||
EffectText string `json:"effectText,omitempty"`
|
||
Food string `json:"food,omitempty"`
|
||
// Perk foods (e.g. Honey) attach like any food, but a pet only benefits
|
||
// from the last-applied perk.
|
||
Perk bool `json:"perk,omitempty"`
|
||
// Temporary cards (apples, bees) are removed from the deck after the
|
||
// next battle.
|
||
Temporary bool `json:"temporary,omitempty"`
|
||
}
|
||
|
||
func (c Card) IsPet() bool { return c.Kind == KindPet }
|
||
func (c Card) IsFood() bool { return c.Kind == KindFood }
|
||
|
||
// petTemplate is the printed definition of a pet. Suits lists the suit of
|
||
// each physical copy in the tier deck (one card per entry).
|
||
type petTemplate struct {
|
||
Name string
|
||
Power int
|
||
Suits []Suit
|
||
Effects []Effect
|
||
EffectText string
|
||
}
|
||
|
||
// foodTemplate is the printed definition of a food card that lives in a
|
||
// shop deck (e.g. Honey).
|
||
type foodTemplate struct {
|
||
Name string
|
||
Food string
|
||
Copies int
|
||
Perk bool
|
||
Effects []Effect
|
||
EffectText string
|
||
}
|
||
|
||
// petTiers defines the shop decks' pets. Index 0 is tier 1 (round 1)
|
||
// through index 5 for tier 6 (round 6).
|
||
//
|
||
// Tiers 1-2 are real card data. Tiers 3-6 are placeholders with the same
|
||
// structure until their real definitions are provided.
|
||
var petTiers = [MaxRounds][]petTemplate{
|
||
{ // Tier 1
|
||
{
|
||
Name: "Ant", Power: 1, Suits: []Suit{SuitBlue, SuitYellow},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "apple"}},
|
||
EffectText: "Faint: add an Apple on top of your deck",
|
||
},
|
||
{
|
||
Name: "Cricket", Power: 1, Suits: []Suit{SuitRed, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "bee"}},
|
||
EffectText: "Faint: add a Bee on top of your deck",
|
||
},
|
||
{
|
||
Name: "Duck", Power: 2, Suits: []Suit{SuitYellow, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerSell, Action: ActionGainApple}},
|
||
EffectText: "Sell: add 1 extra Apple to your hand",
|
||
},
|
||
{
|
||
Name: "Otter", Power: 1, Suits: []Suit{SuitYellow, SuitRed},
|
||
Effects: []Effect{{Trigger: TriggerBuy, Action: ActionGainApple}},
|
||
EffectText: "Buy: add an Apple to your hand",
|
||
},
|
||
{
|
||
Name: "Mosquito", Power: 2, Suits: []Suit{SuitRed, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerPlay, Action: ActionThrowRock}},
|
||
EffectText: "Play: throw 1 Rock",
|
||
},
|
||
{
|
||
Name: "Fish", Power: 2, Suits: []Suit{SuitYellow, SuitRed},
|
||
Effects: []Effect{{Trigger: TriggerTriple, Action: ActionGainApple}},
|
||
EffectText: "Triple: add an Apple to your hand",
|
||
},
|
||
},
|
||
{ // Tier 2
|
||
{
|
||
Name: "Worm", Power: 2, Suits: []Suit{SuitBlue, SuitYellow},
|
||
Effects: []Effect{{Trigger: TriggerBuy, Action: ActionGainApple, Count: 2}},
|
||
EffectText: "Buy: add 2 Apples to your hand",
|
||
},
|
||
{
|
||
Name: "Flamingo", Power: 1, Suits: []Suit{SuitRed, SuitYellow},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "apple", Count: 2}},
|
||
EffectText: "Faint: add 2 Apples on top of your deck",
|
||
},
|
||
{
|
||
Name: "Peacock", Power: 2, Suits: []Suit{SuitBlue, SuitRed},
|
||
Effects: []Effect{{Trigger: TriggerHurt, Action: ActionEatApple}},
|
||
EffectText: "Hurt: if this pet hasn't fainted, it eats 1 Apple",
|
||
},
|
||
{
|
||
Name: "Swan", Power: 1, Suits: []Suit{SuitRed, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerTriple, Action: ActionRefreshGold, MinRound: 3}},
|
||
EffectText: "Triple: if it is round 3 or later, refresh a spent Gold",
|
||
},
|
||
{
|
||
Name: "Rat", Power: 4, Suits: []Suit{SuitRed, SuitYellow},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "bee", Target: "enemy"}},
|
||
EffectText: "Faint: add a Bee on top of the enemy deck",
|
||
},
|
||
{
|
||
Name: "Spider", Power: 2, Suits: []Suit{SuitYellow, SuitBlue},
|
||
Effects: []Effect{
|
||
{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "bee"},
|
||
{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "apple"},
|
||
},
|
||
EffectText: "Faint: add a Bee, then an Apple, on top of your deck",
|
||
},
|
||
},
|
||
{ // Tier 3
|
||
{
|
||
Name: "Dog", Power: 2, Suits: []Suit{SuitYellow, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerPlay, Action: ActionEatApple, Per: PerFaintedBees}},
|
||
EffectText: "Play: eats 1 Apple for each friendly fainted Bee",
|
||
},
|
||
{
|
||
Name: "Dolphin", Power: 2, Suits: []Suit{SuitBlue, SuitRed},
|
||
Effects: []Effect{{Trigger: TriggerPlay, Action: ActionThrowRock, Count: 3}},
|
||
EffectText: "Play: throw 3 Rocks",
|
||
},
|
||
{
|
||
Name: "Giraffe", Power: 2, Suits: []Suit{SuitRed, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerBattlePrep, Action: ActionGainApple, Count: 2}},
|
||
EffectText: "Battle Prep: add 2 Apples to your hand",
|
||
},
|
||
{
|
||
Name: "Camel", Power: 3, Suits: []Suit{SuitYellow, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerHurt, Action: ActionSummonTop, Card: "apple"}},
|
||
EffectText: "Hurt: add an Apple on top of your deck",
|
||
},
|
||
{
|
||
Name: "Sheep", Power: 3, Suits: []Suit{SuitYellow, SuitRed},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "bee", Count: 2}},
|
||
EffectText: "Faint: add 2 Bees on top of your deck",
|
||
},
|
||
{
|
||
Name: "Dodo", Power: 3, Suits: []Suit{SuitRed, SuitBlue},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionRecycleApples, Count: 3}},
|
||
EffectText: "Faint: put up to 3 of this pet's Apples on top of your deck",
|
||
},
|
||
{
|
||
Name: "Badger", Power: 3, Suits: []Suit{SuitRed, SuitYellow},
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionDelayedRocks, Count: 2}},
|
||
EffectText: "Faint: set aside — when you play your next pet, throw 2 Rocks at each active pet",
|
||
},
|
||
},
|
||
placeholderTier([6]string{"Skunk", "Hippo", "Bison", "Deer", "Squirrel", "Whale"},
|
||
[6]int{5, 6, 6, 4, 4, 5}),
|
||
placeholderTier([6]string{"Scorpion", "Rhino", "Monkey", "Cow", "Seal", "Shark"},
|
||
[6]int{5, 7, 6, 6, 6, 7}),
|
||
placeholderTier([6]string{"Leopard", "Boar", "Gorilla", "Mammoth", "Snake", "Tiger"},
|
||
[6]int{8, 9, 9, 10, 8, 9}),
|
||
}
|
||
|
||
// foodTiers defines the food cards mixed into each tier's shop deck.
|
||
var foodTiers = [MaxRounds][]foodTemplate{
|
||
{}, // Tier 1
|
||
{ // Tier 2
|
||
{
|
||
Name: "Honey", Food: FoodHoney, Copies: 2, Perk: true,
|
||
Effects: []Effect{{Trigger: TriggerFaint, Action: ActionSummonTop, Card: "bee"}},
|
||
EffectText: "Faint: add a Bee on top of your deck",
|
||
},
|
||
},
|
||
{ // Tier 3
|
||
{
|
||
Name: "Garlic", Food: FoodGarlic, Copies: 2, Perk: true,
|
||
Effects: []Effect{{Trigger: TriggerPassive, Action: ActionPreventDamage}},
|
||
EffectText: "Every attack that hits this pet deals 1 less damage",
|
||
},
|
||
},
|
||
{}, {}, {},
|
||
}
|
||
|
||
// placeholderTier mirrors tier 1's suit distribution (each suit appears on 4
|
||
// of the 12 cards) for pets whose real definitions aren't in yet.
|
||
func placeholderTier(names [6]string, powers [6]int) []petTemplate {
|
||
suitPairs := [6][]Suit{
|
||
{SuitBlue, SuitYellow},
|
||
{SuitRed, SuitBlue},
|
||
{SuitYellow, SuitBlue},
|
||
{SuitYellow, SuitRed},
|
||
{SuitRed, SuitBlue},
|
||
{SuitYellow, SuitRed},
|
||
}
|
||
tier := make([]petTemplate, 6)
|
||
for i := range names {
|
||
tier[i] = petTemplate{Name: names[i], Power: powers[i], Suits: suitPairs[i]}
|
||
}
|
||
return tier
|
||
}
|
||
|
||
// newCardID mints a unique card ID within the game.
|
||
func (g *Game) newCardID() string {
|
||
g.NextCardID++
|
||
return fmt.Sprintf("c%d", g.NextCardID)
|
||
}
|
||
|
||
// buildShopDecks creates all six tier decks (unshuffled).
|
||
func (g *Game) buildShopDecks() {
|
||
g.ShopDecks = make([][]Card, MaxRounds)
|
||
for tierIdx := range petTiers {
|
||
var deck []Card
|
||
for _, t := range petTiers[tierIdx] {
|
||
for _, suit := range t.Suits {
|
||
deck = append(deck, Card{
|
||
ID: g.newCardID(),
|
||
Kind: KindPet,
|
||
Name: t.Name,
|
||
Tier: tierIdx + 1,
|
||
Power: t.Power,
|
||
Suit: suit,
|
||
Effects: t.Effects,
|
||
EffectText: t.EffectText,
|
||
})
|
||
}
|
||
}
|
||
for _, f := range foodTiers[tierIdx] {
|
||
for range f.Copies {
|
||
deck = append(deck, Card{
|
||
ID: g.newCardID(),
|
||
Kind: KindFood,
|
||
Name: f.Name,
|
||
Tier: tierIdx + 1,
|
||
Food: f.Food,
|
||
Perk: f.Perk,
|
||
Effects: f.Effects,
|
||
EffectText: f.EffectText,
|
||
})
|
||
}
|
||
}
|
||
g.ShopDecks[tierIdx] = deck
|
||
}
|
||
}
|
||
|
||
// newApple mints an apple food card. Apples are temporary: they vanish from
|
||
// the deck after the next battle.
|
||
func (g *Game) newApple() Card {
|
||
return Card{
|
||
ID: g.newCardID(),
|
||
Kind: KindFood,
|
||
Name: "Apple",
|
||
Food: FoodApple,
|
||
Temporary: true,
|
||
}
|
||
}
|
||
|
||
// newBee mints a bee: a temporary 1-power pet with no effect, summoned by
|
||
// other pets' effects. It counts as a pet while it exists (foods can attach
|
||
// to it in battle).
|
||
func (g *Game) newBee() Card {
|
||
return Card{
|
||
ID: g.newCardID(),
|
||
Kind: KindPet,
|
||
Name: "Bee",
|
||
Power: 1,
|
||
Temporary: true,
|
||
}
|
||
}
|