boardgame

type Agent interface {
	//Name is the unique, static name for this type of agent. Many games will
	//have only one type of agent, but the reason for this field is that some
	//games will have different agents with radically different play styles.
	//The name is how agents will be looked up within a manager.
	Name() string

	//DisplayName is a name for the agent that is human-friendly and need not
	//be unique. "Artificial Intelligence", "Computer", "Robby the Robot" are
	//all reasonable examples.
	DisplayName() string

	//SetUpForGame is called when a Game is being set up and Agents are
	//configured for some of the players. This is the chance of the Agent to
	//initialize its state. Whatever state is returned will be stored in the
	//storage layer and passed back to the Agent later.
	SetUpForGame(game *Game, player PlayerIndex) (agentState []byte)

	//ProposeMove is where the meat of Agents happen. It is called once after
	//every MoveChain is made on game (that is, after every player Move and
	//its attendant chain of FixUp moves have all been applied). It is passed
	//the index of the player it is playing at, the game, and the last-stored
	//state for this agent. The game may be interrogated for CurrentState,
	//PlayerMoves, etc, but should NOT have ProposeMove called directly. This
	//method should return a non-nil move ≈ if it wants to propose one.
	//newState is the new state for this agent; if it is nil, a new state will
	//not be saved and the next time ProposeMove is called the previously used
	//state will be provided again.
	ProposeMove(game *Game, player PlayerIndex, agentState []byte) (move Move, newState []byte)
}

type Board interface {
	ImmutableBoard
	Spaces() []Stack
	SpaceAt(index int) Stack
	// contains filtered or unexported methods
}

type Component interface {

	//Values returns the ComponentValues struct that you associated with this
	//component via deck.AddComponent during GameDelegate.ConfigureDecks().
	Values() ComponentValues

	//Deck returns the deck that this component is part of.
	Deck() *Deck

	//DeckIndex returns the index into the deck that this component is. This
	//is always fixed and never changes in any game.
	DeckIndex() int

	//Equivalent checks whether two components are equivalent--that is,
	//whether they represent the same index in the same deck.
	Equivalent(other Component) bool

	//Instance returns a mutable ComponentInstance representing the specific
	//instantiation of this component in the given state of the given game.
	//Will never return nil, even if the component isn't valid in this state
	//----although later things like ContainingStack may error later in that
	//case. ComponentInstance is where the methods for moving the instance to
	//other stacks lie.
	Instance(st State) ComponentInstance

	//ImmutableInstance returns an ImmutableComponentInstance representing the
	//specific instantiation of this component in the given state of the given
	//game. Will never return nil, even if the component isn't valid in this
	//state--although later things like ContainingStack may error later in
	//that case.
	ImmutableInstance(st ImmutableState) ImmutableComponentInstance

	//Generic returns true if this Component is the generic component for this
	//deck. You might get this component if you ask for a component from a
	//sanitized stack. This method is a convenience method equivalent to
	//checking for equivalency to Deck().GenericComponent().
	Generic() bool
	// contains filtered or unexported methods
}

type ComponentChest struct {
	// contains filtered or unexported fields
}

type ComponentInstance interface {

	//ComponentInstance can be used anywhere that ImmutableComponentInstance
	//can be.
	ImmutableComponentInstance

	//DynamicValues returns the Dynamic Values for this component in the state
	//this instance is associated with, if it exists. A convenience so you
	//don't have to go find them within  state.DynamicComponentValues
	//yourself.
	DynamicValues() SubState

	//ContainingStack will return the stack and slot index for the associated
	//component, if that location is not sanitized, and the componentinstance
	//is legal for the state it's in. If no error is returned,
	//stack.ComponentAt(slotIndex) == c will evaluate to true.
	ContainingStack() (stack Stack, slotIndex int, err error)

	//MoveTo moves the specified component in its current stack to the
	//specified slot in the destination stack. The destination stack must be
	//different than the one the component's currently in--if you're moving
	//components within a stack, use SwapComponent. In destination, slotIndex
	//must point to a valid "slot" to put a component, such that after
	//insertion, using that index on the destination will return that
	//component. In default Stacks, slots are any index from 0 up to and
	//including stack.Len(), because the stack will grow to insert the
	//component between existing components if necessary. For SizedStacks,
	//slotIndex must point to a currently empty slot.
	//MoveTo{First,Last,Next}Slot methods are useful if you want to move to
	//those locations. If you want the precise location of the inserted
	//component to not be visible, see SecretMoveTo.
	MoveTo(other Stack, slotIndex int) error

	//SecretMoveTo is equivalent to MoveTo, but after the move the Ids of all
	//components in destination will be scrambled. SecretMoveTo is useful when
	//the destination stack will be sanitized with something like PolicyOrder,
	//but the precise location of this insertion should not be observable. For
	//example, if you're cutting a given card to an unknown location deep in
	//the middle of a large stack.
	SecretMoveTo(other Stack, slotIndex int) error

	//MoveToFirstSlot moves the component to the first valid slot in the other
	//stack. For default Stacks, this is always 0. For SizedStacks, this is
	//the first empty slot from the left. A convenience wrapper around
	//stack.FirstSlot.
	MoveToFirstSlot(other Stack) error

	//MoveToLastSlot moves the component to the last valid slot in the other
	//stack. For default Stacks, this is always Len(). For SizedStacks, this
	//is the first empty slot from the right. A convenience wrappar around
	//stack.LastSlot().
	MoveToLastSlot(other Stack) error

	//MoveToNextSlot moves the component to the next valid slot in the other
	//stack where the component could be added without splicing. For default
	//stacks this is equivalent to MoveToLastSlot. For fixed size stacks this
	//is equivalent to MoveToFirstSlot. A convenience wrapper arond
	//stack.NextSlot().
	MoveToNextSlot(other Stack) error

	//SlideToFirstSlot takes the given component and moves it to the start of
	//the same stack, moving everything else up. It is equivalent to removing
	//the component, moving it to a temporary stack, and then moving it back
	//to the original stack with MoveToFirstSlot--but of course without
	//needing the extra scratch stack.
	SlideToFirstSlot() error

	//SlideToLastSlot takes the given component and moves it to the end of the
	//same stack, moving everything else down. It is equivalent to removing
	//the component, moving it to a temporary stack, and then moving it back
	//to the original stack with MoveToLastSlot--but of course without needing
	//the extra scratch stack.
	SlideToLastSlot() error
}

type ComponentValues interface {
	//Reader is the way that the engine will enumerate and extract properties
	//on the ComponentValues.
	Reader
	//ContainingComponent is the component that this ComponentValues is
	//embedded in. It should return the component that was passed to
	//SetContainingComponent.
	ContainingComponent() Component
	//SetContainingComponent is called to let the component values know what
	//its containing component is.
	SetContainingComponent(c Component)
}

