Added strategy pattern to check the map

Author: Pedro Geadas

src/com/ai/astar/AStar.java

@@ -1,37 +1,36 @@
 package com.ai.astar;
 
+import com.ai.astar.searchstrategy.DiagonalMapChecker;
+import com.ai.astar.searchstrategy.HorizontalVerticalChecker;
+import com.ai.astar.searchstrategy.MapChecker;
+import com.ai.astar.searchstrategy.NoOpChecker;
+
 import java.util.*;
 
-/**
- * A Star Algorithm
- *
- * @author Marcelo Surriabre
- * @version 2.1, 2017-02-23
- */
 public class AStar {
     private static final int DEFAULT_HV_COST = 10; // Horizontal - Vertical Cost
     private static final int DEFAULT_DIAGONAL_COST = 14;
-    private final int hvCost;
-    private final int diagonalCost;
     private final Node[][] searchArea;
     private final PriorityQueue<Node> openList;
     private final Set<Node> closedSet;
     private final Node initialNode;
     private final Node finalNode;
+    private final MapChecker diagonalsChecker;
+    private final MapChecker hvChecker;
 
-    public AStar(int rows, int cols, Node initialNode, Node finalNode, int hvCost, int diagonalCost) {
-        this.hvCost = hvCost;
-        this.diagonalCost = diagonalCost;
+    public AStar(int rows, int cols, Node initialNode, Node finalNode, boolean searchDiagonals) {
         this.initialNode = initialNode;
         this.finalNode = finalNode;
         this.searchArea = new Node[rows][cols];
         this.openList = new PriorityQueue<>(Comparator.comparingInt(Node::f));
         initNodes();
         this.closedSet = new HashSet<>();
-    }
-
-    public AStar(int rows, int cols, Node initialNode, Node finalNode) {
-        this(rows, cols, initialNode, finalNode, DEFAULT_HV_COST, DEFAULT_DIAGONAL_COST);
+        if (searchDiagonals) {
+            this.diagonalsChecker = new DiagonalMapChecker(searchArea, openList, closedSet, DEFAULT_DIAGONAL_COST);
+        } else {
+            this.diagonalsChecker = new NoOpChecker(null, null, null);
+        }
+        this.hvChecker = new HorizontalVerticalChecker(searchArea, openList, closedSet, DEFAULT_HV_COST);
     }
 
     private void initNodes() {
@@ -58,15 +57,15 @@ public List<Node> findPath() {
             Node currentNode = openList.poll();
             closedSet.add(currentNode);
             if (isFinalNode(currentNode)) {
-                return generatePath(currentNode);
+                return bestPath(currentNode);
             } else {
                 addAdjacentNodes(currentNode);
             }
         }
         return new ArrayList<>();
     }
 
-    private List<Node> generatePath(Node currentNode) {
+    private List<Node> bestPath(Node currentNode) {
         List<Node> path = new ArrayList<>();
         path.add(currentNode);
         Node parent;
@@ -78,71 +77,26 @@ private List<Node> generatePath(Node currentNode) {
     }
 
     private void addAdjacentNodes(Node currentNode) {
-        addAdjacentUpperRow(currentNode);
-        addAdjacentMiddleRow(currentNode);
-        addAdjacentLowerRow(currentNode);
-    }
-
-    private void addAdjacentLowerRow(Node currentNode) {
         int row = currentNode.row();
         int col = currentNode.col();
-        int lowerRow = row + 1;
-        if (lowerRow >= searchArea.length) {
-            return;
-        }
-        if (col - 1 >= 0) {
-            checkNode(currentNode, col - 1, lowerRow, diagonalCost); // Comment this line if diagonal movements are not allowed
-        }
-        if (col + 1 < searchArea[0].length) {
-            checkNode(currentNode, col + 1, lowerRow, diagonalCost); // Comment this line if diagonal movements are not allowed
-        }
-        checkNode(currentNode, col, lowerRow, hvCost);
+        addAdjacentUpperRow(currentNode, row, col);
+        addAdjacentMiddleRow(currentNode, row, col);
+        addAdjacentLowerRow(currentNode, row, col);
     }
 
-    private void addAdjacentMiddleRow(Node currentNode) {
-        int row = currentNode.row();
-        int col = currentNode.col();
-        if (col - 1 >= 0) {
-            checkNode(currentNode, col - 1, row, hvCost);
-        }
-        if (col + 1 < searchArea[0].length) {
-            checkNode(currentNode, col + 1, row, hvCost);
-        }
+    private void addAdjacentLowerRow(Node currentNode, int row, int col) {
+        diagonalsChecker.checkNode(currentNode, col, row + 1);
+        hvChecker.checkNode(currentNode, col, row + 1);
     }
 
-    private void addAdjacentUpperRow(Node currentNode) {
-        int row = currentNode.row();
-        int col = currentNode.col();
-        int upperRow = row - 1;
-        if (upperRow < 0) {
-            return;
-        }
-        if (col - 1 >= 0) {
-            checkNode(currentNode, col - 1, upperRow, diagonalCost); // Comment this if diagonal movements are not allowed
-        }
-        if (col + 1 < searchArea[0].length) {
-            checkNode(currentNode, col + 1, upperRow, diagonalCost); // Comment this if diagonal movements are not allowed
-        }
-        checkNode(currentNode, col, upperRow, hvCost);
+    private void addAdjacentMiddleRow(Node currentNode, int row, int col) {
+        hvChecker.checkNode(currentNode, col - 1, row);
+        hvChecker.checkNode(currentNode, col + 1, row);
     }
 
-    private void checkNode(Node currentNode, int col, int row, int cost) {
-        Node adjacentNode = searchArea[row][col];
-        if (adjacentNode.isBlocked() || closedSet.contains(adjacentNode)) {
-            return;
-        }
-        if (!openList.contains(adjacentNode)) {
-            adjacentNode.setNodeData(currentNode, cost);
-            openList.add(adjacentNode);
-        } else {
-            boolean changed = adjacentNode.checkBetterPath(currentNode, cost);
-            if (changed) {
-                // Remove and Add the changed node, so that the PriorityQueue can sort again its
-                // contents with the modified "finalCost" value of the modified node
-                openList.remove(adjacentNode);
-                openList.add(adjacentNode);
-            }
-        }
+    private void addAdjacentUpperRow(Node currentNode, int row, int col) {
+        diagonalsChecker.checkNode(currentNode, col, row - 1);
+        hvChecker.checkNode(currentNode, col, row - 1);
     }
 
     private boolean isFinalNode(Node currentNode) {

src/com/ai/astar/AStarTest.java

@@ -9,7 +9,7 @@ public static void main(String[] args) {
         Node finalNode = new Node(2, 5);
         int rows = 6;
         int cols = 7;
-        AStar aStar = new AStar(rows, cols, initialNode, finalNode);
+        AStar aStar = new AStar(rows, cols, initialNode, finalNode, false);
         int[][] blocksArray = new int[][]{{1, 3}, {2, 3}, {3, 3}};
         aStar.initBlocks(blocksArray);
         List<Node> path = aStar.findPath();

src/com/ai/astar/searchstrategy/DiagonalMapChecker.java

@@ -0,0 +1,22 @@
+package com.ai.astar.searchstrategy;
+
+import com.ai.astar.Node;
+
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public class DiagonalMapChecker extends MapChecker {
+
+    private final int diagonalCost;
+
+    public DiagonalMapChecker(Node[][] searchArea, PriorityQueue<Node> openList, Set<Node> closedSet, int diagonalCost) {
+        super(searchArea, openList, closedSet);
+        this.diagonalCost = diagonalCost;
+    }
+
+    @Override
+    public void checkNode(Node currentNode, int col, int row) {
+        check(currentNode, col - 1, row, diagonalCost);
+        check(currentNode, col + 1, row, diagonalCost);
+    }
+}

src/com/ai/astar/searchstrategy/HorizontalVerticalChecker.java

@@ -0,0 +1,21 @@
+package com.ai.astar.searchstrategy;
+
+import com.ai.astar.Node;
+
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public class HorizontalVerticalChecker extends MapChecker {
+
+    private final int hvCost;
+
+    public HorizontalVerticalChecker(Node[][] searchArea, PriorityQueue<Node> openList, Set<Node> closedSet, int hvCost) {
+        super(searchArea, openList, closedSet);
+        this.hvCost = hvCost;
+    }
+
+    @Override
+    public void checkNode(Node currentNode, int col, int row) {
+        check(currentNode, col, row, hvCost);
+    }
+}

src/com/ai/astar/searchstrategy/MapCheck.java

@@ -0,0 +1,9 @@
+package com.ai.astar.searchstrategy;
+
+import com.ai.astar.Node;
+
+public interface MapCheck {
+
+    void checkNode(Node currentNode, int col, int row);
+
+}

src/com/ai/astar/searchstrategy/MapChecker.java

@@ -0,0 +1,46 @@
+package com.ai.astar.searchstrategy;
+
+import com.ai.astar.Node;
+
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public abstract class MapChecker implements MapCheck {
+    protected final Node[][] searchArea;
+    protected final PriorityQueue<Node> openList;
+    protected final Set<Node> closedSet;
+    protected final int columns;
+
+    protected MapChecker(Node[][] searchArea, PriorityQueue<Node> openList, Set<Node> closedSet) {
+        this.searchArea = searchArea;
+        this.openList = openList;
+        this.closedSet = closedSet;
+        this.columns = searchArea == null ? 0 : searchArea[0].length;
+    }
+
+    void check(Node currentNode, int col, int row, int cost) {
+        if (row < 0 || row >= searchArea.length) {
+            return;
+        }
+        if (col < 0 || col >= columns) {
+            return;
+        }
+        Node adjacentNode = searchArea[row][col];
+        if (adjacentNode.isBlocked() || closedSet.contains(adjacentNode)) {
+            return;
+        }
+        if (!openList.contains(adjacentNode)) {
+            adjacentNode.setNodeData(currentNode, cost);
+            openList.add(adjacentNode);
+        } else {
+            boolean changed = adjacentNode.checkBetterPath(currentNode, cost);
+            if (changed) {
+                // Remove and Add the changed node, so that the PriorityQueue can sort again its
+                // contents with the modified "finalCost" value of the modified node
+                openList.remove(adjacentNode);
+                openList.add(adjacentNode);
+            }
+        }
+    }
+
+}

src/com/ai/astar/searchstrategy/NoOpChecker.java

@@ -0,0 +1,18 @@
+package com.ai.astar.searchstrategy;
+
+import com.ai.astar.Node;
+
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public class NoOpChecker extends MapChecker {
+
+    public NoOpChecker(Node[][] searchArea, PriorityQueue<Node> openList, Set<Node> closedSet) {
+        super(searchArea, openList, closedSet);
+    }
+
+    @Override
+    public void checkNode(Node currentNode, int col, int row) {
+        // nothing to do
+    }
+}