Coverage Report

 /******************************************************************************
  * BoardPane.java - Draw a backgammon board
  * $Id$
  * 
  * BuckoFIBS - Backgammon by BuckoSoft
  * Copyright© 2009,2010 - Dick Balaska - BuckoSoft, Corp.
  * 
  * $Log$
  * Revision 1.9  2013/09/12 06:42:28  dick
  * Animating the double cube.
  *
  * Revision 1.8  2013/09/10 00:21:58  dick
  * Javadoc and debug
  *
  * Revision 1.7  2011/07/04 03:44:35  dick
  * Add FirstRoll handling.
  *
  * Revision 1.6  2011/06/19 04:14:09  dick
  * Send the board to the MatchStatusPanel as well.
  *
  * Revision 1.5  2011/06/18 19:34:09  dick
  * Always draw red dice on CantMove.  Who cares whose dice they are.
  * Push our resign flag a little onto his board.
  *
  * Revision 1.4  2011/06/05 06:56:05  dick
  * Draw the AcceptAndWin animation.
  *
  * Revision 1.3  2011/06/02 19:18:30  dick
  * Deal with painting resign.
  *
  * Revision 1.2  2011/05/31 19:38:56  dick
  * Use the AnimateEventDiceRoll constants, instead of hard coded numbers.
  *
  * Revision 1.1  2011/05/22 22:56:08  dick
  * c.b.f.B.g.boardTab.board becomes c.b.f.B.g.boardTab.boardPane .
  *
  * Revision 1.8  2011/05/22 05:24:07  dick
  * diceUsed is always false during a DiceRoll animation.
  *
  * Revision 1.7  2011/05/21 05:03:02  dick
  * Doubling functions are in the Board, not the Document.
  * BoardPane only care about Board.
  *
  * Revision 1.6  2011/05/17 22:50:04  dick
  * AnimateEvent moves to c.b.f.B.g.b.b which is where it is used.
  *
  * Revision 1.5  2011/05/16 21:25:56  dick
  * Handle Home and Bar during Move.
  *
  * Revision 1.4  2011/05/16 14:18:41  dick
  * Draw the CantMove event.
  *
  * Revision 1.3  2011/05/16 11:40:03  dick
  * Painting animated dice rolls.
  * More work on painting moving checkers.
  *
  * Revision 1.2  2011/05/15 04:38:03  dick
  * Still draw the animation's extraCheckers even if there is no open event.
  *
  * Revision 1.1  2011/05/15 02:17:54  dick
  * Move the AnimateEvents to their own package.
  *
  * Revision 1.11  2011/05/14 05:19:31  dick
  * Still need work on the doubles handling for board/document split.
  *
  * Revision 1.10  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.9  2011/05/13 18:26:22  dick
  * Debugging animation.
  *
  * Revision 1.8  2011/05/13 14:56:15  dick
  * Add support for animating checkers on the board.
  *
  * Revision 1.7  2011/05/11 22:22:04  dick
  * Working on animating checkers.
  *
  * Revision 1.6  2011/01/04 20:05:26  dick
  * If there are 3 columns of checkers on a point, draw the point number in the correct y coordinate.
  *
  * Revision 1.5  2011/01/01 06:11:14  dick
  * Javadoc.
  *
  * Revision 1.4  2010/12/29 07:50:05  dick
  * Display the dice in grey as they are used up.
  *
  * Revision 1.3  2010/03/03 13:12:21  inim
  * Replaced (c) sign in comment mangled by CVS default encoding back to UTF-8
  *
  * Revision 1.2  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.1  2010/02/04 05:57:53  inim
  * Mavenized project folder layout
  *
  * Revision 1.6  2009/02/14 15:19:12  dick
  * BuckoFIBS is released under the GNU license.
  *
  * Revision 1.5  2009/02/12 06:28:03  dick
  * Add hoverTo home.
  *
  * Revision 1.4  2009/02/06 07:56:49  dick
  * Working on doubles.
  *
  * Revision 1.3  2009/02/05 06:01:43  dick
  * Draw the double cube being pushed.
  * Draw the minidice.
  *
  * Revision 1.2  2009/01/31 06:06:55  dick
  * If there are 6 or more checkers on a point, then draw the point number centered on #6.
  *
  * Revision 1.1  2009/01/28 19:37:28  dick
  * package com.buckosoft.fibs.gui.board becomes com.buckosoft.fibs.BuckoFIBS.gui.board.
  *
  * Revision 1.25  2009/01/28 08:32:49  dick
  * Turn off DEBUG.
  *
  * Revision 1.24  2009/01/27 05:45:39  dick
  * Hover off of the bar.
  *
  * Revision 1.23  2009/01/26 06:07:34  dick
  * I believe checkers always draw in their correct colors now.
  *
  * Revision 1.22  2009/01/24 17:08:36  dick
  * Wrassle with drawing the right colored pieces in the right places.
  *
  * Revision 1.21  2009/01/22 05:04:49  dick
  * More moving checkers on the board.  There are issues with playing 1-24 vs. 24-1.
  *
  * Revision 1.20  2009/01/20 07:42:52  dick
  * Add hover colors and checkers.
  *
  * Revision 1.19  2009/01/18 05:06:08  dick
  * mouse event handling.
  * Add paintPointNumbers
  * Make some methods/attributes protected so that BoardGui can get at them.
  *
  * Revision 1.18  2009/01/10 05:06:15  dick
  * Fix the color of the dice, the position of the cube, and tweak the position of the bar.
  *
  * Revision 1.17  2009/01/08 18:47:02  dick
  * Assign a dummy board.
  *
  * Revision 1.16  2009/01/08 01:34:00  dick
  * Javadoc.
  *
  * Revision 1.15  2009/01/07 04:30:06  dick
  * Javadoc.
  *
  * Revision 1.14  2008/12/20 23:02:40  dick
  * Dice, checkers on bar, and double cube.
  *
  * Revision 1.13  2008/12/16 20:08:13  dick
  * Start painting on the bar.
  *
  * Revision 1.12  2008/12/12 23:24:43  dick
  * Switch around the colors of the dice and checkers.
  *
  * Revision 1.11  2008/12/12 14:45:51  dick
  * Update drawing to the new FIBS based board (based on points instead of checkers).
  *
  * Revision 1.10  2008/12/12 01:19:52  dick
  * Start reworking for a point based board,  not a checker based board.
  *
  * Revision 1.9  2008/12/11 09:57:25  dick
  * Javadoc.
  *
  * Revision 1.8  2008/12/10 23:46:59  dick
  * Drawing nice dice.
  *
  * Revision 1.7  2008/12/10 21:56:12  dick
  * Early dice drawing.
  *
  * Revision 1.6  2008/12/08 10:17:15  dick
  * Display the checkers on the board.
  *
  * Revision 1.5  2008/12/08 06:45:39  dick
  * Drawing checkers in the home position.
  *
  * Revision 1.4  2008/04/07 06:13:26  dick
  * Generalize calculating the board's points.
  *
  * Revision 1.3  2008/04/05 01:43:22  dick
  * Draw the points.
  */
 
 /* 
  * 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.BuckoFIBS.gui.boardTab.boardPane;
 
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Point;
 
 import javax.swing.JPanel;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.buckosoft.fibs.BuckoFIBS.BFProperties;
 import com.buckosoft.fibs.BuckoFIBS.gui.boardTab.BoardTab;
 import com.buckosoft.fibs.BuckoFIBS.gui.boardTab.boardPane.AnimateEvent.Type;
 import com.buckosoft.fibs.domain.Board;
 
 /** Draw a backgammon board. <br>
  * checker width is a root.<br>
  * There are 16.5 checker widths in a board.<br>
  * 12 points<br>
  * 1.5 left side, right side, bar.<br>
  * ebeh, still need to make sure that 5 checkers will fit on a point.
  * @author Dick Balaska
  * @since 2008/04/01
  * @version $Revision$ <br> $Date$
  * @see <a href="http://cvs.buckosoft.com/Projects/BuckoFIBS/BuckoFIBS/src/main/java/com/buckosoft/fibs/BuckoFIBS/gui/boardTab/BoardPane.java">cvs BoardPane.java</a>
  */
 public class BoardPane extends JPanel {
         private        final static boolean DEBUG = false;
         private        final static boolean DEBUGa = false;                // animate foo
     private Logger logger = LoggerFactory.getLogger(getClass());
         private static final long serialVersionUID = 1L;
         
         
         // Assign a dummy board, just so Visual Editor will have something to draw.
         // This will get overwritten by the real board during runtime.
         protected        Board                        board = new Board();  //  @jve:decl-index=0:
         //protected        Document                document;
         private                BoardTab                boardTab = null;
         protected        BFProperties        properties = null;
 
         /** Drawing dimensions and hints */
         public                BoardSpecs bs = new BoardSpecs();  //  @jve:decl-index=0:
 
         private        Color        boxColor = Color.darkGray;  //  @jve:decl-index=0:
         private        Color        boardColor = Color.lightGray;  //  @jve:decl-index=0:
         private        Color        bPointColor = Color.pink;  //  @jve:decl-index=0:
         private        Color        wPointColor = Color.red;  //  @jve:decl-index=0:
         private        Color        bCheckerColor = Color.black;
         private        Color        bTrimColor = Color.white;
         private        Color        wCheckerColor = Color.white;
         private Color        wGreyColor = Color.gray;
         private        Color        wTrimColor = Color.black;
         
 //        private        Color        hoverColor = Color.lightGray;
         private        Color        hoverColor = new Color(200,200,200,192);
 //        private        Color        hoverToColor = Color.yellow;
         private        Color        hoverToColor = new Color(255,255,0,150);
         
         protected static final int POINT_UNKNOWN = -1;
         protected static final int POINT_BAR = -2;
         protected static final int POINT_DICE = -3;
         protected static final int POINT_DOUBLE = -4;
         protected static final int POINT_BAR_DICE = -5;
         protected static final int POINT_REJECT = -6;
         
         
 
         protected int        hoverPoint = POINT_UNKNOWN;
         
         /** 1-24 are any "shadow" checkers on a point */
         protected int[] hoverTo = new int[26];
         
         /** Used for drawing the points */
         private        int[] xPoints = new int[4];
         /** Used for drawing the points */
         private int[] yPoints = new int[4];
 
         protected boolean[] diceUsed = new boolean[2];
         
         protected        AnimateManager        animateManager;
         
         /** Default/only constructor */
         public BoardPane() {
                 super();
                 initialize();                
                 this.animateManager = new AnimateManager();
                 this.animateManager.setBoardPane(this);
                 this.animateManager.setProperties(properties);
         }
 
         /** Precalculate the dimensions of a board for drawing
          * @author Dick Balaska
          * @since 2008/04/01
          * @version $Revision$ <br> $Date$
          * @see <a href="http://cvs.buckosoft.com/Projects/BuckoFIBS/BuckoFIBS/src/main/java/com/buckosoft/fibs/BuckoFIBS/gui/board/BoardPane.java">cvs BoardPane.java</a>
          */
         public class BoardSpecs {
                 /** Width of the board */
                 public int        w;
                 /** Height of the board */
                 public int        h;
                 /** diameter of a checker */
                 public int        checkerSize;
                 /** checkerSize * 1.5 */
                 public int c15;
                 /** checkerSize / 2 */
                 public int        c2;
                 /** checkerSize / 3 for in home */
                 public int checkerHeight;
                 public int dieSize;
                 public int extra;
                 public int barWidth;
                 /** How tall is the point */
                 public int        pointHeight;
 //                public Color        cColor;
 //                public Color        tColor;
         }
         
         /** Set the reference to the backgammon board.
          * @param board the board to set
          */
         public void setBoard(Board board) {
                 this.board = board;
                 this.boardTab.setMatchStatusPanelBoard(board);
         }
 
         public void setBoardTab(BoardTab boardTab) {
                 this.boardTab = boardTab;
         }
 
 
         /** This method initializes this
          * @return void
          */
         private void initialize() {
                 this.setSize(400, 300);
                 this.setPreferredSize(new Dimension(400, 300));
                 this.addMouseListener(new java.awt.event.MouseAdapter() {   
                         public void mousePressed(java.awt.event.MouseEvent e) {    
                                 onMousePressed(e);
                         }
                 });
                 this.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
                         public void mouseMoved(java.awt.event.MouseEvent e) {
                                 onMouseMoved(e);
                         }
                 });
         }
 
         protected void setHoverPoint(int p) {
                 if (DEBUG)
                         System.out.println("setHoverPoint(" + p + ")");
                 hoverPoint = p;
                 int i;
                 for (i=0; i<hoverTo.length; i++)
                         hoverTo[i] = 0;
         }
 
         protected void onMouseClicked(java.awt.event.MouseEvent e) {
                 System.out.println("onMouseClicked: Should be overridden");
         }
 
         protected void onMousePressed(java.awt.event.MouseEvent e) {
                 System.out.println("onMousePressed: Should be overridden");
         }
 
         protected void onMouseMoved(java.awt.event.MouseEvent e) {
                 System.out.println("onMouseMoved: Should be overridden");
         }
 
         /** Paint the entire backgammon board and all of it's pieces.
          * @param g The Graphics to use
          */
         public void paint(Graphics g) {
                 super.paint(g);
                 bs.w = this.getWidth();
                 bs.h = this.getHeight();
                 bs.checkerSize = (int)(((double)bs.w)/16.5);
                 bs.c2 = bs.checkerSize / 2;
                 bs.c15 = (int)((double)bs.checkerSize * 1.5);
                 bs.checkerHeight = bs.checkerSize/3;
                 bs.extra = bs.w-((bs.checkerSize*12)+(bs.c15*3));
                 bs.barWidth = bs.checkerSize + bs.extra;
                 bs.pointHeight = bs.h/2-bs.c15;                // XXX: make something up for now. This could be better.
 
                 // fill with the board color (shouldn't this be in "erase"?)
                 g.setColor(boardColor);
                 g.fillRect(0, 0, bs.w, bs.h);
         
                 // draw left end
                 g.setColor(boxColor);
                 g.fillRect(0, 0, bs.c15, bs.h);
                 // draw right end
                 g.fillRect(bs.w-bs.c15, 0, bs.w, bs.h);
                 // draw bar
                 g.fillRect(bs.w/2-bs.barWidth/2, 0, bs.barWidth, bs.h);
                 int x, y, w;
                 y = bs.pointHeight;
                 int p;
                 for (p=1; p<=12; p++) {                // points 1-12
                         x = getPointX(p);
                         if ((p & 1) != 0)
                                 g.setColor(wPointColor);
                         else
                                 g.setColor(bPointColor);
                         xPoints[0] = x;
                         yPoints[0] = bs.h;
                         xPoints[1] = x+bs.c2;
                         yPoints[1] = bs.h-y;
                         xPoints[2] = x+bs.checkerSize;
                         yPoints[2] = bs.h;
                         xPoints[3] = x;
                         yPoints[3] = bs.h;
                         g.fillPolygon(xPoints, yPoints, 4);
                         g.setColor(Color.black);
                         g.drawLine(x, bs.h, x+bs.c2, bs.h-y);
                         g.drawLine(x+bs.c2, bs.h-y, x+bs.checkerSize, bs.h);
                 }
                 for (p=13; p<=24; p++) {
                         x = getPointX(p);
                         if ((p & 1) == 1)
                                 g.setColor(wPointColor);
                         else
                                 g.setColor(bPointColor);
                         xPoints[0] = x;
                         yPoints[0] = 0;
                         xPoints[1] = x+bs.c2;
                         yPoints[1] = y;
                         xPoints[2] = x+bs.checkerSize;
                         yPoints[2] = 0;
                         xPoints[3] = x;
                         yPoints[3] = 0;
                         g.fillPolygon(xPoints, yPoints, 4);
                         g.setColor(Color.black);
                         g.drawLine(x, 0, x+bs.c2, y);
                         g.drawLine(x+bs.c2, y, x+bs.checkerSize, 0);
                 }
                 paintCheckers(g);
                 paintDice(g);
                 paintDoubleCube(g);
                 paintPointNumbers(g);
                 if (this.board.isYourTurnToRollOrDouble()) {
                         int miniDieSize = bs.barWidth/2;
                         x = bs.w/2-bs.barWidth/2;
                         y = bs.h-miniDieSize-2;
                         paintDie(g, miniDieSize, x, y, 6, Color.white, Color.white, Color.black);
                         paintDie(g, miniDieSize, x+miniDieSize, y, 6, Color.white, Color.white, Color.black);
                         g.setColor(Color.yellow);
                         g.drawRoundRect(x-2, y-2, miniDieSize*2+2, miniDieSize+2, miniDieSize/4+2, miniDieSize/4+2);
                         g.drawRoundRect(x-1, y-1, miniDieSize*2+1, miniDieSize+1, miniDieSize/4+1, miniDieSize/4+1);
                         
                 }
                 if (board.isAcceptDeclineDouble() || board.isAcceptDeclineResign()) {
                         g.setColor(Color.red);
                         x = getDeclineX();
                         y = getDeclineY();
                         w = bs.c15;
                         g.drawLine(x, y, x+w, y+w);
                         g.drawLine(x+w, y, x, y+w);
                         g.drawLine(x+1, y, x+w+1, y+w);
                         g.drawLine(x+w+1, y, x+1, y+w);
 
                 }
                 paintResign(g);
                 paintAnimatedCheckers(g);
         }
 
         protected        int        getDeclineX() {
                 return(bs.w-bs.c15);
         }
         protected        int        getDeclineY() {
                 return(bs.h/2 - bs.c15/2);
         }
         private void paintCheckers(Graphics g) {
                 int[] p = this.board.getPoints();
                 int i;
                 int j;
                 int c;
                 if (p == null)
                         return;
                 if (DEBUG)
                         System.out.println("xo=" + board.getXO() + " dir=" + board.getDirection());
                 for (i=1; i<=24; i++) {
                         c = Math.abs(p[i]);
                         if (c == 0 && hoverTo[i] == 0)
                                 continue;
                         Color cColor = bCheckerColor;
                         Color tColor = bTrimColor;
                         //if (p[i]*board.getXO() > 0) {
                         if (p[i] < 0) {
                                 if (DEBUG)
                                         System.out.println("p[" + i + "]=" + p[i]);
                                 cColor = wCheckerColor;
                                 tColor = wTrimColor;
                         }
                         int x = getPointX(i);
                         for (j=0; j<c+hoverTo[i]; j++) {
                                 int y = getNthCheckerY(i, j);
                                 if (i == hoverPoint && j == c-1) 
                                         cColor = hoverColor;
                                 if (j>=c)
                                         cColor = hoverToColor;
                                 g.setColor(cColor);
                                 g.fillArc(x, y, bs.checkerSize, bs.checkerSize, 0, 360);
                                 g.setColor(tColor);
                                 g.drawArc(x, y, bs.checkerSize, bs.checkerSize, 0, 360);
                         }
                 }
                 p = this.board.getHome();
                 for (j=0; j<p[1]; j++)
                         paintCheckerInHome(g, Board.X, j, bCheckerColor, bTrimColor);
                 for (j=0; j<p[0]; j++)
                         paintCheckerInHome(g, Board.O, j, wCheckerColor, wTrimColor);
                 if (hoverTo[0] > 0)
                         paintCheckerInHome(g, Board.O, j, hoverToColor, wTrimColor);
                 int[] bar = board.getBar();
                 for (j=0; j<bar[Board.O]; j++)
                         paintCheckerOnBar(g, Board.O, j, wCheckerColor, wTrimColor);
                 for (j=0; j<bar[Board.X]; j++)
                         paintCheckerOnBar(g, Board.X,  j, bCheckerColor, bTrimColor);
         }
 
         protected int getCheckerYOnBar(int who, int checker) {
                 int y = bs.h/2 + bs.checkerSize + ((checker % 5) * bs.checkerSize);
                 y -= (checker/5*bs.checkerHeight);
                 if (who == Board.O)
                         y = bs.h - bs.checkerSize -y;
                 
                 return(y);
         }
 
         private void paintCheckerOnBar(Graphics g, 
                         int who, int c, Color cColor, Color tColor) {
                 if (hoverPoint == POINT_BAR && c == 0)
                         cColor = hoverColor;
                 int x = bs.w/2 - bs.checkerSize/2;
                 int y = getCheckerYOnBar(who, c);
                 g.setColor(cColor);
                 g.fillArc(x, y, bs.checkerSize, bs.checkerSize, 0, 360);
                 g.setColor(tColor);
                 g.drawArc(x, y, bs.checkerSize, bs.checkerSize, 0, 360);
         }
 
         protected int        getCheckerYInHome(int who, int checker) {
                 int y;
                 y = checker * bs.checkerHeight;
                 if (who == Board.O)
                         y = bs.h - (checker+1) * bs.checkerHeight;
                 return(y);
         }
 
         private void paintCheckerInHome(Graphics g, 
                         int who, int checker, Color cColor, Color tColor) {
                 int x = bs.w-(bs.c15/2)-(bs.checkerSize/2);
                 int y = getCheckerYInHome(who, checker);
                 g.setColor(cColor);
                 g.fillArc(x, y, bs.checkerSize, bs.checkerHeight, 0, 180);
                 g.setColor(tColor);
                 g.drawArc(x, y, bs.checkerSize, bs.checkerHeight, 0, 180);
         }
 
         /** Return the left side of a point
          * @param p The point to calculate
          * @return The x of the left side of the triangle
          */
         protected int        getPointX(int p) {
                 if (p == Board.Bar)
                         return(bs.w/2-bs.c2);
                 if (p == Board.Home)
                         return(bs.w-(bs.c15/2)-(bs.checkerSize/2));
 
                 if (p > 12)
                         p = 25 - p;
                 p--;
                 int x = (bs.w - bs.c15 - bs.checkerSize) - ((bs.checkerSize+1)*p) - 2;
                 if (p > 5)
                         x -= bs.barWidth + 2;
                 return(x);
         }
 
         /** Calculate the y for a checker
          * @param p The point to calculate
          * @param c The checker number on the point.  There can be between 1-15 checkers sitting on a point.
          *                     (If there's 0, then there's no point of drawing).
          *                        This number is 0 based.
          * @return The y value to draw the checker at.
          */
         protected int getNthCheckerY(int p, int c) {
                 if (board.getDirection() > 0)
                         p = 25-p;
                 int y = (c % 5) * bs.checkerSize;
                 y += (c/5*bs.checkerHeight);
                 if (p <= 12)
                         y = bs.h - bs.checkerSize -y;
                 return(y);
         }
 
         ///////////////////////////////////////////////////////////////////////////
         /** Paint the dice
          * @param g The Graphics we draw to
          */
         private void paintDice(Graphics g) {
                 Color cColor = bCheckerColor;
                 Color tColor = bTrimColor;
                 Color gColor = wGreyColor;
 
                 bs.dieSize = bs.checkerSize;
                 int y = bs.h/2-bs.c2;
                 int x0 = this.getPointX(9) - bs.c15;
                 int x1 = x0+bs.c15;
                 int size = bs.dieSize;
                 int[][] dice = board.getDice();
 
                 AnimateEvent ae = this.animateManager.getHeadEvent();
                 if (ae != null) {
                         if (ae.getType() == Type.Roll) {
                                 AnimateEventDiceRoll aedr = (AnimateEventDiceRoll)ae;
                                 for (int i=0; i<diceUsed.length; i++)
                                         diceUsed[i] = false;
                                 if (aedr.getWho() == Board.X){
                                         int miniSize = bs.barWidth/2;
                                         int miniX = bs.w/2-bs.barWidth/2;
                                         int miniY = 0;        // bs.h-miniSize-2;
                                         int[] pos = aedr.getDiceParms(miniX, miniX+miniSize, miniY, miniSize, x0, x1, y, bs.dieSize);
                                         x0 = pos[AnimateEventDiceRoll.XL];
                                         x1 = pos[AnimateEventDiceRoll.XR];
                                         y = pos[AnimateEventDiceRoll.Y];
                                         size = pos[AnimateEventDiceRoll.SIZE];
                                         dice[Board.X][0] = aedr.dice[0];
                                         dice[Board.X][1] = aedr.dice[1];
                                 }
                         }
                         if (ae.getType() == Type.FirstRoll) {
                                 AnimateEventFirstRoll aefr = (AnimateEventFirstRoll)ae;
                                 for (int i=0; i<diceUsed.length; i++)
                                         diceUsed[i] = false;
                                 // Calculate the black die
                                 int miniSize = bs.barWidth/2;
                                 int miniX = bs.w/2-bs.barWidth/2;
                                 int miniY = 0;        // bs.h-miniSize-2;
                                 x0 = (int)(((x0-miniX)*ae.offset)+miniX);
                                 y =  (int)(((y-miniY)*ae.offset)+miniY);
                                 size = (int)(((bs.dieSize-miniSize)*ae.offset)+miniSize);
                                 // We have to paint the die here because Board.X is 0
                                 paintDie(g, size, x0, y, aefr.getBlackDie(), cColor, cColor, tColor);
 
                         }
                         if (ae.getType() == Type.CantMove){
                                 cColor = Color.red;
                         }
                         if (ae instanceof AnimateEventResign) {
                                 cColor = makeTranslucent(cColor);
                                 tColor = makeTranslucent(tColor);
                         }
                 }
                 // paint the black/opponent dice
                 if (ae == null || ae.getType() != Type.FirstRoll) {
                         if (dice[Board.X][0] != 0)
                                 paintDie(g, size, x0, y, dice[Board.X][0], cColor, cColor, tColor);
                         if (dice[Board.X][1] != 0)
                                 paintDie(g, size, x1, y, dice[Board.X][1], cColor, cColor, tColor);
                 }
                 if (ae != null && ae.getType() == Type.CantMove && ae.getWho() == Board.X) {
                         g.setColor(Color.red);
                         y = y + size + size/2;
                         g.drawLine(x0, y, x1+size, y-size*2);
                         g.drawLine(x0-1, y, x1+size-1, y-size*2);
                         g.drawLine(x0, y-size*2, x1+size, y);
                         g.drawLine(x0-1, y-size*2, x1+size-1, y);
                         
                 }
                 // Do white dice
                 Color luColor = wCheckerColor;
                 Color ldColor = wCheckerColor;
                 Color ruColor = wCheckerColor;
                 Color rdColor = wCheckerColor;
                 tColor = wTrimColor;
 
                 if (diceUsed.length == 2) {
                         if (diceUsed[0]) {
                                 luColor = gColor;
                                 ldColor = gColor;
                         }
                         if (diceUsed[1]) {
                                 ruColor = gColor;
                                 rdColor = gColor;
                         }
                 }
                 if (diceUsed.length == 4) {
                         if (diceUsed[3])
                                 luColor = gColor;
                         if (diceUsed[2])
                                 ldColor = gColor;
                         if (diceUsed[1])
                                 ruColor = gColor;
                         if (diceUsed[0])
                                 rdColor = gColor;
                 }
                 x0 = this.getPointX(4);
                 x1 = x0+bs.c15;
                 y = bs.h/2-bs.c2;
                 size = bs.dieSize;
                 if (ae != null) {
                         if (ae.getType() == Type.Roll) {
                                 AnimateEventDiceRoll aedr = (AnimateEventDiceRoll)ae;
                                 if (aedr.getWho() == Board.O){
                                         int miniSize = bs.barWidth/2;
                                         int miniX = bs.w/2-bs.barWidth/2;
                                         int miniY = bs.h-miniSize-2;
                                         int[] pos = aedr.getDiceParms(miniX, miniX+miniSize, miniY, miniSize, x0, x1, y, bs.dieSize);
                                         x0 = pos[0];
                                         x1 = pos[1];
                                         y = pos[2];
                                         size = pos[3];
                                         dice[Board.O][0] = aedr.dice[0];
                                         dice[Board.O][1] = aedr.dice[1];
                                 }
                         }
                         if (ae.getType() == Type.CantMove) {
                                 luColor = Color.red;
                                 ldColor = Color.red;
                                 ruColor = Color.red;
                                 rdColor = Color.red;
                         }
                         if (ae.getType() == Type.FirstRoll) {
                                 AnimateEventFirstRoll aefr = (AnimateEventFirstRoll)ae;
                                 // Calculate the white die
                                 int miniSize = bs.barWidth/2;
                                 int miniX = bs.w/2-bs.barWidth/2;
                                 int miniY = bs.h-miniSize-2;
                                 x0 = (int)(((x0-miniX)*ae.offset)+miniX);
                                 y =  (int)(((y-miniY)*ae.offset)+miniY);
                                 size = (int)(((bs.dieSize-miniSize)*ae.offset)+miniSize);
                                 // We have to paint the die here because Board.X is 0
                                 paintDie(g, size, x0, y, aefr.getWhiteDie(),  luColor, ldColor, tColor);
 
                         }
                         if (ae instanceof AnimateEventResign) {
                                 luColor = makeTranslucent(luColor);
                                 ldColor = makeTranslucent(ldColor);
                                 ruColor = makeTranslucent(ruColor);
                                 rdColor = makeTranslucent(rdColor);
                                 tColor = makeTranslucent(tColor);
                         }
                 }
                 if (ae == null || ae.getType() != Type.FirstRoll) {
                         if (dice[Board.O][0] != 0)
                                 paintDie(g, size, x0, y, dice[Board.O][0], luColor, ldColor, tColor);
                         if (dice[Board.O][1] != 0)
                                 paintDie(g, size, x1, y, dice[Board.O][1], ruColor, rdColor, tColor);
                 }
                 if (ae != null && ae.getType() == Type.CantMove && ae.getWho() == Board.O){
                         g.setColor(Color.red);
                         y = y + size + size/2;
                         g.drawLine(x0, y, x1+size, y-size*2);
                         g.drawLine(x0-1, y, x1+size-1, y-size*2);
                         g.drawLine(x0, y-size*2, x1+size, y);
                         g.drawLine(x0-1, y-size*2, x1+size-1, y);
                 }
         }
         
         /*  0   4
          *  1 3 5
          *  2   6
          */
         private final static boolean[][] diePoints = new boolean[][] {
                 {false,false,false,false,false,false,false},        // 0
                 {false,false,false,true,false,false,false},                // 1
                 {false,false,true,false,true,false,false},                // 2
                 {false,false,true,true,true,false,false},                // 3
                 {true,false,true,false,true,false,true},                // 4
                 {true,false,true,true,true,false,true},                        // 5
                 {true,true,true,false,true,true,true},                        // 6
         };
         private        final static double y0m = 25.0/100.0;
         private        final static double y2m = 75.0/100.0;
 
         /** Paint one die on the board
          * @param g The graphics to use
          * @param dieSize The number of pixels to draw the die in
          * @param x The left side of the die
          * @param y The bottom of the die
          * @param n The number of dots to draw (value of the die)
          * @param uColor The top half color
          * @param dColor The bottom half color
          * @param tColor The trim (border) color
          */
         private void paintDie(Graphics g, int dieSize,
                                                   int x, int y, int n, Color uColor, Color dColor, Color tColor) {
                 int dotSize = dieSize/4;
                 int dotSize2 = dotSize/2;
                 g.setColor(uColor);
                 g.setClip(x-1, y+0, dieSize+1, dieSize/2+1);
                 g.fillRoundRect(x, y, dieSize, dieSize, dieSize/4, dieSize/4);
                 g.setColor(dColor);
                 g.setClip(x-1, y+dieSize/2+1, dieSize+1, dieSize/2+1);
                 g.fillRoundRect(x, y, dieSize, dieSize, dieSize/4, dieSize/4);
                 g.setClip(null);
                 g.setColor(tColor);
                 g.drawRoundRect(x, y, dieSize, dieSize, dieSize/4, dieSize/4);
                 int dX[] = new int[3];
                 int dY[] = new int[3];
                 dX[0] = (int)(x + ((double)dieSize * y0m)) - dotSize2;
                 dX[1] = (int)(x + ((double)dieSize / 2.0)) - dotSize2;
                 dX[2] = (int)(x + ((double)dieSize * y2m)) - dotSize2;
                 dY[0] = (int)(y + ((double)dieSize * y0m)) - dotSize2;
                 dY[1] = (int)(y + ((double)dieSize / 2.0)) - dotSize2;
                 dY[2] = (int)(y + ((double)dieSize * y2m)) - dotSize2;
                 /*  0   4
                  *  1 3 5
                  *  2   6
                  */
                 if (diePoints[n][0])
                         g.fillArc(dX[0], dY[0], dotSize, dotSize, 0, 360);
                 if (diePoints[n][1])
                         g.fillArc(dX[0], dY[1], dotSize, dotSize, 0, 360);
                 if (diePoints[n][2])
                         g.fillArc(dX[0], dY[2], dotSize, dotSize, 0, 360);
                 if (diePoints[n][3])
                         g.fillArc(dX[1], dY[1], dotSize, dotSize, 0, 360);
                 if (diePoints[n][4])
                         g.fillArc(dX[2], dY[0], dotSize, dotSize, 0, 360);
                 if (diePoints[n][5])
                         g.fillArc(dX[2], dY[1], dotSize, dotSize, 0, 360);
                 if (diePoints[n][6])
                         g.fillArc(dX[2], dY[2], dotSize, dotSize, 0, 360);
         }
 
 
         Font        doubleCubeFont = new Font("Arial", Font.BOLD, 18);
 
         private void paintDoubleCube(Graphics g) {
                 Point p = getDoubleCubeXY();
                 int w2 = getDoubleCubeWidth()/2;
                 int x = p.x - w2;
                 int y = p.y - w2;
                 AnimateEvent ae = animateManager.getHeadEvent();
                 if (ae != null) {
                         AnimateEventDouble aed = null;
                         if (ae.getType() == Type.Double) {
                                 aed = (AnimateEventDouble)ae;
                                 if (properties.isDEBUG_ShowAnimatePath()) {
                                         aed.calculate(board);
                                         g.setColor(Color.blue);
                                         for (double d = 0.0; d <= 1.0; d += 0.002) {
                                                 int pp[] = aed.getXY(d);
                                                 g.drawRect(pp[0]-1, pp[1]-1, 3, 3);
                                         }
                                         g.setColor(Color.green);
                                                 for (int i=0; i<aed.x.length; i++ ) {
                                                         g.drawRect((int)aed.x[i]-3, (int)aed.y[i]-3, 6, 6);                
                                                 }
                                 }
                                 int[] xy = aed.getXY(aed.getOffset());
                                 x = xy[0] - w2;
                                 y = xy[1] - w2;
                         }
                 }
                 //logger.info("paintdoubleCube x/y = " + x + "/" + y);
                 int cubeValue = board.getCube();
                 int w = getDoubleCubeWidth();
                 if (board.getWasDoubled()[0] || board.getWasDoubled()[1]) {
                         cubeValue *= 2;
                         if (cubeValue > 64)
                                 cubeValue = 1;
                 }
                 g.setColor(Color.white);
                 g.fillRoundRect(x, y, w, w, w/4, w/4);
                 g.setColor(Color.black);
                 g.drawRoundRect(x, y, w, w, w/4, w/4);
                 g.setColor(Color.yellow);
                 if (this.board.isYourTurnToRollOrDouble()) {
                         g.drawRoundRect(x, y, w, w, w/4, w/4);
                         g.drawRoundRect(x-1, y-1, w+2, w+2, w/4+1, w/4+1);
                 }
 
                 g.setColor(Color.black);
                 g.setFont(doubleCubeFont);
                 FontMetrics fm = g.getFontMetrics();
                 String s = "" + cubeValue; 
                 int sw = fm.stringWidth(s);
                 x = x + w/2 - sw/2;
                 y = y + w/2 - fm.getAscent()/2 + fm.getAscent();
                 g.drawString(s, x, y);
         }
 
         protected Point getDoubleCubeXY() {
                 int w = getDoubleCubeWidth();
                 int x = bs.c15/2;
                 int y = bs.h/2;
                 if (board.getHasCube() == Board.O)
                         y = 0 + w;
                 if (board.getHasCube() == Board.X)
                         y = bs.h - w*2;
                 if (board.getWasDoubled()[0]) {
                         logger.info("wasDoubled[0]");
                         return(getDoubleCubePushXY());
                 }
                 if (board.getWasDoubled()[1]) {
                         logger.info("wasDoubled[1]");
                         return(getDoubleCubePushXY());
                 }
                 return(new Point(x,y));
         }
 
         // XXX
         protected Point getDoubleCubePushXY() {
                 int[] bp = board.getPoints();
                 //final int[] points0 = new int[] {8,  9,10, 5, 4, 3, 2,11,12, 6, 1};
                 //final int[] points1 = new int[] {17,16,15,20,21,22,23,14,18,13,24};
                 final int[] points1 = new int[] { 4, 5, 3, 2, 8, 9,10,11, 1, 7,12,19};
                 final int[] points0 = new int[] {21,20,22,23,17,16,15,14,24,18,13,6};
                 int[] check = points1;
                 int dir = Board.turnO;
                 AnimateEvent ae = animateManager.getHeadEvent();
                 if (ae != null) {
                         AnimateEventDouble aed;
                         if (ae.getType() == Type.Double) {
                                 aed = (AnimateEventDouble)ae;
                                 board.setWasDoubled(aed.getWhoDoubled());
                                 logger.info("(aed) set board.wasdoubled(" + Board.getXOAsText(aed.getWhoDoubled()) + ")");
 /*                                if (aed.getWhoDoubled() == Board.turnO) {
                                         check = points0;
                                         dir = Board.turnX;
                                         logger.info("(aed) use other points1;");
                                 }
 */                        }
                 }
                 logger.info("wasDoubled[0/1] = " + board.getWasDoubled()[0] + "/" + board.getWasDoubled()[1] + " dir = " + Board.getTurnAsText(board.getDirection()));
                 if ((board.getWasDoubled()[Board.X] && board.getDirection() == Board.turnO)
                  || (board.getWasDoubled()[Board.O] && board.getDirection() == Board.turnX)) {
                         check = points0;
                         dir = Board.turnX;
                         logger.info("use other points0;");
                 }
                 int f = 0;
                 int h = 0;
                 for (h = 0; h < 2; h++) {
                         for (int i : check) {
                                 if (bp[i] == 0) {
                                         f = i;
                                         break;
                                 }
                         }
                         if (f != 0)
                                 break;
                 }
                 int x = getPointX(f);
                 logger.info("f = " + f + " h = " + h);
                 x += bs.c2;
                 int y = bs.checkerSize * (h+1) + getDoubleCubeWidth()/2;
                 if (dir == Board.turnX) {
                         y = bs.h - y; // - getDoubleCubeWidth();
                         logger.info("dir = turnX");
                 }
                 //logger.info("push x/y = " + x + "/" + y);
                 return(new Point(x,y));
         }
 
         protected int getDoubleCubeWidth() {
                 return((bs.c15 + bs.dieSize) / 2);
         }
 
         Font        pointNumbersFont = new Font("Arial", Font.BOLD, 11);
         private void paintPointNumbers(Graphics g) {
                 if (!this.properties.isShowPointNumbers())
                         return;
                 int p;
                 int x,y;
                 String s;
                 int f = 0;
                 int t;
                 boolean reverse = board.getDirection() > 0;
                 g.setFont(pointNumbersFont);
                 FontMetrics fm = g.getFontMetrics();
                 for (p=1; p<=12; p++) {
                         f = p;
                         if (reverse)
                                 f = 25-p;
                         s = "" + f;
                         int sw = fm.stringWidth(s);
                         x = getPointX(p) + bs.c2 - sw/2;
                         y = bs.h - bs.c2 + fm.getAscent()/2;
                         t = board.getPoints()[f];
                         if (t < -5 || t > 5)
                                 y = this.getNthCheckerY(f, 5) + bs.c2 + fm.getAscent()/2;
 //                        g.setColor(Color.red);
 //                        g.drawRect(x-1, y-1, 3, 3);
                         if (t > 0)
                                 g.setColor(Color.white);
                         else
                                 g.setColor(Color.blue);
                         g.drawString(s, x, y);
                 }
                 for (p=13; p<=24; p++) {
                         f = p;
                         if (reverse)
                                 f = 25-p;
                         s = "" + f;
                         int sw = fm.stringWidth(s);
                         x = getPointX(p) + bs.c2 - sw/2;
                         y = bs.c2 + fm.getAscent()/2;
                         t = board.getPoints()[f];
                         if (t < -5 || t > 5)
                                 y = this.getNthCheckerY(f, 5) + bs.c2 + fm.getAscent()/2;
                         if (t < -10 || t > 10)
                                 y = this.getNthCheckerY(f, 10) + bs.c2 + fm.getAscent()/2;
                                 
                         if (t > 0)
                                 g.setColor(Color.white);
                         else
                                 g.setColor(Color.blue);
                         g.drawString(s, x, y);
                 }
         }
 
         /** Callback from AnimationManager to refresh the whole BoardTab
          */
         public void        updateBoardTab() {
                 this.boardTab.updateBoard();
         }
 
         /** Given a Color, return a translucent copy of that color
          * @param c The color to translucify
          * @return
          */
         private Color        makeTranslucent(Color c) {
                 return(new Color(c.getRed(), c.getGreen(), c.getBlue(), 48));
         }
 
         private        static         final Color        endColor = new Color(20,255,20,150);
         private void        paintAnimatedCheckers(Graphics g) {
                 AnimateEvent ae = animateManager.getHeadEvent();
                 if (ae != null) {
                         AnimateEventMove aem = null;
                         if (ae.getType() == Type.Move) {
                                 aem = (AnimateEventMove)ae;
                                 if (properties.isDEBUG_ShowAnimatePath()) {
                                         aem.calculate();
                                         g.setColor(Color.blue);
                                         for (double d = 0.0; d <= 1.0; d += 0.002) {
                                                 int p[] = aem.getXY(d);
                                                 g.drawRect(p[0]-1, p[1]-1, 3, 3);
                                         }
                                         g.setColor(Color.green);
                                         for (int i=0; i<aem.x.length; i++ ) {
                                                 g.drawRect((int)aem.x[i]-3, (int)aem.y[i]-3, 6, 6);                
                                         }
                                 }
                                 g.setColor(aem.getColor(aem.getOffset()));
                                 int[] xy = aem.getXY(aem.getOffset());
                                 g.fillArc(xy[0]-bs.c2, xy[1]-bs.c2, bs.checkerSize, bs.checkerSize, 0, 360);
                         }
                 }
                 if (animateManager.extraCheckersIndex != 0) {
                         if (DEBUGa) {
                                 logger.debug("extraCheckers: " + (animateManager.extraCheckersIndex/2));
                                 for (int i=0; i<animateManager.extraCheckersIndex; i+=2)
                                         logger.debug("checker[" + i + "]=" + animateManager.extraCheckers[i] + "/" + animateManager.extraCheckers[i+1]);
                         }
                         g.setColor(endColor);
                         for (int i=0; i<animateManager.extraCheckersIndex; i+=2) {
                                 if (animateManager.extraCheckers[i] == Board.Home) {
                                         paintCheckerInHome(g, animateManager.extraCheckersWho, animateManager.extraCheckers[i+1], endColor, endColor);
                                 //} else if (animateManager.extraCheckers[i] == Board.Bar) {
                                         
                                 } else {
                                         int x = getPointX(animateManager.extraCheckers[i]);
                                         int y = this.getNthCheckerY(animateManager.extraCheckers[i], animateManager.extraCheckers[i+1]);
                                         g.fillArc(x, y, bs.checkerSize, bs.checkerSize, 0, 360);
                                 }
                         }
                 }
 //                g.setColor(Color.black);
 //                g.fillArc(xy[0]-bs.c2, xy[1]-bs.c2, bs.checkerSize, bs.checkerSize, 0, 360);
         }
         
         private void paintResign(Graphics g) {
                 AnimateEvent ae = this.animateManager.getHeadEvent();
                 if (ae != null && ae instanceof AnimateEventResign) {        // ().getType() == Type.Resign || ae.getType() == Type.PleaseAcceptOrRejectResign)) {
                         AnimateEventResign aer = (AnimateEventResign)ae;
                         int flagSize = (int)(bs.checkerSize*2.5);
                         int miniSize = bs.barWidth/2;
                         int miniX = bs.w/2-bs.barWidth/2;
                         int miniY = 0;        // bs.h-miniSize-2;
 //                        int y = bs.h/2-bs.c2;
                         int y = (int)(bs.h-bs.pointHeight-(flagSize*0.75));
                         int x = this.getPointX(4); // - bs.c15;
                         if (aer.getWho() == Board.O){
                                 miniY = bs.h-miniSize-2;
                                 x = this.getPointX(9) - bs.c15;
                                 y = (int)(0+bs.pointHeight-(flagSize*0.25));
                         }
                         int[] pos = aer.getFlagParms(miniX, miniY, miniSize, x, y, flagSize);
                         g.drawImage(aer.getIcon().getImage(), pos[AnimateEventResign.X], pos[AnimateEventResign.Y],
                                         pos[AnimateEventResign.WIDTH], pos[AnimateEventResign.HEIGHT], null);
                         Font f = doubleCubeFont;                // XXX: Should calculate our own font, use this for now
                         g.setFont(f);
                         g.setColor(Color.black);
                         g.drawString("" + aer.getResigningPoints(), 
                                         (int)(pos[AnimateEventResign.X]+pos[AnimateEventResign.WIDTH]*0.25), 
                                         (int)(pos[AnimateEventResign.Y]+pos[AnimateEventResign.HEIGHT]*0.30));
                         if (ae instanceof AnimateEventRejectResign) {
                                 g.setColor(Color.red);
                                 g.drawLine(pos[AnimateEventResign.X],
                                                    pos[AnimateEventResign.Y],
                                                    pos[AnimateEventResign.X]+pos[AnimateEventResign.WIDTH],
                                                    pos[AnimateEventResign.Y]+pos[AnimateEventResign.HEIGHT]);
                                 g.drawLine(pos[AnimateEventResign.X]+1,
                                                    pos[AnimateEventResign.Y],
                                                    pos[AnimateEventResign.X]+pos[AnimateEventResign.WIDTH]+1,
                                                    pos[AnimateEventResign.Y]+pos[AnimateEventResign.HEIGHT]);
                                 if (ae.getOffset() > 0.5) {
                                         g.drawLine(pos[AnimateEventResign.X]+pos[AnimateEventResign.WIDTH],
                                                         pos[AnimateEventResign.Y],
                                                         pos[AnimateEventResign.X],
                                                         pos[AnimateEventResign.Y]+pos[AnimateEventResign.HEIGHT]);
                                         g.drawLine(pos[AnimateEventResign.X]+pos[AnimateEventResign.WIDTH]+1,
                                                         pos[AnimateEventResign.Y],
                                                         pos[AnimateEventResign.X]+1,
                                                         pos[AnimateEventResign.Y]+pos[AnimateEventResign.HEIGHT]);
                                 }
                         } else if (ae instanceof AnimateEventAcceptAndWin) {
                                 AnimateEventAcceptAndWin aeaaw = (AnimateEventAcceptAndWin)ae;
                                 pos = aeaaw.getFlagParms(miniX, miniY, miniSize, x, y, flagSize);
                                 g.drawImage(aer.getIcon().getImage(), pos[AnimateEventResign.X], pos[AnimateEventResign.Y],
                                                 pos[AnimateEventResign.WIDTH], pos[AnimateEventResign.HEIGHT], null);
                                 
                         }
                 }
         }
 }