engine source pure

 1const (
 2	GainBlock EffectKind = iota
 3	GainCounter
 4	Hit      // deal N damage
 5	HitBlock // deal damage equal to your Block
 6	ApplyVulnerable
 7	GainStrength
 8	VulnerableIfCancelled // apply N Vulnerable if this card cancelled a card this beat
 9	MoveVulnerable        // Block phase: move all your Vulnerable to the opponent
10	GainVulnerable        // gain N Vulnerable yourself
11	HitPerVulnerable      // deal N damage, and N more for each Vulnerable on you
12	BlockPerVulnerable    // Block phase: gain N Block, and N more for each Vulnerable on you
13	StripBlock            // the opponent loses all Block at the end of the step
14	HitHardest            // deal the HP the hardest opponent hit took from you this round, up to N
15	HitIfNotAttacked      // deal N damage if no opponent attack lands this beat
16)

 1const (
 2	Cancelled         EventKind = iota // Card was cancelled by the opponent's Interrupt or Parry
 3	ParryEnded                         // Card made its last Parry cancel; its later beats stay empty
 4	BlockGained                        // Side gained N Block from Card
 5	CounterGained                      // Side gained Counter N from Card
 6	HitLanded                          // Card hit the opponent for N damage to HP, Blocked absorbed
 7	CounterHit                         // the opponent's Counter dealt N to Side's HP after Card hit
 8	VulnerableApplied                  // Card applied N Vulnerable to the opponent
 9	StrengthGained                     // Side gained N Strength from Card
10	VulnerableMoved                    // Card moved Side's N Vulnerable to the opponent, who keeps up to the cap
11	VulnerableGained                   // Side gained N Vulnerable from Card
12	BlockStripped                      // Card took the opponent's N Block
13)

1const (
2	InterruptPhase Phase = iota
3	BlockPhase
4	DamagePhase
5)

1const (
2	Ongoing Result = iota
3	AWins
4	BWins
5	Draw
6)

1const (
2	SideA Side = iota
3	SideB
4)

1const (
2	Quick Tier = iota
3	Normal
4	Slow
5)

1func ProofOfConcept() *Ruleset

 1type Card struct {
 2	Name      string
 3	Cost      int
 4	Tier      Tier
 5	Special   bool // spent once played; basics are not
 6	Rare      bool // the clan's signature card; a deck holds exactly one
 7	Interrupt bool
 8	Parry     int      // Parry N: attacks it cancels while active; 0 for no Parry
 9	Block     []Effect // Block phase
10	Damage    []Effect // Damage phase, in printed order
11	OnCancel  []Effect // Block phase of the beat the card is cancelled on
12	// CancelDamage resolves in the card's tier, in the Damage phase of the beat it is
13	// cancelled on.
14	CancelDamage []Effect
15}

1type CardID int

1type Clan struct {
2	Name string
3	Pool uint64 // bit i set: Ruleset.Cards[i] is in the pool
4}

1type Effect struct {
2	Kind EffectKind
3	N    int
4}

1type EffectKind int

 1type Event struct {
 2	Beat    int // 1 to 3
 3	Phase   Phase
 4	Tier    Tier
 5	Step    int // from 1 within a beat, phase and tier; equal for effects that resolve together
 6	Kind    EventKind
 7	Side    Side
 8	Card    CardID
 9	N       int
10	Blocked int       // HitLanded and CounterHit: damage absorbed by Block
11	Doubled bool      // HitLanded: the defender's Vulnerable doubled it
12	After   [2]Vitals // both gnomes once the whole step has resolved
13}

1type EventKind int

1type Gnome struct {
2	HP, Vulnerable, Strength int
3	Spent                    uint64 // special cards played, by CardID bit
4}

1type Outcome struct {
2	State  State
3	Result Result
4}

1type Phase int

1type Plan []CardID

1type Result int

 1type Ruleset struct {
 2	Cards         []Card
 3	Clans         []Clan
 4	HP            int // starting HP of both gnomes
 5	BlockCap      int
 6	CounterCap    int
 7	VulnerableCap int
 8	StrengthCap   int
 9	// VulnerableDoublesOneHit: each hit against a Vulnerable gnome deals double and uses a
10	// token. Otherwise the next card to hit deals double on every hit and uses one token.
11	VulnerableDoublesOneHit bool
12	// StrengthLastsTheRound: Strength ends with the round, like Block and Counter. Otherwise
13	// it lasts the match.
14	StrengthLastsTheRound bool
15	// VulnerableLastsTheRound: unused Vulnerable ends with the round. Otherwise it lasts
16	// until hits use it.
17	VulnerableLastsTheRound bool
18}

1type Side int

1type State struct {
2	Round  int
3	Gnomes [2]Gnome
4}

1type Tier int

1type Vitals struct {
2	HP, Block, Counter, Vulnerable, Strength int
3}