Improve hard computer skill & refactor code

Author: sloenthran

src/main/java/pl/nogacz/chess/application/BoardPoint.java

@@ -20,9 +20,25 @@ public int calculateBoard() {
         int blackPoint = 0;
 
         for(Map.Entry<Coordinates, PawnClass> entry : cacheBoard.entrySet()) {
+            PawnMoves pawnMoves = new PawnMoves(entry.getValue(), entry.getKey());
+
             if(entry.getValue().getColor().isWhite()) {
+                if(pawnMoves.getPossibleCheck().size() > 0) {
+                    whitePoint += 100;
+                    blackPoint -= 100;
+                } else if(pawnMoves.getPossibleKick().size() > 0) {
+                    whitePoint += 20;
+                }
+
                 whitePoint += calculatePawn(entry.getKey(), entry.getValue());
             } else {
+                if(pawnMoves.getPossibleCheck().size() > 0) {
+                    blackPoint += 100;
+                    whitePoint -= 100;
+                } else if(pawnMoves.getPossibleKick().size() > 0) {
+                    blackPoint += 20;
+                }
+
                 blackPoint += calculatePawn(entry.getKey(), entry.getValue());
             }
         }
@@ -33,15 +49,7 @@ public int calculateBoard() {
     private int calculatePawn(Coordinates coordinates, PawnClass pawn) {
         int point = 1;
 
-        PawnMoves pawnMoves = new PawnMoves(pawn, coordinates);
-
-        if(pawnMoves.getPossibleCheck().size() > 0) {
-            point += 100;
-        } else if(pawnMoves.getPossibleKick().size() > 0) {
-            point += 20;
-        }
-
-        if(pawn.getColor().isWhite() && pawn.getPawn() == Pawn.PAWN && coordinates.getY() > 4) {
+        if(pawn.getColor().isWhite()) {
             point++;
         } else if(pawn.getColor().isBlack() && pawn.getPawn() == Pawn.PAWN && coordinates.getY() < 4) {
             point++;

src/main/java/pl/nogacz/chess/application/Computer.java

@@ -22,7 +22,6 @@ public class Computer {
 
     private Set<Coordinates> possibleKick = new HashSet<>();
     private Set<Coordinates> possibleMoves = new HashSet<>();
-    private Set<Coordinates> possibleKickAndNotIsEnemyKickMe = new HashSet<>();
 
     private BoardPoint boardPoint = new BoardPoint();
 
@@ -82,7 +81,6 @@ public void getGameData() {
 
         possibleMoves.clear();
         possibleKick.clear();
-        possibleKickAndNotIsEnemyKickMe.clear();
 
         for (Map.Entry<Coordinates, PawnClass> entry : cacheBoard.entrySet()) {
             if (entry.getValue().getColor().isBlack()) {
@@ -107,28 +105,23 @@ public Coordinates choosePawn() {
     }
 
     private Coordinates choosePawnEasy() {
-        Object[] object = null;
-
         if (possibleMoves.size() > 0) {
-            object = possibleMoves.toArray();
+            return selectRandom(possibleMoves);
         } else if (possibleKick.size() > 0) {
-            object = possibleKick.toArray();
-
+            return selectRandom(possibleKick);
         }
 
-        return (Coordinates) object[random.nextInt(object.length)];
+        return null;
     }
 
     private Coordinates choosePawnNormal() {
-        Object[] object = null;
-
         if (possibleKick.size() > 0) {
-            object = possibleKick.toArray();
+            return selectRandom(possibleKick);
         } else if (possibleMoves.size() > 0) {
-            object = possibleMoves.toArray();
+            return selectRandom(possibleMoves);
         }
 
-        return (Coordinates) object[random.nextInt(object.length)];
+        return null;
     }
 
     private Coordinates choosePawnHard() {
@@ -141,47 +134,30 @@ private Coordinates choosePawnHard() {
         Set<Coordinates> cachePossiblePawn = new HashSet<>();
 
         for(Coordinates coordinates : cachePawn) {
-
             PawnMoves moves = new PawnMoves(Board.getPawn(coordinates), coordinates);
 
             Set<Coordinates> cacheMoves = new HashSet<>();
             cacheMoves.addAll(moves.getPossibleKick());
             cacheMoves.addAll(moves.getPossibleMoves());
 
-            for(Coordinates moveCoordinates : cacheMoves) {
-                PawnClass oldPawn = Board.addPawnWithoutDesign(moveCoordinates, Board.getPawn(coordinates));
-
-                int point = boardPoint.calculateBoard();
-
-                if(point > minNumber) {
-                    minNumber = point;
-                }
-
-                Board.removePawnWithoutDesign(moveCoordinates);
+            int point = getMinNumber(cacheMoves, Board.getPawn(coordinates));
 
-                if (oldPawn != null) {
-                    Board.addPawnWithoutDesign(moveCoordinates, oldPawn);
-                }
+            if(point > minNumber) {
+                minNumber = point;
             }
+        }
 
-            for(Coordinates moveCoordinates : cacheMoves) {
-                PawnClass oldPawn = Board.addPawnWithoutDesign(moveCoordinates, Board.getPawn(coordinates));
-
-                int point = boardPoint.calculateBoard();
-
-                if(point == minNumber) {
-                    cachePossiblePawn.add(coordinates);
-                }
+        for(Coordinates coordinates : cachePawn) {
+            PawnMoves moves = new PawnMoves(Board.getPawn(coordinates), coordinates);
 
-                Board.removePawnWithoutDesign(moveCoordinates);
+            Set<Coordinates> cacheMoves = new HashSet<>();
+            cacheMoves.addAll(moves.getPossibleKick());
+            cacheMoves.addAll(moves.getPossibleMoves());
 
-                if (oldPawn != null) {
-                    Board.addPawnWithoutDesign(moveCoordinates, oldPawn);
-                }
-            }
+            cachePossiblePawn.addAll(getListWithOnlyMinNumber(cacheMoves, Board.getPawn(coordinates), minNumber));
         }
 
-        return (Coordinates) cachePossiblePawn.toArray()[random.nextInt(cachePossiblePawn.size())];
+        return selectRandom(cachePossiblePawn);
     }
 
     public Coordinates chooseMove(Coordinates coordinates) {
@@ -197,11 +173,9 @@ private Coordinates chooseMoveEasy(Coordinates coordinates) {
         PawnMoves moves = new PawnMoves(pawn, coordinates);
 
         if (moves.getPossibleMoves().size() > 0) {
-            Object[] object = moves.getPossibleMoves().toArray();
-            return (Coordinates) object[random.nextInt(object.length)];
+            return selectRandom(moves.getPossibleMoves());
         } else if (moves.getPossibleKick().size() > 0) {
-            Object[] object = moves.getPossibleKick().toArray();
-            return (Coordinates) object[random.nextInt(object.length)];
+            return selectRandom(moves.getPossibleKick());
         }
 
         return null;
@@ -212,11 +186,9 @@ private Coordinates chooseMoveNormal(Coordinates coordinates) {
         PawnMoves moves = new PawnMoves(pawn, coordinates);
 
         if (moves.getPossibleKick().size() > 0) {
-            Object[] object = moves.getPossibleKick().toArray();
-            return (Coordinates) object[random.nextInt(object.length)];
+            return selectRandom(moves.getPossibleKick());
         } else if (moves.getPossibleMoves().size() > 0) {
-            Object[] object = moves.getPossibleMoves().toArray();
-            return (Coordinates) object[random.nextInt(object.length)];
+            return selectRandom(moves.getPossibleMoves());
         }
 
         return null;
@@ -226,51 +198,63 @@ private Coordinates chooseMoveHard(Coordinates coordinates) {
         PawnClass pawn = Board.getPawn(coordinates);
         PawnMoves moves = new PawnMoves(pawn, coordinates);
 
-        Object[] object = null;
+        Set<Coordinates> possibleMove = new HashSet<>();
+        possibleMove.addAll(moves.getPossibleMoves());
+        possibleMove.addAll(moves.getPossibleKick());
+
+        int minNumber = getMinNumber(possibleMove, pawn);
+
+        Set<Coordinates> test = getListWithOnlyMinNumber(possibleMove, pawn, minNumber);
+
+        return selectRandom(test);
+    }
+
+    private int getMinNumber(Set<Coordinates> list, PawnClass actualPawn) {
+        int minNumber = -10000;
 
-        if(moves.getPossibleKick().size() > 0) {
-            moves.getPossibleKick().forEach(entry -> checkEnemyKickField(entry, pawn));
+        for(Coordinates coordinates : list) {
+            PawnClass oldPawn = Board.addPawnWithoutDesign(coordinates, actualPawn);
 
-            if(possibleKickAndNotIsEnemyKickMe.size() > 0) {
-                object = possibleKickAndNotIsEnemyKickMe.toArray();
-            } else {
-                object = moves.getPossibleKick().toArray();
+            int point = boardPoint.calculateBoard();
+
+            if(point > minNumber) {
+                minNumber = point;
             }
 
-            return (Coordinates) object[random.nextInt(object.length)];
-        } else if(moves.getPossibleMoves().size() > 0) {
-            object = moves.getPossibleMoves().toArray();
-            return (Coordinates) object[random.nextInt(object.length)];
+            Board.removePawnWithoutDesign(coordinates);
+
+            if (oldPawn != null) {
+                Board.addPawnWithoutDesign(coordinates, oldPawn);
+            }
         }
 
-        return null;
+        return minNumber;
     }
 
-    public Coordinates selectRandom(Set<Coordinates> list) {
-        Object[] object = list.toArray();
-        return (Coordinates) object[random.nextInt(object.length)];
-    }
+    private Set<Coordinates> getListWithOnlyMinNumber(Set<Coordinates> list, PawnClass actualPawn, int minNumber) {
+        Set<Coordinates> returnList = new HashSet<>();
 
-    private void checkEnemyKickField(Coordinates coordinates, PawnClass actualPawn) {
-        PawnClass oldPawn = Board.addPawnWithoutDesign(coordinates, actualPawn);
+        for(Coordinates coordinates : list) {
+            PawnClass oldPawn = Board.addPawnWithoutDesign(coordinates, actualPawn);
 
-        Set<Coordinates> possibleEnemyKick = new HashSet<>();
+            int point = boardPoint.calculateBoard();
 
-        for (Map.Entry<Coordinates, PawnClass> entry : Board.getBoard().entrySet()) {
-            if (!Board.isThisSameColor(entry.getKey(), actualPawn.getColor()) && !entry.getValue().getPawn().isKing()) {
-                PawnMoves moves = new PawnMoves(entry.getValue(), entry.getKey());
-                possibleEnemyKick.addAll(moves.getPossibleKick());
+            if(point == minNumber) {
+                returnList.add(coordinates);
             }
-        }
 
-        Board.removePawnWithoutDesign(coordinates);
+            Board.removePawnWithoutDesign(coordinates);
 
-        if(oldPawn != null) {
-            Board.addPawnWithoutDesign(coordinates, oldPawn);
+            if (oldPawn != null) {
+                Board.addPawnWithoutDesign(coordinates, oldPawn);
+            }
         }
 
-        if(!possibleEnemyKick.contains(coordinates)) {
-            possibleKickAndNotIsEnemyKickMe.add(coordinates);
-        }
+        return returnList;
+    }
+
+    public Coordinates selectRandom(Set<Coordinates> list) {
+        Object[] object = list.toArray();
+        return (Coordinates) object[random.nextInt(object.length)];
     }
 }