type ConfigurableSubState interface {
	//Every SubState should be able to have its containing State set and read
	//back, so each sub-state knows how to reach up and over into other parts of
	//the over-arching state. You can implement this interface by emedding
	//base.SubState in your struct. This is how the values returned in
	//StateGetter methods are installed on your struct.
	ContainingStateConnector

	//This is how the values set via the StateSetter methods are retrieved from
	//your struct.
	StateGetter

	//ReadSetConfigurer defines the method to retrieve the
	//PropertyReadSetConfigurer for this object type. Typically this getter--
	//and the underlying PropertyReadSetConfigurer it returns--are generated
	//via `boardgame-util codegen`.
	ReadSetConfigurer
}

type ConfigurationValidator interface {
	//ValidConfiguration will be checked when the NewGameManager is being set
	//up, and if it returns an error the manager will fail to be created.
	ValidConfiguration(exampleState State) error
}

type ContainingStateConnector interface {
	//ConnectContainingState is called when the SubState is almost done being
	//initialized and just needs to be told who its containing State is and what
	//piece of the containing State this SubState is (i.e if it's a Game,
	//Player, or DynamicComponentValues, and what its Player or DeckIndex is∑).
	//The values passed here should be returned from State(), ImmutableState(),
	//and StatePropertyRef(). Although even ImmutableStates will see the full,
	//mutable State via this method, they should not do anything mutable with
	//it. The StatePropertyRef passed will have PropName as "" since it refers
	//to the entire Reader, not a specific property on it.
	ConnectContainingState(state State, ref StatePropertyRef)

	//FinishStateSetUp is called once the SubState is fully initialized and
	//ConnectContainingStack has been called. The game engine doesn't require
	//anything to happen here, but this is where behaviors are typically
	//connected.
	FinishStateSetUp()
}

type Deck struct {
	// contains filtered or unexported fields
}

type DelayedError chan error

type Game struct {
	// contains filtered or unexported fields
}

