MancalaNode

java.lang.Object
- GameNode
- - MancalaNode

All Implemented Interfaces:

java.lang.Cloneable

Direct Known Subclasses:

ScoreDiffMancalaNode
```
public abstract class MancalaNode
extends GameNode
```
MancalaNode - a Mancala game node. When using the constructor with fairStateIndex, a FairKalah (fair Mancala) initial game node is created where perfect play leads to a draw.

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`INIT_PIECES_PER_PIT` Initial pieces per pit for standard Mancala play.
`protected static int`	`MAX_SCORE_PIT` Score pit index for maximizing player.
`protected static int`	`MIN_SCORE_PIT` Score pit index for minimizing player.
`protected static int`	`NUM_PIECES`
`protected static int`	`PLAY_PITS` Total number of play pits per player
`protected int[]`	`state` How to interpret the Mancala state variable: Let the mancala pits be notated thus: _ _ _ _ _ _ _ 1 2 3 4 5 6 s s 6 5 4 3 2 1 where 6-1 are the first player's (MAX's) pits, s1 is the first player's (MAX's) scoring pit, _ _ 6-1 are the second player's (MIN's) pits, and _ s is the second player's (MIN's) scoring pit.
`protected static int`	`TOTAL_PITS` Total number of play and score pits.

Fields inherited from class GameNode
MAX, MIN, parent, player, prevMove, UNDEFINED_MOVE

Constructor Summary

Constructors
Constructor and Description
`MancalaNode()` Create a standard Mancala (a.k.a.
`MancalaNode(int fairStateIndex)` Create an initial FairKalah (fair Mancala) state where two perfect players will draw.
`MancalaNode(int[] state)` Initialize Mancala node with given state piece distribution with MAX to play.
`MancalaNode(MancalaNode node)` Mancala copy constructor.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.Object`	`clone()` `clone` - return a deep clone of the MancalaNode.
`java.util.ArrayList<GameNode>`	`expand()` `expand` - return an ArrayList of all possible next game states
`boolean`	`gameOver()` `gameOver` - return true if no pieces left in play pits.
`java.util.ArrayList<java.lang.Integer>`	`getLegalMoves()` Return an `ArrayList` of integers, each designating a legal pit index to play from.
`void`	`makeMove(int move)` Make the designated move, redistributing pieces from the indicated position and updating player accordingly.
`static java.lang.String`	`moveToString(int move)` Translates move integer to a String.
`java.lang.String`	`toString()` String representation of current game state.
`abstract double`	`utility()` Return an estimation of game node utility, unless game is over.

Methods inherited from class GameNode
childClone, getPlayer

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - PLAY_PITS
```
protected static final int PLAY_PITS
```
    Total number of play pits per player
    
    See Also:
    
    Constant Field Values
  - MAX_SCORE_PIT
```
protected static final int MAX_SCORE_PIT
```
    Score pit index for maximizing player.
    
    See Also:
    
    Constant Field Values
  - MIN_SCORE_PIT
```
protected static final int MIN_SCORE_PIT
```
    Score pit index for minimizing player.
    
    See Also:
    
    Constant Field Values
  - TOTAL_PITS
```
protected static final int TOTAL_PITS
```
    Total number of play and score pits.
    
    See Also:
    
    Constant Field Values
  - INIT_PIECES_PER_PIT
```
protected static final int INIT_PIECES_PER_PIT
```
    Initial pieces per pit for standard Mancala play. Pieces are redistributed for FairKalah (fair Mancala) play.
    
    See Also:
    
    Constant Field Values
  - NUM_PIECES
```
protected static final int NUM_PIECES
```
    See Also:
    
    Constant Field Values
  - state
```
protected int[] state
```
```
 
How to interpret the Mancala state variable:

Let the mancala pits be notated thus:

  _ _ _ _ _ _
_ 1 2 3 4 5 6
s             s
  6 5 4 3 2 1

where 
6-1 are the first player's (MAX's) pits,
s1 is the first player's (MAX's) scoring pit,
_ _
6-1 are the second player's (MIN's) pits, and 
_
s is the second player's (MIN's) scoring pit.

The numbers of pieces in each pit are stored in an array as follows:
state[0] ... state[6] store the number of pieces in 6, 5, 4, 3, 2, 1, and s.
                                                     _  _  _  _  _  _      _
state[7] ... state[13] store the number of pieces in 6, 5, 4, 3, 2, 1, and s.

Each player's goal is to end the game with more pieces in one's own
                                                             _
