--- a/org/homelinux/largo/checkers/KIBoard.java
+++ b/org/homelinux/largo/checkers/KIBoard.java
@@ -9,196 +9,196 @@
import org.homelinux.largo.games.board.checkersboard.CheckersBoard;
public class KIBoard extends CheckersBoard {
- static final long serialVersionUID = 1L;
- static final int game_const = 500;
+ static final long serialVersionUID = 1L;
+ static final int game_const = 500;
- protected boolean SIMU_DEBUG = false;
- private boolean negate_estimation = false;
+ protected boolean SIMU_DEBUG = false;
+ private boolean negate_estimation = false;
- private Move bestMove;
- private int desired_depth;
+ private Move bestMove;
+ private int desired_depth;
- public KIBoard(int w, int h) {
- super(w, h);
- desired_depth = -1;
- }
+ public KIBoard(int w, int h) {
+ super(w, h);
+ desired_depth = -1;
+ }
- /**
- * Set the current DEBUG-Level: simu: print all valid, simulated moves undo:
- * print all undos
- */
- public void setDebug(boolean simu, boolean undo) {
- SIMU_DEBUG = simu;
- UNDO_DEBUG = undo;
- }
+ /**
+ * Set the current DEBUG-Level: simu: print all valid, simulated moves undo:
+ * print all undos
+ */
+ public void setDebug(boolean simu, boolean undo) {
+ SIMU_DEBUG = simu;
+ UNDO_DEBUG = undo;
+ }
- public boolean simu_debug() {
- return SIMU_DEBUG;
- }
+ public boolean simu_debug() {
+ return SIMU_DEBUG;
+ }
- public boolean undo_debug() {
- return UNDO_DEBUG;
- }
+ public boolean undo_debug() {
+ return UNDO_DEBUG;
+ }
- /**
- * This function flips the sides: Player A maximizes and Player B minimizes
- */
- public void negateEstimation(boolean b) {
- negate_estimation = b;
- }
+ /**
+ * This function flips the sides: Player A maximizes and Player B minimizes
+ */
+ public void negateEstimation(boolean b) {
+ negate_estimation = b;
+ }
- /**
- * The Minimax-Algorithm works for TWO-PLAYER Games Player A minimizes,
- * Player B maximizes
- */
- public int estimateFunction() {
- int i;
- int white = 0;
- int black = 0;
+ /**
+ * The Minimax-Algorithm works for TWO-PLAYER Games Player A minimizes,
+ * Player B maximizes
+ */
+ public int estimateFunction() {
+ int i;
+ int white = 0;
+ int black = 0;
- for (i = 0; i < 64; i++) {
- if (isWhite(i))
- white += getValue(i);
- if (isBlack(i))
- black += getValue(i);
- }
+ for (i = 0; i < 64; i++) {
+ if (isWhite(i))
+ white += getValue(i);
+ if (isBlack(i))
+ black += getValue(i);
+ }
- /**
- * solves ticket #3
- */
- if (negate_estimation)
- return white - black;
+ /**
+ * solves ticket #3
+ */
+ if (negate_estimation)
+ return white - black;
- return black - white;
- }
+ return black - white;
+ }
- /**
- * simulates and returns the next possible move for a Player or null, when
- * no more moves are possible. The Turn will flip automatically if
- * "simulate(...)" finds a valid move.
- */
- Move simulate(int t, int o) {
- Move move = null;
- int value;
+ /**
+ * simulates and returns the next possible move for a Player or null, when
+ * no more moves are possible. The Turn will flip automatically if
+ * "simulate(...)" finds a valid move.
+ */
+ Move simulate(int t, int o) {
+ Move move = null;
+ int value;
- if (validTurn(o)) {
- while (t < 64) {
- if (!simulateMove(t, o)) {
- t++;
- continue;
- }
+ if (validTurn(o)) {
+ while (t < 64) {
+ if (!simulateMove(t, o)) {
+ t++;
+ continue;
+ }
- value = estimateFunction();
- move = new Move(value, t, o);
+ value = estimateFunction();
+ move = new Move(value, t, o);
- /* Flip Sides */
- setBlacksTurn(!isBlacksTurn());
- return move;
- }
- }
- return null;
- }
+ /* Flip Sides */
+ setBlacksTurn(!isBlacksTurn());
+ return move;
+ }
+ }
+ return null;
+ }
- /**
- * AlphaBeta-Algorithm: the Maximizer
- */
- int max_alpha_beta(int depth, int alpha, int beta) {
- int moveValue;
- int o, t;
- Move move = null;
+ /**
+ * AlphaBeta-Algorithm: the Maximizer
+ */
+ int max_alpha_beta(int depth, int alpha, int beta) {
+ int moveValue;
+ int o, t;
+ Move move = null;
- if (desired_depth == -1)
- desired_depth = depth;
+ if (desired_depth == -1)
+ desired_depth = depth;
- for (o = 0; o < 64; o++) {
- t = 0;
- while ((move = simulate(t, o)) != null) {
- /* particular move from black */
- t = move.target;
+ for (o = 0; o < 64; o++) {
+ t = 0;
+ while ((move = simulate(t, o)) != null) {
+ /* particular move from black */
+ t = move.target;
- if (depth == 0 || Math.abs(move.value) > game_const)
- moveValue = move.value;
- else
- /* best next move */
- moveValue = min_alpha_beta(depth - 1, alpha, beta);
+ if (depth == 0 || Math.abs(move.value) > game_const)
+ moveValue = move.value;
+ else
+ /* best next move */
+ moveValue = min_alpha_beta(depth - 1, alpha, beta);
- undo();
- t++;
+ undo();
+ t++;
- if (moveValue >= beta)
- return beta;
+ if (moveValue >= beta)
+ return beta;
- if (moveValue > alpha) {
- alpha = moveValue;
- if (depth == desired_depth)
- bestMove = move;
- }
- }
- }
+ if (moveValue > alpha) {
+ alpha = moveValue;
+ if (depth == desired_depth)
+ bestMove = move;
+ }
+ }
+ }
- return alpha;
- }
+ return alpha;
+ }
- /**
- * AlphaBeta-Algorithm: the Minimizer
- */
- int min_alpha_beta(int depth, int alpha, int beta) {
- int moveValue;
- int o, t;
- Move move = null;
+ /**
+ * AlphaBeta-Algorithm: the Minimizer
+ */
+ int min_alpha_beta(int depth, int alpha, int beta) {
+ int moveValue;
+ int o, t;
+ Move move = null;
- for (o = 0; o < 64; o++) {
- t = 0;
- while ((move = simulate(t, o)) != null) {
- /* particular move from white */
- t = move.target;
+ for (o = 0; o < 64; o++) {
+ t = 0;
+ while ((move = simulate(t, o)) != null) {
+ /* particular move from white */
+ t = move.target;
- if (depth == 0 || Math.abs(move.value) > game_const)
- moveValue = move.value;
- else
- /* best next move */
- moveValue = max_alpha_beta(depth - 1, alpha, beta);
+ if (depth == 0 || Math.abs(move.value) > game_const)
+ moveValue = move.value;
+ else
+ /* best next move */
+ moveValue = max_alpha_beta(depth - 1, alpha, beta);
- undo();
- t++;
+ undo();
+ t++;
- if (moveValue <= alpha)
- return alpha;
+ if (moveValue <= alpha)
+ return alpha;
- if (moveValue < beta)
- beta = moveValue;
- }
- }
+ if (moveValue < beta)
+ beta = moveValue;
+ }
+ }
- return beta;
- }
+ return beta;
+ }
- /**
- * Evaluates the next, best Move after search_depth half-moves. When the
- * Machine has Black, set negateEstimation(false); When the Machine has
- * White, set negateEstimation(true);
- */
- public boolean doBestMove(int search_depth) {
- int value;
+ /**
+ * Evaluates the next, best Move after search_depth half-moves. When the
+ * Machine has Black, set negateEstimation(false); When the Machine has
+ * White, set negateEstimation(true);
+ */
+ public boolean doBestMove(int search_depth) {
+ int value;
- desired_depth = -1;
- bestMove = null;
- value = max_alpha_beta(search_depth, Integer.MIN_VALUE, Integer.MAX_VALUE);
+ desired_depth = -1;
+ bestMove = null;
+ value = max_alpha_beta(search_depth, Integer.MIN_VALUE, Integer.MAX_VALUE);
- if (bestMove == null) {
- System.err.println("Computing once more...");
- value = max_alpha_beta(1, Integer.MIN_VALUE, Integer.MAX_VALUE);
- if (bestMove == null) {
- System.out.println("Finito " + value);
- return false;
- }
- }
+ if (bestMove == null) {
+ System.err.println("Computing once more...");
+ value = max_alpha_beta(1, Integer.MIN_VALUE, Integer.MAX_VALUE);
+ if (bestMove == null) {
+ System.out.println("Finito " + value);
+ return false;
+ }
+ }
- if (doMove(bestMove.target, bestMove.origin)) {
- System.out.println("Next Move");
- return true;
- }
+ if (doMove(bestMove.target, bestMove.origin)) {
+ System.out.println("Next Move");
+ return true;
+ }
- return false;
- }
+ return false;
+ }
}