type GameDelegate interface {

	//Name is a string that defines the type of game this is. This must return
	//the package name that contains the game (e.g.
	//"github.com/jkomoros/mygame" should return "mygame"), since the package
	//name and the delegate.Name() are both used at different times in the
	//system, since one can be determined statically and the other only at
	//run-time. NewGameManager will fail if that is not true.The name should
	//be unique and compact since it will sometimes be used in a URL path.
	//Good examples are "tictactoe", "blackjack". Once configured, names
	//should never change over the lifetime of the gametype, since it will be
	//persisted in storage.
	Name() string

	//DisplayName is a string that defines the type of game this is in a way
	//appropriate for humans. The name should be unique but human readable. It
	//is purely for human consumption, and may change over time with no
	//adverse effects. Good examples are "Tic Tac Toe", "Blackjack".
	//Subclasses should override this.
	DisplayName() string

	//Description is a string that describes the game type in a descriptive
	//sentence, for use in showing to end users. A reasonable value for
	//"tictactoe" is "A classic game where players compete to get three in a
	//row"
	Description() string

	//ConfigureMoves will be called during creation of a GameManager in
	//NewGameManager. This is the time to install moves onto the manager by
	//returning a list of moves to install. This is the single most important
	//configuration point for your game logic, as the collection of moves for
	//the game--and the logic of when they apply--is the bedrock of your game
	//logic. Typically you use moves.Combine and friends to organize your list
	//of moves to install. If the moves you add are illegal for any reason,
	//NewGameManager will fail with an error. By the time this is called.
	//delegate.SetManager will already have been called, so you'll have access
	//to the manager via Manager().
	ConfigureMoves() []MoveConfig

	//ConfigureAgents will be called when creating a new GameManager. Emit the
	//agents you want to install.
	ConfigureAgents() []Agent

	//ConfigureDecks will be called when the GameManager is being booted up.
	//Each entry in the return value will be added to the ComponentChest that
	//is being created for this game type. This method is where you create
	//individual decks via NewDeck and associate the right underlying
	//ComponentValues with each component via AddComponent.
	ConfigureDecks() map[string]*Deck

	//ConfigureEnums is called during set up of a new GameManager. Return the
	//set of enums you want to be associated with this GameManagaer's Chest.
	//`boardgame-util codegen` will often generate this automatically for you.
	ConfigureEnums() *enum.Set

	//ConfigureConstants is called during set-up of a new GameManager. Return
	//the map of constants you want to create, which will be configured onto
	//the newly created chest. If any of the constants cannot be added to the
	//ComponentChest, errors, the GameManager will fail to be set up.
	//Constants are primarily useful in two cases: first, when you want to
	//have access to a constant value client-side, and second, when you want
	//to be able to use a constant value in a struct tag provided as an
	//instruction for a StructInflater.
	ConfigureConstants() PropertyCollection

	//GameStateConstructor and PlayerStateConstructor are called to get an
	//instantiation of the concrete game/player structs that your package
	//defines. This is used both to create the initial state, but also to
	//inflate states from the database. These methods should always return the
	//underlying same type of struct when called. This means that if different
	//players have very different roles in a game, there might be many
	//properties that are not in use for any given player. The simple
	//properties (ints, bools, strings) should all be their zero-value.
	//Importantly, all Stacks, Timers, and Enums should be non- nil, because
	//an initialized struct contains information about things like MaxSize,
	//Size, and a reference to the deck they are affiliated with. GameManger
	//will automatically create and use StructInflaters for these types of
	//objects, allowing you to use tag-based configuration to automatically
	//inflate these properties. See the documentation for StructInflater for
	//more.
	GameStateConstructor() ConfigurableSubState
	//PlayerStateConstructor is similar to GameStateConstructor, but playerIndex
	//is provided as a convenience if it's useful (your constructor need not do
	//anything wiht it, typically `return new(playerState)` is sufficient).
	PlayerStateConstructor(player PlayerIndex) ConfigurableSubState

	//DynamicComponentValuesConstructor returns an empty
	//DynamicComponentValues for the given deck. DynamicComponentValues are
	//useful for representing when a given component has mutable properties
	//associated with it--for example, if a given card could have a stack of
	//tokens on top, the stack of tokens would be a property on a
	//DynamicComponentValues associated with that card component. If nil is
	//returned, then the components in that deck don't have any dynamic
	//component state. This method must always return the same underlying type
	//of struct for the same deck. Like GameStateConstructor and
	//PlayerStateConstructor, the engine will automatically create
	//StructInflaters for these objects, allowing you to use tag-based
	//inflation of properties. See StructInflate for more. If the returned
	//object also implements the ComponentValues interface, then
	//SetContainingComponent will be called on the DynamicComponent whenever
	//one is created, with a reference back to the component it's associated
	//with.
	DynamicComponentValuesConstructor(deck *Deck) ConfigurableSubState

	//DistributeComponentToStarterStack is called during set up of a given
	//Game to establish the Deck/Stack invariant that every component in the
	//chest is placed in precisely one Stack. Game will call this on each
	//component in the Chest in order. This is where the logic goes to make
	//sure each Component goes into its correct starter stack. You must return
	//a non-nil Stack for each call, after which the given Component will be
	//inserted into NextSlotIndex of that stack. If that is not the ordering
	//you desire, you can fix it up in FinishSetUp by using SwapComponents. If
	//any errors are returned, any nil Stacks are returned, or any returned
	//stacks don't have space for another component, NewGame will fail and
	//return an error. State and Component are only provided for reference; do
	//not modify them.
	DistributeComponentToStarterStack(state ImmutableState, c Component) (ImmutableStack, error)

	//BeginSetup is called on a newly created Game before components are
	//distributed via DistributeComponentToStarterStack. If you need to modify
	//your state before components are distributed, do it here. It is also
	//where the variant configuration for your gametype will be passed (it
	//will already have been checked for legality and had all configure
	//defaults set), although you can also retrieve that at any time via
	//game.Variant(). This is a good place to configure state that will be
	//necessary for you to make the right decisions in
	//DistributeComponentToStarterStack, or to transcribe config information
	//you were passed into properties on your gameState as appropriate. If
	//error is non-nil, Game setup will be aborted, with the reasoning
	//including the error message provided.
	BeginSetUp(state State, variant Variant) error

	//FinishSetUp is called during NewGame, *after* components have been
	//distributed to their StarterStack. This is the last chance to modify the
	//state before the game's initial state is considered final. For example,
	//if you have a card game this is where you'd make sure the starter draw
	//stacks are shuffled. If your game has multiple rounds, or if you don't
	//want the game to start with it already set-up (e.g. you want to show
	//animations of starter cards being dealt) then it's probably best to do
	//most of the logic in a SetUp phase. See the README for more. If error is
	//non-nil, Game setup will be aborted, with the reasoning including the
	//error message provided.
	FinishSetUp(state State) error

	//CheckGameFinished should return true if the game is finished, and who
	//the winners are. Called after every move is applied.
	CheckGameFinished(state ImmutableState) (finished bool, winners []PlayerIndex)

	//ProposeFixUpMove is called after a move has been applied. It may return
	//a FixUp move, which will be applied before any other moves are applied.
	//If it returns nil, we may take the next move off of the queue. FixUp
	//moves are useful for things like shuffling a discard deck back into a
	//draw deck, or other moves that are necessary to get the GameState back
	//into reasonable shape. base.GameDelegate's defintion is almost always
	//suficient.
	ProposeFixUpMove(state ImmutableState) Move

	//DefaultNumPlayers returns the number of users that new games of this
	//type default to. For example, for tictactoe, it will be 2. If 0 is
	//provided to manager.NewGame(), we wil use this value instead.
	DefaultNumPlayers() int

	//Min/MaxNumPlayers should return the min and max number of players,
	//respectively. The engine doesn't use this directly, instead looking at
	//LegalNumPlayers. Typically your LegalNumPlayers will check the given
	//number of players is between these two extremes.
	MinNumPlayers() int
	MaxNumPlayers() int

	//LegalNumPlayers will be consulted when a new game is created. It should
	//return true if the given number of players is legal, and false
	//otherwise. If this returns false, the NewGame will fail with an error.
	//Game creation will automatically reject a numPlayers that does not
	//result in at least one player existing. Generally this is simply
	//checking to make sure the number of players is between Min and Max
	//(inclusive), although some games could only allow, for example, even
	//numbers of players.
	LegalNumPlayers(numPlayers int) bool

	//PlayerMayBeActive should return whether the given PlayerIndex may be
	//"active". In general, this should just return true all of the time,
	//because any player index that is between 0 and NumPlayers is valid. But
	//there are certain times when a given player actually isn't valid. For
	//example, a notional player "seat" might not be filled by a real player
	//currently. This is primarily used for things like PlayerIndex.Next() and
	//Valid(). This is a place for things like behaviors.InactivePlayer to hook
	//different behavior into the core engine.
	PlayerMayBeActive(player ImmutableSubState) bool

	//Variants returns a VariantConfig, which describes the different
	//categories of configuration values and the legal values they may take on
	//when a new game is created. In general if you want to inspect legal
	//variants in your own game logic you shouldn't call this, but instead
	//call gameManager.Variants() which will ensure your VariantConfig is
	//initalized and memoize the return result.
	Variants() VariantConfig

	//CurrentPlayerIndex returns the index of the "current" player for the
	//given game state--a notion that is game specific (and sometimes
	//inapplicable). If CurrentPlayer doesn't make sense (perhaps the game
	//never has a notion of current player, or the type of round that we're in
	//has no current player), this should return ObserverPlayerIndex. The
	//result of this method is used to power state.CurrentPlayer.
	CurrentPlayerIndex(state ImmutableState) PlayerIndex

	//CurrentPhase returns the phase that the game state is currently in.
	//Phase is a formalized convention used in moves.Default to make it easier
	//to write fix-up moves that only apply in certain phases, like SetUp. The
	//return result is primarily used in moves.Default to check whether it is
	//one of the phases in a give Move's LegalPhases. See moves.Default for
	//more information. The only use of this method in the main library is
	//when generating a MoveStorageRecord.
	CurrentPhase(state ImmutableState) int

	//PhaseEnum returns the enum for game phases (the return values of
	//CurrentPhase are expected to be valid enums within that enum). If this
	//returns a non-nil enums.TreeEnum, then the state will not be able to be
	//saved if CurrentPhase() returns a value that is not a leaf-node. The
	//core package doesn't rely on this method directly.
	PhaseEnum() enum.Enum

	//GroupEnum should return the enum to use for group membership in
	//SanitizationPolicy. This enum's string values will be legal keys to
	//be passed to delegate.SanitizationPolicy in addition to the built-in
	//values.
	GroupEnum() enum.Enum

	//GroupMembership should return the groups this playerState is part of
	//(where the ints are valid values from GroupEnum()). This information will
	//be passed into SanitizationPolicy after being transformed to have string
	//keys, and extended with 'all', and any built ins like self or other, and
	//ComputedPlayerGroupMembership . A nil return value is legal.
	GroupMembership(playerState ImmutableSubState) map[int]bool

	//ComputedPlayerGroupMembership is an opportunity for your game's
	//sanitization logic to handle more complex group membership that is tied to
	//how the player state in question compares to the playerState related to
	//the player the state is being sanitized for. For example,
	//base.GameDelegate does lots of special behavior e.g. 'same-ENUMNAME' via
	//overriding this method. playerMembership and viewingAsPlayerMembership
	//will be the return values of delegate.GroupMembership for the different
	//player states. Note that viewingAsPlayerMembership might be a zero-entry
	//map if the viewingAsPlayer is ObserverPlayerIndex. Your method should
	//return an error if the groupName is not one it knows how to process. This
	//is only applied on players, and not other types of subStates currently.
	ComputedPlayerGroupMembership(groupName string, playerMembership, viewingAsPlayerMembership map[int]bool) (bool, error)

	//SanitizationPolicy is consulted when sanitizing states. It is called for
	//each prop in the state, including the set of groups that this player is a
	//mamber of. In practice the default behavior of base.GameDelegate, which
	//uses struct tags to figure out the policy, is sufficient and you do not
	//need to override this. For more on how sanitization works, see the
	//documenation for Policy. The statePropetyRef passed will never be
	//StateGroupComponentValues, and will always have the Index properties set
	//to 0, but remember that the returned Policy will be applied to all
	//Indexes. The string keys will be the string values of GroupEnum()'s keys,
	//as well as always including 'all' and potentially also 'self' and 'other',
	//and any other keys that were provided that didn't error for
	//delegate.ComputedPlayerGroupMembership(). See the documentation of
	//StructInflater.PropertySanitizationPolicy for more about the special
	//values of 'all', 'other', and 'self'.
	SanitizationPolicy(prop StatePropertyRef, groupMembership map[string]bool) Policy

	//If you have computed properties that you want to be included in your
	//JSON (for example, for use clientside), export them here by creating a
	//dictionary with their values.
	ComputedGlobalProperties(state ImmutableState) PropertyCollection
	ComputedPlayerProperties(player ImmutableSubState) PropertyCollection

	//Diagram should return a basic debug rendering of state in multi-line
	//ascii art. Useful for debugging. State.Diagram() will reach out to this
	//method.
	Diagram(s ImmutableState) string

	//SetManager configures which manager this delegate is in use with. A
	//given delegate can only be used by a single manager at a time.
	SetManager(manager *GameManager)

	//Manager returns the Manager that was set on this delegate.
	Manager() *GameManager
}

