/* Author: Xan Date: 19th April 2018 Helping someone with this question: https://www.sololearn.com/Discuss/1224356/java-generating-random-numbers-in-a-checkers-board-java Status: Playing around! The original poster had come up with an efficient approach. EXPERIMENTATION at this point. Aim: Checkers / Draughts. Play the computer against itself, with random moves (only using valid moves). */ public class Board { // Define some useful constants, that are used to signify what // a particular square is populated by, if anything. public static final int EMPTY_SQUARE = 0; public static final int COLOUR_WHITE = 2; public static final int COLOUR_BLACK = 4; public static final int REGULAR_PIECE = 8; public static final int QUEEN = 16; public static final int WHITE_CHECKER = REGULAR_PIECE | COLOUR_WHITE; public static final int WHITE_QUEEN = QUEEN | COLOUR_WHITE; public static final int BLACK_CHECKER = REGULAR_PIECE | COLOUR_BLACK; public static final int BLACK_QUEEN = QUEEN | COLOUR_BLACK; // The board storage. What each square is populated by, is represented by an integer. private int checkersBoard[][] = new int[8][8]; // Constructor. Board() { InitialisePieces(); } // Is this a valid move, for this piece? private boolean isValidMove ( int x, int y, int dx, int dy, int piece ) { int to_x = x + dx; int to_y = y + dy; // Check the proposed move is on the board! if ( (to_x < 8) && (to_x >= 0) && (to_y < 8) && (to_y >= 0) ) { // If this is a diagonal move of one (left or right), // and one (up or down) [a standard non-taking move], then... if (Math.abs(dx) == 1 && Math.abs(dy) == 1) { if (checkersBoard[to_x][to_y] == EMPTY_SQUARE) { return true; } } // Else, if this is a diagonal move of two (left or right), // and two (up or down) [a taking move] then... else if (Math.abs(dx) == 2 && Math.abs(dy) == 2) { // See what's in the square // we are 'taking'. int pieceBeingTaken = checkersBoard[x + dx / 2][y + dy / 2]; // White can only take black, and black can only take white... if ( ( isBlack(pieceBeingTaken) && isWhite(piece) ) || ( isWhite(pieceBeingTaken) && isBlack(piece) ) ) { return true; } } // else invalid arguments! } return false; } // Is this piece black? private boolean isBlack(int piece) { return (piece & COLOUR_BLACK) == COLOUR_BLACK; } // Is this piece white? private boolean isWhite(int piece) { return (piece & COLOUR_WHITE) == COLOUR_WHITE; } // Is this piece a queen? private boolean isQueen(int piece) { return (piece & QUEEN) == QUEEN; } // Output this move, if it is valid. private void OutputMoveIfValid ( int x, int y, int dx, int dy, int piece ) { // This should hopefully be set, to black or white, and never // be left unset. String colour_string = "DEBUG_ERROR"; if (isValidMove(x, y, dx, dy, piece)) { if ( isWhite(piece) ) { colour_string = "white"; } else if ( isBlack(piece) ) { colour_string = "black"; } System.out.format("(%d, %d) ==> (%d, %d) is a valid move for %s.\n", x, y, x + dx, y + dy, colour_string); } } // Output valid moves. // // Currently excludes valid // moves based on taking pieces. public void OutputValidMoves() { for (int y = 0; y < 8; y ++) { for (int x = 0; x < 8; x ++) { int pieceToCheck = checkersBoard[x][y]; if (pieceToCheck == WHITE_CHECKER) { // Work out possible move for this white piece. // Regular white pieces can only move down the board (increasing y). // Standard moves: // right + down // left + down OutputMoveIfValid(x, y, +1, +1, pieceToCheck); OutputMoveIfValid(x, y, -1, +1, pieceToCheck); // As if taking pieces: // right + down OutputMoveIfValid(x, y, +2, +2, pieceToCheck); // left + down OutputMoveIfValid(x, y, -2, +2, pieceToCheck); } else if (pieceToCheck == BLACK_CHECKER) { // Work out possible move for this black piece. // Regular black pieces can only move up the board (decreasing y). // Standard moves: // right + up OutputMoveIfValid(x, y, +1, -1, pieceToCheck); // left + up OutputMoveIfValid(x, y, -1, -1, pieceToCheck); // As if taking pieces: // right + up OutputMoveIfValid(x, y, +2, -2, pieceToCheck); // left + up OutputMoveIfValid(x, y, -2, -2, pieceToCheck); } else if ( isQueen(pieceToCheck) ) { // Queens (whether black, or white), can move up or down // the board. // Standard moves: // right + up OutputMoveIfValid(x, y, +1, -1, pieceToCheck); // left + up OutputMoveIfValid(x, y, -1, -1, pieceToCheck); // right + down OutputMoveIfValid(x, y, +1, +1, pieceToCheck); // left + down OutputMoveIfValid(x, y, -1, +1, pieceToCheck); // As if taking pieces: // right + up OutputMoveIfValid(x, y, +2, -2, pieceToCheck); // left + up OutputMoveIfValid(x, y, -2, -2, pieceToCheck); // right + down OutputMoveIfValid(x, y, +2, +2, pieceToCheck); // left + down OutputMoveIfValid(x, y, -2, +2, pieceToCheck); } } } } // Add default start positions // for white. private void InitialiseWhite() { for (int x = 0; x < 8; x += 2) { checkersBoard[x][0] = WHITE_CHECKER; checkersBoard[x][2] = WHITE_CHECKER; } for (int x = 1; x < 8; x += 2) { checkersBoard[x][1] = WHITE_CHECKER; } } // Ensure all squares are empty. private void InitialiseEmpty() { for (int y = 0; y < 8; y ++) { for (int x = 0; x < 8; x ++) { checkersBoard[x][y] = EMPTY_SQUARE; } } } // Add default start positions // for black. private void InitialiseBlack() { for (int x = 0; x < 8; x += 2) { checkersBoard[x][5] = BLACK_CHECKER; checkersBoard[x][7] = BLACK_CHECKER; } for (int x = 1; x < 8; x += 2) { checkersBoard[x][6] = BLACK_CHECKER; } } // Initialise the board. private void InitialisePieces() { // Empty all squares. InitialiseEmpty(); // Then add the pieces (to their default 'start of game' positions). InitialiseWhite(); InitialiseBlack(); } } public class Program { public static void main(String[] args) { // Create a new board. Board board = new Board(); System.out.println("Calculate valid moves (checkers / draughts):\n"); // Output all the valid moves, for this board configuration. board.OutputValidMoves(); } }

Random Checker Moves (Draughts)