State

All Superinterfaces:

Copyable

All Known Implementing Classes:

C4State, IngeniousState, TicTacToeState
```
public interface State
extends Copyable
```
Represents the game state of a given game. A state is responsible for tracking whose turn it is, what actions have been taken, and if anybody has won. A good state will strive to implement the methods in its interface as efficiently as possible, particularly ones like perform() and getWinner(), since they will likely be called extremely frequently. States should usually have only one public constructor: a zero-argument one which performs no work and null-initializes the state.

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`State.ActionIterator` An iterator over the actions available from a state in an undefined order.
`static class`	`State.ActionIteratorFromIterable` Adapter class to convert an Iterable into an ActionIterator.

Method Summary

Methods
Modifier and Type	Method and Description
`java.lang.String`	`actionToString(long action)`
`State`	`copy()`
`State.ActionIterator`	`getActionIterator()` Gets an action iterator for this state.
`int`	`getCurrentPlayer()`
`long`	`getRandomAction()`
`int`	`getWinner()`
`State`	`initializeFrom(Copyable state)` Initialize this state from the information in the provided object.
`boolean`	`isTerminal()`
`long`	`perform(long action)` Performs the provided action by mutating the state.
`int`	`playerAfter(int player)`
`int`	`playerBefore(int player)`
`State`	`setToStartingConditions()` Put this state in the starting condition for the game, the state before any actions have been taken.
`void`	`undo(long action, long undoToken)` Undoes the provided action by mutating the state back to the way that it was.

- Method Detail
  - getActionIterator
```
State.ActionIterator getActionIterator()
```
    Gets an action iterator for this state.
    
    Returns:
    An iterator over the set of all actions which are currently possible from this state. This iterator should be "perform-tolerant", meaning that a user can perform() and then undo() an arbitrary number of actions between calls to State.ActionIterator.nextAction() without breaking the iterator or causing it to lose its place.
  - getRandomAction
```
long getRandomAction()
```
    Returns:
    A random action which is legal from this state.
  - perform
```
long perform(long action)
```
    Performs the provided action by mutating the state. You should assume that the provided action will be a legal one, it is the responsibility of getActionIterator() to return only legal actions.
    
    Parameters:
    action - The action to perform.
    
    Returns:
    An "undo token" which must be passed to undo(long, long) in order to undo this action.
  - undo
```
void undo(long action,
        long undoToken)
```
    Undoes the provided action by mutating the state back to the way that it was. It is the responsibility of callers to only supply the most recently performed action as an argument.
    
    Parameters:
    action - The action to undo.
    undoToken - The undo token returned from undo(long, long) when this action was performed.
  - setToStartingConditions
```
State setToStartingConditions()
```
    Put this state in the starting condition for the game, the state before any actions have been taken.
    
    Returns:
    this
  - copy
```
State copy()
```
    Specified by:
    
    copy in interface Copyable
    
    Returns:
    A complete copy of this state.
  - initializeFrom
```
State initializeFrom(Copyable state)
```
    Initialize this state from the information in the provided object. Typically, this method should make a copy of the provided object and then cast it to a known representation to initialize its fields. In general, this method should handle initialization from another instance of this State as well as initialization from some canonical state object.
    
    Parameters:
    state - The object to initialize this state from.
    
    Returns:
    this.
  - isTerminal
```
boolean isTerminal()
```
    Returns:
    True if there are no more actions possible from this state (the game has ended).
  - getWinner
```
int getWinner()
```
    Returns:
    The Player who won the game in this state. If there is no winner (the game is a draw, not yet over, etc), returns 0.
  - getCurrentPlayer
```
int getCurrentPlayer()
```
    Returns:
    The Player whose turn it is in this state.
  - playerAfter
```
int playerAfter(int player)
```
    Parameters:
    player - A player.
    
    Returns:
    The player who will follow the provided player in the game's turn sequence.
  - playerBefore
```
int playerBefore(int player)
```
    Parameters:
    player - A player.
    
    Returns:
    The player who is before the provided player in the game's turn sequence.
  - actionToString
```
java.lang.String actionToString(long action)
```
    Parameters:
    action - One of this state's actions.
    
    Returns:
    A String representation of this action.

Interface State

Nested Class Summary

Method Summary

Method Detail

getActionIterator

getRandomAction

perform

undo

setToStartingConditions

copy

initializeFrom

isTerminal

getWinner

getCurrentPlayer

playerAfter

playerBefore

actionToString