type GameManager struct {
	// contains filtered or unexported fields
}

type GameStorageRecord struct {
	//Name is the type of the game, from its manager. Used for sanity
	//checking.
	Name string
	ID   string
	//SecretSalt for this game for things like component Ids. Should never be
	//transmitted to an insecure or untrusted environment; the only way to
	//access it outside this package is via this field, because it must be
	//able to be persisted to and read from storage.
	SecretSalt string `json:",omitempty"`
	Version    int
	Winners    []PlayerIndex
	Finished   bool
	Created    time.Time
	//Modified is updated every time a new move is applied.
	Modified time.Time
	//NumPlayers is the reported number of players when it was created.
	//Primarily for convenience to storage layer so they know how many players
	//are in the game.
	NumPlayers int
	Agents     []string
	Variant    Variant
}

type ImmutableBoard interface {
	ImmutableSpaces() []ImmutableStack
	ImmutableSpaceAt(index int) ImmutableStack
	Len() int
	// contains filtered or unexported methods
}

type ImmutableComponentInstance interface {
	//ImmutableComponentInstances have all of the information of a base Component, as
	//often that's the information you most need.
	Component

	//ID returns a semi-stable ID for this component within this game and the
	//current state this component instance is associated with. Within this
	//game, it will only change when the shuffleCount for this component
	//changes (that is, when the component is in a stack that is Shuffle()'d
	//or when the ComponentInstance is in a stach that has a component moved
	//to it via SecretMoveTo). Across games the Id for the "same" component
	//will be different, in a way that cannot be guessed without access to
	//game.SecretSalt. Typically your game logic can ignore IDs and not use
	//them; they're provided to enable certain scenarios and animations in the
	//core engine and other packages. See the documentation for Policy for
	//more on IDs and why they exist.
	ID() string

	//ImmutableDynamicValues returns the Dynamic Values for this component in the state
	//this instance is associated with. A convenience so you don't have to go
	//find them within the state.DynamicComponentValues yourself.
	ImmutableDynamicValues() ImmutableSubState

	//ContainingImmutableStack will return the stack and slot index for the
	//associated component, if that location is not sanitized, and the
	//componentinstance is legal for the state it's in. If no error is
	//returned, stack.ComponentAt(slotIndex) == c will evaluate to true.
	ContainingImmutableStack() (stack ImmutableStack, slotIndex int, err error)

	//ImmutableState returns the State object that this ComponentInstance is affiliated
	//with.
	ImmutableState() ImmutableState
	// contains filtered or unexported methods
}

type ImmutableSizedStack interface {
	//An ImmutableSizedStack can be used everywhere a normal ImmutableStack
	//can. Note the behavior of an ImmutableSizedStack's base ImmutableStack
	//methods will often be different than a default stack.
	ImmutableStack

	//FirstComponentIndex returns the index of the first non-nil component
	//from the left.
	FirstComponentIndex() int
	//LastComponentIndex returns the index of the first non-nil component from
	//the right.
	LastComponentIndex() int
}

type ImmutableStack interface {

	//Deck returns the Deck associated with this stack.
	Deck() *Deck

	//Len returns the number of slots in the Stack. For a normal Stack this is
	//the number of items in the stack. For SizedStacks, this is the number of
	//slots--even if some are unfilled.
	Len() int

	//NumComponents returns the number of components that are in this stack.
	//For default Stacks this is the same as Len(); for SizedStacks, this is
	//the number of non-nil slots.
	NumComponents() int

	//SlotsRemaining returns how many slots there are left in this stack to
	//add items. For default stacks this will be the number of slots until
	//maxSize is reached (or MaxInt64 if there is no maxSize). For SizedStacks
	//this will be the number of empty slots.
	SlotsRemaining() int

	//MaxSize returns the Maxium Size, if set, for default stacks. For sized
	//stacks it will return the number of total current slots (filled and
	//unfilled), which is equivalent to Len().
	MaxSize() int

	//ImmutableComponentAt retrieves the component at the given index in the
	//stack. See also Stack.ComponentAt.
	ImmutableComponentAt(index int) ImmutableComponentInstance

	//ImmutableComponents returns all of the components. Equivalent to calling
	//ImmutableComponentAt from 0 to Len(). See also Stack.Components().
	ImmutableComponents() []ImmutableComponentInstance

	//ImmutableFirst returns a reference to the first non-nil component from
	//the left, or nil if empty. For default stacks, this is simply a
	//convenience wrapper around stack.ImmutableComponentAt(0). SizedStacks
	//however will use the result of FirstComponentIndex().
	ImmutableFirst() ImmutableComponentInstance

	//ImmutableLast returns a reference to the first non-nil component from
	//the right, or nil if empty. For default stacks, this is simply a
	//convenience wrapper around stack.ComponentAt(stack.Len() - 1).
	//SizedStacks however will use the result of LastComponentIndex().
	ImmutableLast() ImmutableComponentInstance

	//IDs returns a slice of strings representing the IDs of each component at
	//each index. Under normal circumstances this will be the results of
	//calling c.ID() on each component in order. This information will be
	//elided or modified if the state has been sanitized. See documentation
	//for Policy for more on when and how these might be changed.
	IDs() []string

	//LastSeen represents an unordered list of the last version number at
	//which the given ID was seen in this stack. A component is "seen" at
	//three moments: 1) when it is moved to this stack, 2) immediately before
	//its ID is scrambled, and 3) immediately after its ID is scrambled.
	//LastSeen thus represents the last time that we knew for sure it was in
	//this stack --although it may have been in this stack after that, and may
	//no longer be in this stack. This information may be elided if the stack
	//has been sanitized. See the documentation for Policy for more about when
	//this might be elided.
	IDsLastSeen() map[string]int

	//ShuffleCount is the number of times during this game that Shuffle (or
	//PublicShuffle) have been called on this stack. Not visible in some
	//sanitization policies, see Policy for more.
	ShuffleCount() int

	//ImmutableSizedStack will return a version of this stack that implements
	//the ImmutableSizedStack interface, if that's possible, or nil otherwise.
	ImmutableSizedStack() ImmutableSizedStack

	//MergedStack will return a version of this stack that implements the
	//MergedStack interface, if that's possible, or nil otherwise.
	MergedStack() MergedStack

	//ImmutableBoard will return the Board that this Stack is part of, or nil
	//if it is not part of a board.
	ImmutableBoard() ImmutableBoard

	//If Board returns a non-nil Board, this will return the index within the
	//Board that this stack is.
	BoardIndex() int
	// contains filtered or unexported methods
}