scoring pit.  Thus a simple measure of utility would be (s - s).
```
- Constructor Detail
  - MancalaNode
```
public MancalaNode()
```
    Create a standard Mancala (a.k.a. Kalah) initial state. This state is unfair: In play between two optimal players, the first player will win by 10 points. Irving, Geoffrey; Donkers, Jeroen; Uiterwijk, Jos. (2003). Solving Kalah. ICGA journal. 23. 10.3233/ICG-2000-23303.
  - MancalaNode
```
public MancalaNode(int[] state)
```
    Initialize Mancala node with given state piece distribution with MAX to play. State should contain a total of NUM_PIECES pieces.
    
    Parameters:
    
    state - given state piece distribution.
  - MancalaNode
```
public MancalaNode(int fairStateIndex)
```
    Create an initial FairKalah (fair Mancala) state where two perfect players will draw. Index -1 will return a standard (unfair) Mancala initial board state. Index 0 will return a random FairKalah initial board state. Indices 1-254 will return specific FairKalah initial board states. Indices beyond those bounds will throw an IllegalArgumentException.
    
    Parameters:
    
    fairStateIndex - either a valid state index 1-254 or an implicit request (0) for a random FairKalah initial state, or -1 indicating a standard (unfair) Mancala initial state.
  - MancalaNode
```
public MancalaNode(MancalaNode node)
```
    Mancala copy constructor.
    
    Parameters:
    
    node - other node to copy
- Method Detail
  - clone
```
public java.lang.Object clone()
```
    clone - return a deep clone of the MancalaNode.
    
    Overrides:
    
    clone in class GameNode
    
    Returns:
    
    an Object value - a deep clone of the MancalaNode.
  - gameOver
```
public boolean gameOver()
```
    gameOver - return true if no pieces left in play pits.
    
    Specified by:
    
    gameOver in class GameNode
    
    Returns:
    
    a boolean value
  - expand
```
public java.util.ArrayList<GameNode> expand()
```
    expand - return an ArrayList of all possible next game states
    
    Specified by:
    
    expand in class GameNode
    
    Returns:
    
    an ArrayList of all possible next game states
  - getLegalMoves
```
public java.util.ArrayList<java.lang.Integer> getLegalMoves()
```
    Return an ArrayList of integers, each designating a legal pit index to play from.
    
    Returns:
    
    an ArrayList of integers, each designating a legal pit index to play from
  - makeMove
```
public void makeMove(int move)
```
    Make the designated move, redistributing pieces from the indicated position and updating player accordingly.
    
    Parameters:
    
    move - int value of play pit from which pieces are being moved from.
  - moveToString
```
public static java.lang.String moveToString(int move)
```
    Translates move integer to a String.
    
    Parameters:
    
    move - pit index for current state
    
    Returns:
    
    java.lang.String String representation of pit index for current state
  - toString
```
public java.lang.String toString()
```
    String representation of current game state. Example (initial state):
```
     _  _  _  _  _  _
     1  2  3  4  5  6
-------------------------
|  | 4| 4| 4| 4| 4| 4|  |
| 0|-----------------| 0|
|  | 4| 4| 4| 4| 4| 4|  | <--
-------------------------
     6  5  4  3  2  1
```
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    String representation of current game state
  - utility
```
public abstract double utility()
```
    Return an estimation of game node utility, unless game is over. If game is over, return actual utility. TODO: In your implementation, you must create your own subclass of MancalaNode (e.g. UserIDMancalaNode extends MancalaNode) and implement this utility method (inheriting all others). This can be confusing if you don't know Java well, so see the example provided with ScoreDiffMancalaNode. Example implementation: public double utility() { return state[MAX_SCORE_PIT] - state[MIN_SCORE_PIT]; }
    
    Specified by:
    
    utility in class GameNode
    
    Returns:
    
    double an estimation of game node utility, unless game is over. If game is over, return actual utility.

Class MancalaNode

Field Summary

Fields inherited from class GameNode

Constructor Summary

Method Summary

Methods inherited from class GameNode

Methods inherited from class java.lang.Object

Field Detail

PLAY_PITS

MAX_SCORE_PIT

MIN_SCORE_PIT

TOTAL_PITS

INIT_PIECES_PER_PIT

NUM_PIECES

state

Constructor Detail

MancalaNode

MancalaNode

MancalaNode

MancalaNode

Method Detail

clone

gameOver

expand

getLegalMoves

makeMove

moveToString

toString

utility