/******************************************************************************

  * Board.java - Define a backgammon board 

  * $Id$

  * 

  * BuckoFIBS - Backgammon by BuckoSoft

  * Copyright© 2009,2010 - Dick Balaska - BuckoSoft, Corp.

  * 

  * $Log$

  * Revision 1.16  2013/09/12 06:40:41  dick

  * static xoToTurn().

  *

  * Revision 1.15  2011/07/04 03:36:01  dick

  * Add getCanMove().

  *

  * Revision 1.14  2011/06/19 04:14:31  dick

  * Define turnO and turnX.

  *

  * Revision 1.13  2011/06/13 04:38:42  dick

  * Add parseFibsBoard(s, bool) for debugging boards.

  *

  * Revision 1.12  2011/06/10 05:59:32  dick

  * Add isOpponentMayDouble().

  *

  * Revision 1.11  2011/06/02 19:04:37  dick

  * Add attributes and methods for dealing with a player resigning.

  *

  * Revision 1.10  2011/05/21 20:19:09  dick

  * If setSortDice(true) then sort any existing dice.

  *

  * Revision 1.9  2011/05/21 04:54:40  dick

  * happenings about doubles goes in Board, not Document.

  *

  * Revision 1.8  2011/05/18 05:50:46  dick

  * Javadoc.

  *

  * Revision 1.7  2011/05/17 23:55:25  dick

  * Add the clone() method.

  *

  * Revision 1.6  2011/05/17 23:14:04  dick

  * getDirectionFromName() does that.

  *

  * Revision 1.5  2011/05/16 21:20:43  dick

  * Javadoc.

  *

  * Revision 1.4  2011/05/16 11:35:43  dick

  * getXOFromName determines the direction from an event.

  *

  * Revision 1.3  2011/05/15 18:16:52  dick

  * Javadoc link fix.

  *

  * Revision 1.2  2011/05/14 05:19:46  dick

  * Still need work on the doubles handling for board/document split.

  *

  * Revision 1.1  2011/05/14 04:43:01  dick

  * I needed to deal with some lightweight Boards.

  * So finally make the primary document Document

  * and demote just the Board handling to a domain object.

  *

  * Revision 1.10  2011/05/13 18:23:25  dick

  * Commentality.

  *

  * Revision 1.9  2011/05/13 14:18:15  dick

  * Define constants Home=0 and Bar=25.

  *

  * Revision 1.8  2011/05/10 20:34:22  dick

  * Javadoc.

  *

  * Revision 1.7  2011/01/01 06:10:25  dick

  * Javadoc.

  *

  * Revision 1.6  2010/12/29 07:42:24  dick

  * Sorting dice is optional.

  *

  * Revision 1.5  2010/12/24 06:12:07  dick

  * Handle the onMatchOver message correctly.

  *

  * Revision 1.4  2010/03/03 13:12:22  inim

  * Replaced (c) sign in comment mangled by CVS default encoding back to UTF-8

  *

  * Revision 1.3  2010/03/03 12:19:49  inim

  * Moved source to UTF8 encoding from CP1252 encoding. To this end all source files' (c) message was updated to "Copyright© 2009,2010 - Dick Balaska - BuckoSoft, Corp.". This replaces the (c) sign to UTF8, and adds the new year 2010.

  *

  * Revision 1.2  2010/02/08 09:12:35  dick

  * isRace() determines if a game is race mode.

  *

  * Revision 1.1  2010/02/04 05:57:53  inim

  * Mavenized project folder layout

  *

  * Revision 1.35  2010/01/23 06:13:06  dick

  * removeSavedMatch() removes a match from the saved (unfinished) matches list.

  *

  * Revision 1.34  2009/02/24 07:12:35  dick

  * Correctly parse the match score onMatchOver().

  *

  * Revision 1.33  2009/02/20 10:20:47  dick

  * Use YourName and OpponentName where possible, instead of just "getName".

  *

  * Revision 1.32  2009/02/17 14:44:08  dick

  * Turn off DEBUG.

  *

  * Revision 1.31  2009/02/14 12:04:30  dick

  * BuckoFIBS is released under the GNU license.

  *

  * Revision 1.30  2009/02/12 06:05:26  dick

  * Javadoc.

  *

  * Revision 1.29  2009/02/11 08:59:24  dick

  * Better beginning and ending your turn.

  *

  * Revision 1.28  2009/02/06 07:56:49  dick

  * Working on doubles.

  *

  * Revision 1.27  2009/02/01 21:21:01  dick

  * Add savedMatches and missManners lists to track other players' behavior.

  *

  * Revision 1.26  2009/01/29 08:26:39  dick

  * Fix the pip count calculation.

  *

  * Revision 1.25  2009/01/28 19:42:37  dick

  * Prettier cvs link in the javadoc.

  *

  * Revision 1.24  2009/01/26 07:31:24  dick

  * Sort the dice high to low.

  *

  * Revision 1.23  2009/01/24 17:04:21  dick

  * When parsing the board, i tried to normalize the data so that the player was always playing 24-1.

  * That didn't really work out, great for watching, tough for playing.

  * So get rid of it.

  * Also, lots of javadoc.

  *

  * Revision 1.22  2009/01/22 05:01:26  dick

  * add getXO().

  *

  * Revision 1.21  2009/01/20 07:41:54  dick

  * Send a string to the parser to set the initial positions.

  *

  * Revision 1.20  2009/01/18 05:26:24  dick

  * Javadoc.

  *

  * Revision 1.19  2009/01/18 04:43:41  dick

  * Javadoc.

  *

  * Revision 1.18  2009/01/10 05:20:36  dick

  * Turn off DEBUG.

  *

  * Revision 1.17  2009/01/10 05:02:27  dick

  * Totally cleanup who is who.  I parse the board so that You is always Player0 and playing 24 to 1.

  * Get rid of unneeded setters.  Only parseFibsBoard can set attributes.

  *

  * Revision 1.16  2009/01/09 06:56:07  dick

  * Change whosTurn parsing.

  * Turn off DEBUG.

  *

  * Revision 1.15  2009/01/08 18:25:26  dick

  * Add getMatchLength

  *

  * Revision 1.14  2009/01/08 01:28:13  dick

  * getPlayerName returns the list of players in this match.

  *

  * Revision 1.13  2009/01/06 08:05:07  dick

  * Javadoc.

  *

  * Revision 1.12  2008/12/20 23:01:39  dick

  * Support for Own Info.

  *

  * Revision 1.11  2008/12/17 04:37:11  dick

  * Add the direction that the user is playing in.

  *

  * Revision 1.10  2008/12/13 06:15:33  dick

  * Parse home and the bar.

  *

  * Revision 1.9  2008/12/12 14:44:22  dick

  * Fibs board parsing.

  *

  * Revision 1.8  2008/12/12 01:19:52  dick

  * Start reworking for a point based board,  not a checker based board.

  *

  * Revision 1.7  2008/12/11 20:24:23  dick

  * Early parsing of FIBS board.

  *

  * Revision 1.6  2008/12/10 21:55:14  dick

  * Add dice attributes.

  *

  * Revision 1.5  2008/12/09 01:47:05  dick

  * Define WHITE and BLACK.

  *

  * Revision 1.4  2008/12/08 10:16:31  dick

  * Add setStartPositions().

  *

  * Revision 1.3  2008/12/08 06:44:07  dick

  * checkers is an array of int.

  *

  * Revision 1.2  2008/03/30 05:38:51  dick

  * More skeleton checkins.

  *

  * Revision 1.1  2008/03/29 08:57:43  dick

  * BuckoFIBS skeleton checkin.

  */

 /* 

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  *

  * The Original Code is BuckoFIBS, <http://www.buckosoft.com/BuckoFIBS/>.

  * The Initial Developer of the Original Code is Dick Balaska and BuckoSoft, Corp.

  * 

  */

 package com.buckosoft.fibs.domain;

 /** Define a backgammon board. 

  * This object parses the fibs board command and returns various attributes from the parse.

  * @author Dick Balaska

  * @since 2008/03/29

  * @version $Revision$ <br> $Date$

  * @see <a href="http://cvs.buckosoft.com/Projects/BuckoFIBS/BuckoFIBS/src/main/java/com/buckosoft/fibs/domain/Board.java">cvs Board.java</a>

  * @see <a href="http://www.fibs.com/fibs_interface.html#board_state" target="_top">FIBS Client Protocol Detailed Specification</a>

  */

 public class Board implements Cloneable {

         private final static boolean DEBUG = false;

         private int canMove;

         private        int        xo;

         private int matchLength = 0;

         private        int matchScore[] = new int[2];

         private        static String        initialPositions = "board:Player0:Player1:3:0:0:0:-2:0:0:0:0:5:0:3:0:0:0:-5:5:0:0:0:-3:0:-5:0:0:0:0:2:0:1:0:0:0:0:1:1:1:0:1:-1:0:25:0:0:0:0:2:0:0:0";

 //        private        boolean        gameOver = true;

         private        int[][] dice = new int[2][2];

         private        int direction;

         private        String[] playerName = new String[2];

         private int[] points = new int[26];                // 0 and 25 are unused.  See bar

         private int[] bar = new int[2];

         private int[] home = new int [2];

         private int[] pipCount = new int[2];

         /** The player playing the 'O' pieces.  The value is 0. */

         public final static int O = 0;

         /** The player playing the 'X' pieces.  The value is 1. */

         public final static int X = 1;

         /** X's turn is marked with -1 */

         public final static int turnX = -1;

         /** O's turn is marked with 1 */

         public final static int turnO =  1;

         /** We don't know if it is player O or player X */

         public final static int XOnot = -2;

         /** When dealing with pointArrays, the special value Home is 0 */

         public final static int Home = 0;

         /** When dealing with pointArrays, the special value Bar is 25 */ 

         public final static int Bar = 25;

         /** Convert {@link Board#X} to {@link Board#turnX} and {@link Board#O} to {@link Board#turnO}.

          * @param xo The board player.

          * @return The turn.

          */

         public static int xoToTurn(int xo) {

                 return (xo == Board.X ? Board.turnX : Board.turnO);

         }

         private        int whosTurn = 0;

         private        int        cube = 1;

         private        boolean        sortDice = true;

         /** Who has the doubling cube?<br>

          * -1 = noone, X = X, O = O */

         private        int        hasCube = 0;

         private        int[] mayDouble = new int[2];

         private boolean[] wasDoubled = new boolean[2];

         /* "External" attributes.  That is, not derived by parseBoard */

         private        boolean        yourTurnToRollOrDouble = false;

         private boolean acceptDeclineResign = false;

         private        int                whoIsResigning = -1;

         private int                resigningPoints = -1;

         /** Create an empty board */

         public Board() { }

         /** Clone this board

          * @return A new copy of this board.

          */

         public Board clone() {

                 Board b = new Board();

                 b.xo = this.xo;

                 b.matchLength = this.matchLength;

                 b.matchScore[0] = this.matchScore[0];

                 b.matchScore[1] = this.matchScore[1];

                 b.dice[0][0] = this.dice[0][0];

                 b.dice[0][1] = this.dice[0][1];

                 b.dice[1][0] = this.dice[1][0];

                 b.dice[1][1] = this.dice[1][1];

                 b.direction = this.direction;

                 b.playerName[0] = this.playerName[0];

                 b.playerName[1] = this.playerName[1];

                 for (int i=0; i<26; i++)

                         b.points[i] = this.points[i];

                 b.bar[0] = this.bar[0];

                 b.bar[1] = this.bar[1];

                 b.home[0] = this.home[0];

                 b.home[1] = this.home[1];

                 b.whosTurn = this.whosTurn;

                 b.cube = this.cube;

                 b.sortDice = this.sortDice;

                 b.hasCube = this.hasCube;

                 b.mayDouble[0] = this.mayDouble[0];

                 b.mayDouble[1] = this.mayDouble[1];

                 b.wasDoubled[0] = this.wasDoubled[0];

                 b.wasDoubled[1] = this.wasDoubled[1];

                 b.yourTurnToRollOrDouble = this.yourTurnToRollOrDouble;

                 b.acceptDeclineResign = this.acceptDeclineResign;

                 b.whoIsResigning = this.whoIsResigning;

                 b.resigningPoints = this.resigningPoints;

                 return(b);

         }

         /** Set the flag saying we want sorted dice or not

          * @param sortDice true = sort the dice, false = deal with them as received

          */

         public void setSortDice(boolean sortDice) {

                 this.sortDice = sortDice;

                 if (sortDice) {

                         if (this.dice[0][0] < this.dice[0][1]) {

                                 int x = dice[0][0];

                                 dice[0][0] = dice[0][1];

                                 dice[0][1] = x;

                         }

                         if (this.dice[1][0] < this.dice[1][1]) {

                                 int x = dice[1][0];

                                 dice[1][0] = dice[1][1];

                                 dice[1][1] = x;

                         }

                 }

         }

         /** Is it your turn?

          * @return the yourTurnToRollOrDouble

          */

         public boolean isYourTurnToRollOrDouble() {

                 return yourTurnToRollOrDouble;

         }

         /** Set your turn to roll or double

          * @param yourTurnToRollOrDouble the yourTurnToRollOrDouble to set

          */

         public void setYourTurnToRollOrDouble(boolean yourTurnToRollOrDouble) {

                 this.yourTurnToRollOrDouble = yourTurnToRollOrDouble;

         }

         /** We have been doubled and need to accept or decline

          */

         public void setAcceptDeclineDouble() {

                 this.getWasDoubled()[1] = true;

         }

         /** Are you in a state where you are required to accept or decline a double?

          * @return true = opponent has doubled

          */

         public boolean isAcceptDeclineDouble() {

                 return(this.getWasDoubled()[1]);

         }

         /** Are you in a state where you are required to accept or decline a resign?

          * @return true = opponent has offered to resign

          */

         public boolean isAcceptDeclineResign() {

                 return(this.acceptDeclineResign);

         }

         public void setAcceptDeclineResign(boolean enabled) {

                 this.acceptDeclineResign = enabled;

         }

         /** Someone wants to resign, this is the player

          * @param xo Board.X or Board.O wants to resign

          */

         public void setWhoIsResigning(int xo) {

                 this.whoIsResigning = xo;

         }

         public int        getWhoIsResigning() {

                 return(this.whoIsResigning);

         }

         public void setResigningPoints(int resigningPoints) {

                 this.resigningPoints = resigningPoints;

         }

         public int getResigningPoints() {

                 return(this.resigningPoints);

         }

         /** Fetch the points array, the checkers on the board.

          * 1-24 are used. 0 and 25 are ununsed (see home and bar).

          * @return The points array.

          */

         public int[] getPoints() {

                 return(points);

         }

         /** Get the number of checkers on the bar for both players.

          * @return The bar

          */

         public int[] getBar() {

                 return(bar);

         }

         /** Get the number of checkers in both player's homes.

          * @return The home array

          */

         public int[] getHome() {

                 return(home);

         }

         /** Is there a pending double on the table?

          * @return an array of wasDoubled

          */

         public boolean[] getWasDoubled() {

                 return(this.wasDoubled);

         }

         /** Is there a pending double on the table?

          * @param xo {@link Board#X} or {@link Board#O}

          */

         public void setWasDoubled(int xo) {

                 wasDoubled[Board.O] = false;

                 wasDoubled[Board.X] = false;

                 if (xo == Board.O)

                         wasDoubled[Board.O] = true;

                 if (xo == Board.X)

                         wasDoubled[Board.X] = true; 

         }

         /** Are You allowed to double?

          * @return true is yes.

          */

         public boolean isYouMayDouble() {

                 return (this.mayDouble[Board.O] == 1);

         }

         public boolean isOpponentMayDouble() {

                 return (this.mayDouble[Board.X] == 1);

         }

         /** Are you playing or just watching?

          * @return true if playing

          */ 

         public boolean isYouPlaying() {

                 return(this.playerName[0].equals("You"));

         }

         /** Is it your turn to move?  That is, have you rolled and should move checkers?

          * @return whether there is valid dice on the table.

          */

         public boolean isYourMove() {

                 return(dice[0][0] != 0);

         }

         /** Get the list of player names who are playing this game.

          * @return The player Names

          */

         public String[] getPlayerName() {

                 return(playerName);

         }

         /** Set the value of one of the playerNames.

          * @param which Which player to set {@link Board#X} or {@link Board#O}

          * @param name The name of the player.

          */

         public void setPlayerName(int which, String name) {

                 this.playerName[which] = name;

         }

         /** Get the number of points in the match

          * @return The matchLength

          */

         public int        getMatchLength() {

                 return(matchLength);

         }

         /** Get the score for both players in this match

          * @return the score array

          */

         public int[] getMatchScore() {

                 return(matchScore);

         }

         /** Place all checkers on their start positions

          */

         public void setStartPositions() {

                 this.parseFibsBoard(initialPositions);

         }

         /** Get whether you are playing as X or O

          * @return -1 if you are X,  1 if you are O <br>({@link Board#turnX} or {@link Board#turnO})

          */

         public int        getXO() {

                 return(xo);

         }

         /** Get XO as text. Just a devel function

          * @return "O" or "X"

          */

         public String getXOAsText() {

                 return(xo == Board.O ? "O" : "X");

         }

         /** Get XO as text. Just a devel function

          * @return "O" or "X"

          */

         public static String getXOAsText(int xo) {

                 return(xo == Board.O ? "O" : "X");

         }

         /** Get turnXO as text. Just a devel function

          * @return "O" or "X"

          */

         public static String getTurnAsText(int turn) {

                 return(turn == Board.turnO ? "turnO" : "turnX");

         }

         /** When you pick up the dice, 0 them out so there is a visual cue.

          * Sometimes it takes fibs a while to send a new board. 

          */

         public void clearDice() {

                 this.dice[0][0] = 0;

                 this.dice[0][1] = 0;

         }

         /** Get who's turn it is.  -1 = X, 1 = O, 0 = game over

          * @return the whosTurn {@link Board#turnX} or{@link Board#turnO}

          */

         public int getWhosTurn() {

                 return whosTurn;

         }

         /** Given a playerName, return whether he is playing {@link Board#X} or {@link Board#O} 

          * @param name The player's name to check

          * @return Board.X or Board.O for a match, {@link Board#XOnot} for non-match

          */

         public int        getXOFromName(String name) {

                 if (name.equals(playerName[Board.X]))

                         return(Board.X);

                 else if (name.equals(playerName[Board.O]))

                         return(Board.O);

                 return(XOnot);

         }

         /** Get the playing direction for this player

          * @param name The player name to check

          * @return -1 or 1

          */

         public int        getDirectionFromName(String name) {

                 if (name.equals(playerName[Board.O]))

                         return(direction);

                 return(-direction);

         }

         /** Get the number displayed on the double cube

          * @return the cube

          */

         public int getCube() {

                 return cube;

         }

         /** Who has the doubling cube?

          * -1 = noone, X = X, O = O 

          * @return who has the cube

          */

         public int getHasCube() {

                 return hasCube;

         }

         /** -1 If you play from position 24 to position 1.<br>

          *   1 If you play from position 1 to position 24.

          * @return the direction

          */

         public int getDirection() {

                 return direction;

         }

         /** Get the 2x2 array of both player's both dice

          * @return the dice

          */

         public int[][] getDice() {

                 return dice;

         }

         /** Return the number of pieces the player can move this turn.

          * @return The canMove from this board.

          */

         public int getCanMove() {

                 return(canMove);

         }

         /** Handle the '* wins the match' message. <br>

          * Fibs doesn't send a final board, which should have the final score.

          * So we have to derive the match over scenario.

          */

         public void onMatchOver(String winner, String score) {

                 String[] ss = score.split("\\-");

                 int s0 = Integer.parseInt(ss[0]);

                 int s1 = Integer.parseInt(ss[1]);

                 if (winner.equals("You") || winner.equals(this.playerName[0])) {

                         matchScore[0] = s0;

                         matchScore[1] = s1;

                 } else {

                         matchScore[0] = s1;

                         matchScore[1] = s0;

                 }

                 whosTurn = 0;

         }

         /** Calculate and return the number of pips for both players.

          * Used by the {@link com.buckosoft.fibs.BuckoFIBS.gui.boardTab.MatchStatusPanel}.

          * @return A reference to our local pipCount (reuse object).

          */

         public int[] getPipCount() {

                 int i;

                 this.pipCount[O] = 0;

                 this.pipCount[X] = 0;

                 for (i=1; i<=24; i++) {

                         if (this.points[i] < 0)

                                 pipCount[O] += ((this.getDirection() == -1 ? i : (25 - i)) * -this.points[i]);

                         else if (this.points[i] > 0)

                                 pipCount[X] += ((this.getDirection() == 1 ? i : (25 - i)) * this.points[i]);

                 }

                 pipCount[O] += (bar[O]*25);

                 pipCount[X] += (bar[X]*25);

                 return(this.pipCount);

         }

         /** Is this game a race?

          * Determine whether all of your checkers are past the opponent's checkers

          * @return true if this game has turned into a race.

          */

         public boolean isRace() {

                 int i;

                 int k = 0;

                 if (bar[O] > 0 || bar[X] > 0)

                         return(false);

                 boolean oppositeSeen = false;

                 for (i=1; i<=24; i++) {

                         if (this.points[i] == 0)

                                 continue;

                         if (k == 0) {

                                 k = this.points[i];

                                 continue;

                         }

                         if (!oppositeSeen) {

                                 if (k < 0 && this.points[i] > 0) {

                                         oppositeSeen = true;

                                         continue;

                                 }

                                 if (k > 0 && this.points[i] < 0) {

                                         oppositeSeen = true;

                                         continue;

                                 }

                         } else {

                                 if (k < 0 && this.points[i] < 0)

                                         return(false);

                                 if (k > 0 && this.points[i] > 0)

                                         return(false);

                         }

                 }

                 return(true);

         }

         // positions of the fields in a board line

         private final static int YOU = 1;

         private final static int SOMEPLAYER = 2;

         private final static int MATCHLENGTH = 3;

         private final static int CURRENTSCORES = 4;

         private final static int BOARD = 6;

         private final static int TURN = 32;

         private final static int DICE = 33;

         private final static int CUBE = 37;

         private final static int MAYDOUBLE = 38;

 //        private final static int WASDOUBLED = 40;

         private final static int XO = 41;

         private final static int DIRECTION = 42;

         private final static int ONHOME = 45;

         private final static int ONBAR = 47;

         private final static int CANMOVE = 49;

         /** Parse the board state from Fibs.

          * Opening board looks like this:<br>

          * board:You:someplayer:3:0:0:0:-2:0:0:0:0:5:0:3:0:0:0:-5:5:0:0:0:-3:0:-5:0:0:0:0:2:0:1:6:2:0:0:1:1:1:0:1:-1:0:25:0:0:0:0:2:0:0:0

          * @param s The board

          * @see <a href="http://www.fibs.com/fibs_interface.html#board_state" target="_top">FIBS Client Protocol Detailed Specification</a>

          * <pre>

          * 0                                   1                    2                     3                   4                     5

          * 0     1   2          3 4 5 6 7  8 9 0 1 2 3 4 5 6 7 8  9 0 1 2 3  4 5  6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2  3 4  5 6 7 8 9 0 1 2 

          * board:You:someplayer:3:0:0:0:-2:0:0:0:0:5:0:3:0:0:0:-5:5:0:0:0:-3:0:-5:0:0:0:0:2:0:1:6:2:0:0:1:1:1:0:1:-1:0:25:0:0:0:0:2:0:0:0

          * </pre>

          */

         public void parseFibsBoard(String s) {

                 int i;

                 String[] t = s.split(":");

                 xo = Integer.parseInt(t[XO]);

                 direction = Integer.parseInt(t[DIRECTION]);

                 playerName[0] = t[YOU];

                 playerName[1] = t[SOMEPLAYER];

                 matchLength = Integer.parseInt(t[MATCHLENGTH]);

                 matchScore[0] = Integer.parseInt(t[CURRENTSCORES+0]);

                 matchScore[1] = Integer.parseInt(t[CURRENTSCORES+1]);

                 for (i=1; i<=24; i++) {

                         this.points[i] = Integer.parseInt(t[BOARD+i]) * -xo;

                 }

                 this.whosTurn = Integer.parseInt(t[TURN]);

                 setDice(dice[O], Integer.parseInt(t[DICE+0]), Integer.parseInt(t[DICE+1]));

                 setDice(dice[X], Integer.parseInt(t[DICE+2]), Integer.parseInt(t[DICE+3]));

                 cube = Integer.parseInt(t[CUBE]);

                 mayDouble[0] = Integer.parseInt(t[MAYDOUBLE+0]);

                 mayDouble[1] = Integer.parseInt(t[MAYDOUBLE+1]);

 //                wasDoubled[1] = t[WASDOUBLED].equals("1") ? true : false;

                 if (DEBUG)

                         System.out.println("mayDouble[" + mayDouble[0] + "][" + mayDouble[1] + "]");

                 if (mayDouble[0] == mayDouble[1])

                         hasCube = -1;

                 else if (mayDouble[0] == 1)

                         hasCube = X;

                 else if (mayDouble[1] == 1)

                         hasCube = O;

                 home[O] = Integer.parseInt(t[ONHOME+0]);

                 home[X] = Integer.parseInt(t[ONHOME+1]);

                 bar[O] = Integer.parseInt(t[ONBAR+0]);

                 bar[X] = Integer.parseInt(t[ONBAR+1]);

                 canMove = Integer.parseInt(t[CANMOVE]);

                 if (DEBUG)

                         System.out.println("xo=" + xo + " direction=" + direction + " canMove=" + canMove

                                         + " wasDoubled[1]=" + wasDoubled[1] + " turn=" + this.whosTurn);

         }

         /** Parse a board for debug analysis.

          * Basically this includes points[0] and points[25] which we usually ignore.

          * @param s The board string

          * @param debugMode If true then actually parse. 

          */

         public void parseFibsBoard(String s, boolean debugMode) {

                 if (debugMode) {

                         parseFibsBoard(s);

                         String[] t = s.split(":");

                         this.points[0] = Integer.parseInt(t[BOARD]);

                         this.points[25] = Integer.parseInt(t[BOARD+25]);

                 }

         }

         /** Sort the dice and set them in the player's dice array

          * @param d The dice array to store in.

          * @param d0 value of die 0

          * @param d1 value of die 1

          */

         private void setDice(int[]d, int d0, int d1) {

                 d[0] = d0;

                 d[1] = d1;

                 if (sortDice && d1 > d0) {

                         d[0] = d1;

                         d[1] = d0;

                 }

         }

 }