type ImmutableState interface {

	//ImmutableGameState is a reference to to the underlying object returned
	//from your GameDelegate.GameStateConstructor(), and can be safely cast
	//back to that underlying struct so you can access its methods directly in
	//a type- checked way. The difference is that the object formally exposed
	//lacks the mutator methods, although when you cast back you'll get access
	//to the full struct--be careful not to mutate things as they will not be
	//persisted. See State.GameState for more.
	ImmutableGameState() ImmutableSubState
	//Each PlayerState is a reference to to the underlying object returned
	//from your GameDelegate.PlayerStateConstructor(), and can be safely cast
	//back to that underlying struct so you can access its methods directly in
	//a type- checked way. The difference is that the object formally exposed
	//lacks the mutator methods, although when you cast back you'll get access
	//to the full struct--be careful not to mutate things as they will not be
	//persisted. See State.PlayerStates for more.
	ImmutablePlayerStates() []ImmutableSubState
	//Each SubState is a reference to to the underlying object returned from
	//your GameDelegate.DynamicComponentValuesConstructor() for the deck with
	//that name, and can be safely cast back to that underlying struct so you
	//can access its methods directly in a type- checked way. The difference
	//is that the object formally exposed lacks the mutator methods, although
	//when you cast back you'll get access to the full struct--be careful not
	//to mutate things as they will not be persisted. DynamicComponentValues
	//returns a map of deck name to array of component values, one per
	//component in that deck. See State.DynamicComponentValues for more.
	ImmutableDynamicComponentValues() map[string][]ImmutableSubState

	//ImmutableCurrentPlayer returns the ImmutablePlayerState corresponding to
	//the result of delegate.CurrentPlayerIndex(), or nil if the index isn't
	//valid. This object is the same underlying struct that you returned from
	//GameDelegate.PlayerStateConstructor and can be cast back safely to
	//access the underlying methods. See State.CurrentPlayer for more.
	ImmutableCurrentPlayer() ImmutableSubState
	//CurrentPlayerIndex is a simple convenience wrapper around
	//delegate.CurrentPlayerIndex(state) for this state.
	CurrentPlayerIndex() PlayerIndex

	//Version returns the version number the state is (or will be once
	//committed).
	Version() int

	//Copy returns a deep copy of the State, including copied version of the
	//Game and Player States. Note that copying uses the
	//ProperyReadSetConfigurer interface, so any properties not enumerated
	//there or otherwise defined in the constructors on your GameDelegate will
	//not be copied.
	Copy(sanitized bool) (ImmutableState, error)

	//Diagram returns a basic, ascii rendering of the state for debug rendering.
	//It thunks out to Delegate.Diagram.
	Diagram() string

	//Santizied will return false if this is a full-fidelity State object, or
	//true if it has been sanitized, which means that some properties might be
	//hidden or otherwise altered. This should return true if the object was
	//created with Copy(true)
	Sanitized() bool

	//SanitizedForPlayer produces a copy state object that has been sanitized
	//for the player at the given index. The state object returned will have
	//Sanitized() return true. Will call GameDelegate.SanitizationPolicy to
	//construct the effective policy to apply. See the documentation for
	//Policy for more on sanitization.
	SanitizedForPlayer(player PlayerIndex) (ImmutableState, error)

	//Game is the Game that this state is part of. Calling
	//Game.State(state.Version()) should return a state equivalent to this State
	//(modulo sanitization, if applied). This almost always returns non-nil,
	//except if you generated the state via GameManager.ExampleState.
	Game() *Game

	//Manager returns the GameManager associated with this state, and never
	//returns nil. Typically you can fetch this via Game().Manager(), but in
	//some cases, like when the State is generated from
	//GameManager.ExampleState(), Game() will return nil.
	Manager() *GameManager

	//StorageRecord returns a StateStorageRecord representing the state.
	StorageRecord() StateStorageRecord
	// contains filtered or unexported methods
}

type ImmutableStateGetter interface {
	//ImmutableState() returns the state that was set via SetState(), but as an
	//ImmutableState so it has a subset of functionality directly visible.
	ImmutableState() ImmutableState

	//StatePropertyRef should return the value that was set via
	//SetStatePropetyRef. This is a good way for the substate to understand what
	//index it has, for example the player index.
	StatePropertyRef() StatePropertyRef
}

type ImmutableSubState interface {
	ContainingStateConnector
	ImmutableStateGetter
	Reader
}

type ImmutableTimer interface {
	//Active returns true if the given timer has been Start()'d and has not
	//yet fired or been canceled.
	Active() bool
	//TimerLeft reutrns the amount of time until the timer fires, if it is
	//active.
	TimeLeft() time.Duration
	// contains filtered or unexported methods
}

type ManagerInternals struct {
	// contains filtered or unexported fields
}

type MergedStack interface {
	//A MergedStack can be used anywhere an ImmutableStack can be.
	ImmutableStack

	//Valid will return a non-nil error if the stack isn't valid currently
	//for example if the two stacks being merged are different sizes for an
	//overlapped stack. Valid is checked just before state is saved. If any
	//stack returns any non-nil for this then the state will not be saved.
	Valid() error

	//ImmutableStacks returns the stacks that this MergedStack is based on.1
	ImmutableStacks() []ImmutableStack

	//Overlapped will return true if the MergedStack is an overlapped stack
	//(in contrast to a concatenated stack).
	Overlapped() bool
}

