match

type ActiveCard struct {
	Card         *Card
	Mode         CardMode
	Desc         *card.RichDescription
	Effects      []CardEffect
	UnNumb       int64
	ATK          card.Number
	DEF          card.Number
	ActiveEffect *card.EffectDef
	CreatedBy    interface{} // *ActiveCard, HandCard, or *Card
	StayOnField  bool
}

type AvailableMode struct {
	Client        string `json:"s"`
	Name          string `json:"t"`
	Revisions     int    `json:"r"`
	ModeData      []byte `json:"m"`
	FirstCard     []byte `json:"fc"`
	CategoryColor int32  `json:"c"`
	CategoryID    int64  `json:"ci"`
}

type AvailableModes struct {
	Categories []ModeCategory  `json:"c"`
	Modes      []AvailableMode `json:"m"`
}

type Card struct {
	Set  *card.Set
	Def  *card.Def
	Back card.Rank
}

type CardEffect struct {
	Card   *ActiveCard
	Effect *card.EffectDef
	Target card.ID
	Player uint8
}

type CardMode uint64

type GameLog struct {
	Root *LogGroup

	Disabled bool
	Debug    bool
	// contains filtered or unexported fields
}

type HandCard struct {
	*Card
	InHandTurns int64
	Temporary   bool
}

type Init struct {
	// Mode is the name of the game mode, one of the following:
	// - an empty string (vanilla)
	// - "custom" (ad-hoc custom)
	// - name.v, where name is a lowercase ascii string and
	//   v is a positive integer (hosted community game mode)
	Mode string

	// Version is the Spy Cards Online version number at the time this match
	// was played.
	Version [3]uint64

	// Custom is the encoded custom cards. For vanilla, this should be empty.
	// For hosted game modes, this should match the mode's data as returned by
	// the server. For ad-hoc custom game modes, this may be any non-empty
	// string of card data.
	Custom string

	// Variant is the game mode variant. Variant may be 0 if there are no
	// variants defined by the game mode. Otherwise, Variant must be less than
	// the number of variants defined by the game mode.
	Variant uint64

	External      *card.ExternalMode
	CachedVariant *card.Variant
	Latest        bool
}

type LogGroup struct {
	Title     string
	Index     int
	Messages  []string
	SubGroups []*LogGroup
}

type Match struct {
	// Init holds data known before the match is established.
	Init *Init

	// Start is the timestamp of the start of the first round. That is, when
	// both players finished selecting their decks.
	Start time.Time

	// Rematches is the number of matches that happened within this
	// matchmaking session so far. It starts at 0 and increases by 1 each
	// time the players agree to a rematch.
	Rematches uint64

	Wins, Losses uint64

	// Perspective is the player number (either 1 or 2, for hosting player or
	// joining player, respectively).
	Perspective uint8

	UnknownDeck uint8

	// NoStats is true if there are zero cards in the set with stat-affecting effects (card stat, empower, etc.)
	NoStats bool

	// Cosmetic holds non-critical cosmetic data for the players of the match.
	Cosmetic [2]card.CosmeticData

	// Set is the modified card set, with changes applied by spoiler guard, etc.
	Set *card.Set

	// Rules is a copy of the rules from Set for convenience.
	Rules [2]card.GameRules

	// Timer is a copy of the timer from Set for convenience.
	Timer card.Timer

	// Banned is a cache of banned cards from Set.
	Banned map[card.ID]bool

	// Unpickable is a cache of unpickable cards from Set.
	Unpickable map[card.ID]bool

	// Unfiltered is a cache of unfiltered cards from Set.
	Unfiltered map[card.ID]bool

	HasReplaceSummon map[card.ID]bool
	OrderForSummon   map[card.ID]int

	// SpecialFlags is a cache of special flags from Set.
	SpecialFlags map[card.SpecialFlag]bool

	// State is the mutable state of the match.
	State State

	// Log is the game log.
	Log GameLog
	// contains filtered or unexported fields
}

type ModeCategory struct {
	ID          int64  `json:"i"`
	Name        string `json:"t"`
	Description string `json:"d"`
	Color       int32  `json:"c"`
}

type Network interface {
	SendModifiedCards([]card.ModifiedCardPosition, bool) error
	RecvModifiedCards(bool) []card.ModifiedCardPosition
}

type Recording struct {
	Recording *card.Recording
	Set       *card.Set
	// contains filtered or unexported fields
}

type Side struct {
	HP       card.Number
	TP       card.Number
	ATK      card.Number
	DEF      card.Number
	RawATK   card.Number
	RawDEF   card.Number
	FinalATK card.Number
	FinalDEF card.Number

	HealMulP int64
	HealMulN int64
	HealP    card.Number
	HealN    card.Number

	Hand    []HandCard
	Deck    []*Card
	Discard []*Card
	Exile   map[string][]*Card
	Field   []*ActiveCard
	Setup   []*ActiveCard

	Limit map[*card.EffectDef]int64
	ModTP map[card.ID]card.Number
}

type State struct {
	// Round is the current round number.
	Round uint64

	// Sides holds state that is separate for each player.
	Sides [2]Side

	// Queue is the card effect queue.
	Queue []CardEffect

	PreQueue    []CardEffect
	OnNumbQueue []CardEffect

	// OnNumb is the effects that activate on numb.
	OnNumb []CardEffect

	// MaxPriority is the latest effect priority processed this turn.
	MaxPriority uint8

	// RoundWinner is the player who won this round.
	RoundWinner uint8

	// TurnData is used to record networked card modifications.
	TurnData *card.TurnData
}