type Move interface {

	//Legal returns nil if this proposed move is legal at the given state, or
	//an error if the move is not legal. The error message may be shown
	//directly to the end- user so be sure to make it user friendly. proposer
	//is set to the notional player that is proposing the move. proposer might
	//be a valid player index, or AdminPlayerIndex (for example, if it is a
	//FixUpMove it will typically be AdminPlayerIndex). AdminPlayerIndex is
	//always allowed to make any move. It will never be ObserverPlayerIndex,
	//because by definition Observers may not make moves. If you want to check
	//that the person proposing is able to apply the move for the given
	//player, and that it is their turn, you would do something like test
	//m.TargetPlayerIndex.Equivalent(proposer),
	//m.TargetPlayerIndex.Equivalent(game.CurrentPlayer). Legal is one of the
	//most key parts of logic for your game type. It is important for fix up
	//moves in particular to have carefully-designed Legal() methods, as the
	//ProposeFixUpMove on base.GameDelegate (which you almost always use)
	//walks through each move and returns the first one that is legal at this
	//game state--so if one of your moves is erroneously legal more often than
	//it should be it could be mistakenly applied, perhaps in an infinite
	//loop!
	Legal(state ImmutableState, proposer PlayerIndex) error

	//Apply applies the move to the state by modifying hte right properties.
	//It is handed a copy of the state to modify. If error is non-nil it will
	//not be applied to the game. It should not be called directly; use
	//Game.ProposeMove. Legal() will have been called before and returned nil.
	//Apply is the only place (outside of some of the Game initalization logic
	//on GameDelegate) where you are allowed to modify the state direclty and
	//are passed a State, not an ImmutableState.
	Apply(state State) error

	//Sets the move to have reasonable defaults for the given state.For
	//example, if the Move has a TargetPlayerIndex property, a reasonable
	//default is state.CurrentPlayer(). DefaultsForState is used to set
	//reasonable defaults for fix up moves. Typically you can skip this.
	DefaultsForState(state ImmutableState)

	//HelpText is a human-readable sentence describing what the move does in
	//general. HelpText should be the same for all moves of the same type, and
	//should not vary with the Move's specific properties. For example, the
	//HelpText for "Place Token" might be "Places the current user's token in
	//the specified slot on the board." Primarily useful just to show to a
	//user in an interface.
	HelpText() string

	//Info returns the MoveInfo object that was affiliated with this object by
	//SetInfo. It includes information about when the move was applied, the
	//name of the move, and other information.
	Info() *MoveInfo

	//SetInfo will be called after the constructor is called to set the
	//information, including what type the move is.
	SetInfo(m *MoveInfo)

	//TopLevelStruct should return the value that was set via
	//SetTopLevelStruct. It returns the Move that is at the top of the
	//embedding chain (because structs that are embedded anonymously can only
	//access themselves and not their embedders). This is useful because in a
	//number of cases embedded moves (for example moves in the moves package)
	//need to consult a method on their embedder to see if any of their
	//behavior should be overridden.
	TopLevelStruct() Move

	//SetTopLevelStruct is called right after the move is constructed, with
	//the top-level struct. This should be returned from TopLevelStruct.
	SetTopLevelStruct(m Move)

	//Moves alos have a ValidConfiguration, because moves, especially
	//sub-classes of the moves package, require set-up that can only be verified
	//at run time (for example, verifying that the embedder implements a certain
	//inteface)
	ConfigurationValidator

	//Moves, like ConfigurableSubStates, must only have all of their
	//important, persistable properties available to be inspected and modified
	//via a PropertyReadSetConfigurer. The game engine will use that interface
	//to create new moves, inflate old moves from storage, and copy moves.
	//Typically you generate this automatically for your moves with `boargame-
	//util codegen`.
	ReadSetConfigurer
}

type MoveConfig interface {
	//Name is the name for this type of move. No other Move structs
	//in use in this game should have the same name, but it should be human-
	//friendly. For example, "Place Token" is a reasonable name, as long as no
	//other types of Move-structs will return that name in this game. Required.
	Name() string

	//Constructor should return a zero-valued Move of the given type. Normally
	//very simple: just a new(MyMoveType). Required. The moves you create may
	//not have an fields of Stack, Board, or Timer type, but may have enum.Val
	//type. Those fields must be non-nil; like delegate.GameStateConstructor
	//and others, a StructInflater will be created for each move type, which
	//allows you to provide inflation configuration via struct tags. See
	//StructInflater for more. Like ConfigurableSubState, all of the
	//properties to persist must be accessible via their ReadSetConfigurer, as
	//that is how the core engine serializes them, re-inflates them from
	//storage, and copies them.
	Constructor() func() Move

	//CustomConfiguration is an optional PropertyCollection. Some move types--
	//especially in the `moves` package--stash configuration options here that
	//will change how all moves of this type behave. Individual moves would
	//reach through via Info().CustomConfiguration() to retrieve the
	//values stored there. Different move types will store different types of
	//information there--to avoid a collision the convention is to use a
	//string name that starts with your fully qualified package name, then a
	//dot, then the propertyname, like so:
	//"github.com/jkomoros/boardgame/moves.MoveName". Those strings are often
	//encoded as package-private constants, and a
	//interfaces.CustomConfigurationOption functor factory is provided to set
	//those from outside the package. Generally you don't use this directly,
	//but moves.AutoConfigurer will help you set these for what specific
	//moves in that package expect.
	CustomConfiguration() PropertyCollection
}

type MoveInfo struct {
	// contains filtered or unexported fields
}

type MoveStorageRecord struct {
	Name      string
	Version   int
	Initiator int
	//The Phase as returned by Delegate.CurrentPhase() for the state the move
	//was in before it was applied. This is captured in this field because
	//moves in the moves package need to quickly inspect this value without
	//fully inflating the move structs.
	Phase int
	//The player index of the proposer of the move.
	Proposer  PlayerIndex
	Timestamp time.Time
	//The actual JSON serialized blob representing the properties of the move.
	Blob json.RawMessage
}

type PlayerIndex int

type Policy int

type PropertyCollection map[string]interface{}

type PropertyReadSetConfigurer interface {

	//PropertyReadSetConfigurer adds configuration methods to
	//PropertyReadSetter.
	PropertyReadSetter

	//Configure*Prop allows you to set the named property to the given
	//container value. Use this if PropMutable(name) returns true.
	ConfigureEnumProp(name string, value enum.Val) error
	ConfigureStackProp(name string, value Stack) error
	ConfigureBoardProp(name string, value Board) error
	ConfigureTimerProp(name string, value Timer) error

	//ConfigureImmutable*Prop allows you to set the container for container values for
	//whom MutableProp(name) returns false.
	ConfigureImmutableEnumProp(name string, value enum.ImmutableVal) error
	ConfigureImmutableStackProp(name string, value ImmutableStack) error
	ConfigureImmutableBoardProp(name string, value ImmutableBoard) error
	ConfigureImmutableTimerProp(name string, value ImmutableTimer) error

	//ConfigureProp is like SetProp, except that it does not fail if the type
	//is one of the Interface types. If you know the underlying type it's always better
	//to use the typed accessors.
	ConfigureProp(name string, value interface{}) error
}

type PropertyReadSetter interface {
	//All PropertyReadSetters have read interfaces
	PropertyReader

	//SetTYPEProp sets the given property name to the given type.
	SetIntProp(name string, value int) error
	SetBoolProp(name string, value bool) error
	SetStringProp(name string, value string) error
	SetPlayerIndexProp(name string, value PlayerIndex) error
	SetIntSliceProp(name string, value []int) error
	SetBoolSliceProp(name string, value []bool) error
	SetStringSliceProp(name string, value []string) error
	SetPlayerIndexSliceProp(name string, value []PlayerIndex) error

	//PropMutable will return whether the given property is backed by an
	//underlying mutable object or not. For non-interface types this should
	//always be true, because Set*Prop always exists. For interface types,
	//this will be true if the underlying property is stored as the non-
	//Immutable variant, false otherwise.
	PropMutable(name string) bool

	//For interface types the setter also wants to give access to the mutable
	//underlying value so it can be mutated in place. ReadSetters should
	//return ErrPropertyImmutable if the underlying interface property is the
	//immutable variant (that is, PropMutable returns false for that prop
	//name).
	EnumProp(name string) (enum.Val, error)
	StackProp(name string) (Stack, error)
	BoardProp(name string) (Board, error)
	TimerProp(name string) (Timer, error)

	//SetProp sets the property with the given name. If the value does not
	//match the underlying slot type, it should return an error. If the type
	//is one of the interface types, it should fail because those need to be
	//Configured, not Set. If you know the underlying type it's always better
	//to use the typed accessors.
	SetProp(name string, value interface{}) error
}

type PropertyReader interface {
	//Props returns a list of all property names that are defined for this
	//object.
	Props() map[string]PropertyType
	//IntProp fetches the int property with that name, returning an error if
	//that property doese not exist.
	IntProp(name string) (int, error)
	BoolProp(name string) (bool, error)
	StringProp(name string) (string, error)
	IntSliceProp(name string) ([]int, error)
	BoolSliceProp(name string) ([]bool, error)
	StringSliceProp(name string) ([]string, error)
	PlayerIndexSliceProp(name string) ([]PlayerIndex, error)
	PlayerIndexProp(name string) (PlayerIndex, error)

	//The interface types will only return read-only versions of their objects
	//in a Reader context, even if the underlying objects are mutable
	//versions.
	ImmutableEnumProp(name string) (enum.ImmutableVal, error)
	ImmutableStackProp(name string) (ImmutableStack, error)
	ImmutableBoardProp(naem string) (ImmutableBoard, error)
	ImmutableTimerProp(name string) (ImmutableTimer, error)
	//Prop fetches the given property generically. If you already know the
	//type, it's better to use the typed methods.
	Prop(name string) (interface{}, error)
}

type PropertyType int

type ReadSetConfigurer interface {
	ReadSetter
	ReadSetConfigurer() PropertyReadSetConfigurer
}

type ReadSetter interface {
	Reader
	ReadSetter() PropertyReadSetter
}

type Reader interface {
	Reader() PropertyReader
}

type SizedStack interface {
	//SizedStack can be used anywhere a Stack can be.
	Stack

	//FirstComponentIndex returns the index of the first non-nil component
	//from the left.
	FirstComponentIndex() int
	//LastComponentIndex returns the index of the first non-nil component from
	//the right.
	LastComponentIndex() int

	//FirstSlot returns the index of the first empty slot from the left.
	FirstSlot() int

	//NextSlot returns the index of the next valid slot in the slot, which is
	//equivalent to FirstSlot() for sized stacks.
	NextSlot() int

	//LastSlot returns the index of the first empty component slot from the
	//right.
	LastSlot() int
}

type Stack interface {
	//A Stack can be used anywhere an ImmutableStack can be.
	ImmutableStack

	//ComponentAt fetches the ComponentInstance that exists at the given
	//index. For default stacks, this will never be nil as long as the index
	//is between 0 and Stack.Len(). For SizedStacks, however, this might be
	//nil if the given slot is empty. See also ImmutableComponentAt, which has
	//the same behavior but returns an ImmutableComponentInstance.
	ComponentAt(componentIndex int) ComponentInstance

	//Components returns all of the ComponentInstances. Equivalent to calling
	//ComponentAt from 0 to Len().  The index of each ComponentInstance will
	//correspond to the index you could fetch that item at via
	//Stack.ComponentAt. SizedStacks will return a slice that may have nils if
	//that slot is empty. See also Stack.Components().
	Components() []ComponentInstance

	//First returns a reference to the first non-nil component from the left,
	//or nil if empty. For default stacks, ths is simply a convenience for
	//ComponentAt(0). For SizedStacks, this returns the component at
	//SizedStack.FirstComponentIndex. See also ImmutableFirst.
	First() ComponentInstance

	//Last() returns a reference to the first non-nil component from the
	//right, or nil if empty. For defaults stacks, this is simply a
	//convenience for ComponentAt(stack.Len() - 1). For SizedStacks this
	//returns the component at LastComponentIndex(). See also ImmutableLast.
	Last() ComponentInstance

	//MoveAllTo is a convenience method that moves all of the components in
	//this stack to the other stack, by repeatedly calling
	//stack.First().MoveToNextSlot(other). All other Move* methods can be
	//found on ComponentInstance. This will fail if the SlotsRemaining in
	//other Stack are less than the NumComponents of this stack. In pracitce
	//this is rarely moved, because it chunks all of the component moves up
	//into one notional Move, meaning that animations will show all of the
	//components moving at once. Instead, often moves.MoveAllComponents is
	//used to chunk up the move into a series of distinct Moves.
	MoveAllTo(other Stack) error

	//Shuffle shuffles the order of the stack, so that it has the same items,
	//but in a different order. In a SizedStack, the empty slots will move
	//around as part of a shuffle. Shuffling will scramble all of the ids in
	//the stack, such that the Ids of all items in the stack change. See the
	//documenation for Policy for more on Id scrambling. Shuffle uses
	//state.Rand() as a source of randomness, allowing it to be deterministic
	//if other things also use state.Rand().
	Shuffle() error

	//PublicShuffle is the same as Shuffle, but the Ids are not scrambled
	//after the shuffle. PublicShuffle makes sense in cases where only a small
	//number of cards are shuffled and a preternaturally savvy observer should
	//be able to keep track of them. The normal Shuffle() is almost always
	//what you want. PublicShuffle uses state.Rand() as a source of
	//randomness, allowing it to be deterministic if other things also use
	//state.Rand().
	PublicShuffle() error

	//SwapComponents swaps the position of two components within this stack
	//without changing the size of the stack (in SizedStacks, it is legal to
	//swap empty slots). i,j must be between [0, stack.Len()). This is like a
	//ComponentInstance.MoveTo, except within the same stack.
	SwapComponents(i, j int) error

	//SortComponents sorts the stack's components in the order implied by less
	//by repeatedly calling SwapComponents. Errors if any SwapComponents
	//errors. If error is non-nil, the stack may be left in an arbitrary order.
	SortComponents(less func(i, j ImmutableComponentInstance) bool) error

	//Resizable returns true if calls to any of the methods that change the
	//Size of the stack are legal to call in general. Currently only stacks
	//within a Board return Resizable false. If this returns false, any of
	//those size mutating methods will fail with an error.
	Resizable() bool

	//ContractSize changes the size of the stack. For default stacks it
	//contracts the MaxSize, if non-zero. For SizedStack it will reduce the
	//size by removing the given number of slots, starting from the right.
	//This method will fail if there are more components in the stack
	//currently than would fit in newSize.
	ContractSize(newSize int) error

	//ExpandSize changes the size of the stack. For default stacks it
	//increases MaxSize (unless it is zero). For SizedStack it does it by
	//adding the given number of newSlots to the end.
	ExpandSize(newSlots int) error

	//SetSize is a convenience method that will call ContractSize or
	//ExpandSize depending on the current Len() and the target len. Calling
	//SetSize on a stack that is already that size is a no-op. For default
	//stacks, this is the only sway to switch from a zero MaxSize (no limit)
	//to a non-zero MaxSize().
	SetSize(newSize int) error

	//SizeToFit is a simple convenience wrapper around ContractSize. It
	//automatically sizes the stack down so that there are no empty slots.
	SizeToFit() error

	//Board will return a mutable reference to the Board we're part of,
	//if we're part of a board.
	Board() Board

	//SizedStack will return a version of this stack that implements
	//the MutableSizedStack interface, if that's possible, or nil otherwise.
	SizedStack() SizedStack
	// contains filtered or unexported methods
}

type State interface {
	//State contains all of the methods of a read-only state.
	ImmutableState
	//GameState is a reference to to the underlying object returned from your
	//GameDelegate.GameStateConstructor(), and can be safely cast back to that
	//underlying struct so you can access its methods directly in a type-
	//checked way.
	GameState() SubState
	//Each PlayerState is a reference to to the underlying object returned
	//from your GameDelegate.PlayerStateConstructor(), and can be safely cast
	//back to that underlying struct so you can access its methods directly in
	//a type- checked way.
	PlayerStates() []SubState
	//Each SubState is a reference to to the underlying object returned from
	//your GameDelegate.DynamicComponentValuesConstructor() for the deck with
	//that name, and can be safely cast back to that underlying struct so you
	//can access its methods directly in a type- checked way.
	DynamicComponentValues() map[string][]SubState

	//CurrentPlayer returns the PlayerState corresponding to the result of
	//delegate.CurrentPlayerIndex(), or nil if the index isn't valid. This
	//object is the same underlying struct that you returned from
	//GameDelegate.PlayerStateConstructor and can be cast back safely to
	//access the underlying methods.
	CurrentPlayer() SubState

	//Rand returns a source of randomness. All game logic should use this rand
	//source. It is deterministically seeded when it is created for this state
	//based on the game's ID, the game's secret salt, and the version number
	//of the state. Repeated calls to Rand() on the same state will return the
	//same random generator. If games use this source for all of their
	//randomness it allows the game to be played back detrministically, which
	//is useful in some testing scenarios. Rand is only available on State,
	//not ImmutableState, because all methods that aren't mutators in your
	//game logic should be deterministic.
	Rand() *rand.Rand
	// contains filtered or unexported methods
}

type StateGetter interface {
	ImmutableStateGetter
	//State should return the state that was set via SetState.
	State() State
}

type StateGroupType int

type StatePropertyRef struct {
	//Group is which of Game, Player, or DynamicComponentValues this is a
	//reference to.
	Group StateGroupType
	//PropName is the specific property on the given SubStateObject specified
	//by the rest of the StatePropertyRef.
	PropName string
	//DeckName is only used when Group is StateGroupComponentValues or
	//StateGroupDynamicComponentValues
	DeckName string

	//PlayerIndex is the index of the player, if Group is StateGroupPlayer and
	//the intent of the StatePropertyRef is to select a specific player's state.
	//0 is always legal. Note that AdminPlayerIndex and ObserverPlayerIndex are
	//never valid.
	PlayerIndex PlayerIndex
	//DeckIndex is used only when the Group is StateGroupComponentValues or
	//StateGroupDynamicComponentValues and the intent of the StatePropertyRef is
	//to select a specific ComponentValues or DynamicComponentValues. 0 is
	//always legal.
	DeckIndex int
}

type StateStorageRecord json.RawMessage

type StorageManager interface {
	//State returns the StateStorageRecord for the game at the given version,
	//or nil.
	State(gameID string, version int) (StateStorageRecord, error)

	//Move returns the MoveStorageRecord for the game at the given version, or
	//nil.
	Move(gameID string, version int) (*MoveStorageRecord, error)

	//Moves is like Move but returns all moves from fromVersion (exclusive) to
	//toVersion (inclusive). If fromVersion == toVersion, should return
	//toVersion. In many storage subsystems this is cheaper than repeated
	//calls to Move, which is why it's broken out separately.
	Moves(gameID string, fromVersion, toVersion int) ([]*MoveStorageRecord, error)

	//Game fetches the GameStorageRecord with the given ID from the store, if
	//it exists.
	Game(id string) (*GameStorageRecord, error)

	//AgentState retrieves the most recent state for the given agent
	AgentState(gameID string, player PlayerIndex) ([]byte, error)

	//SaveGameAndCurrentState stores the game and the current state (at
	//game.Version()) into the store at the same time in a transaction. Move
	//is normally provided but will be be nil if game.Version() is 0, denoting
	//the initial state for a game.
	SaveGameAndCurrentState(game *GameStorageRecord, state StateStorageRecord, move *MoveStorageRecord) error

	//SaveAgentState saves the agent state for the given player
	SaveAgentState(gameID string, player PlayerIndex, state []byte) error

	//PlayerMoveApplied is called after a PlayerMove and all of its resulting
	//FixUp moves have been applied. Most StorageManagers don't need to do
	//anything here; it's primarily useful as a callback to signal that a run
	//of moves has been applied, e.g. in the server.
	PlayerMoveApplied(game *GameStorageRecord) error

	//FetchInjectedDataForGame is an override point for other layers to inject
	//triggers for bits of game logic to call into. dataType should be the name
	//of the package that publishes the data type, to avoid collissions (for
	//example, 'github.com/jkomoros/boardgame/server/api.PlayerToSeat'). Things,
	//like server, will override this method to add new data types. Base storage
	//managers need only return nil in all cases.
	FetchInjectedDataForGame(gameID string, dataType string) interface{}
}

type StructInflater struct {
	// contains filtered or unexported fields
}

type SubState interface {
	ContainingStateConnector
	StateGetter
	ReadSetter
}

type Timer interface {
	ImmutableTimer
	//Start begins a timer that will automatically call game.ProposeMove(Move,
	//AdminPlayerIndex) after the given duration has elapsed. Generally called
	//from within a move.Apply() method.
	Start(time.Duration, Move)
	//Cancel cancels a previously Start()'d timer, so that it will no longer
	//fire. If the timer was not active, it's a no-op. The return value is
	//whether the timer was active before being canceled. Generally called
	//during a move.Apply() method.
	Cancel() bool
	// contains filtered or unexported methods
}

type Variant map[string]string

type VariantConfig map[string]*VariantKey

type VariantDisplayInfo struct {
	//The string to actually display to the user
	DisplayName string
	//An optional description to be shown to the user to describe what the
	//setting does.
	Description string
	//The string that is actually used in the game engine. Name can often be
	//skipped because it is often set implicitly during initialization of the
	//containing object.
	Name string
}

type VariantKey struct {
	//VariantKey has a DisplayInfo embedded in it the defines the display name
	//and description for this configuration key.
	VariantDisplayInfo
	//The name of the value, in Values, that is default if none provided. Must
	//exist in the Values map or Valid() will error.
	Default string
	//The specific values this key may take, along with their display
	//information. For example, "blue", "red".
	Values map[string]*VariantDisplayInfo
}