Cleaned code a bit

Author: Pedro Geadas

src/com/ai/astar/AStar.java

@@ -16,61 +16,61 @@ public class AStar {
     private final Node[][] searchArea;
     private final PriorityQueue<Node> openList;
     private final Set<Node> closedSet;
-    private Node initialNode;
-    private Node finalNode;
+    private final Node initialNode;
+    private final Node finalNode;
 
     public AStar(int rows, int cols, Node initialNode, Node finalNode, int hvCost, int diagonalCost) {
         this.hvCost = hvCost;
         this.diagonalCost = diagonalCost;
-        setInitialNode(initialNode);
-        setFinalNode(finalNode);
+        this.initialNode = initialNode;
+        this.finalNode = finalNode;
         this.searchArea = new Node[rows][cols];
-        this.openList = new PriorityQueue<>(Comparator.comparingInt(Node::getF));
-        setNodes();
+        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);
     }
 
-    private void setNodes() {
+    private void initNodes() {
         for (int i = 0; i < searchArea.length; i++) {
             for (int j = 0; j < searchArea[0].length; j++) {
                 Node node = new Node(i, j);
-                node.calculateHeuristic(getFinalNode());
+                node.calculateHeuristic(finalNode);
                 this.searchArea[i][j] = node;
             }
         }
     }
 
-    public void setBlocks(int[][] blocksArray) {
+    public void initBlocks(int[][] blocksArray) {
         for (int[] ints : blocksArray) {
             int row = ints[0];
             int col = ints[1];
-            setBlock(row, col);
+            this.searchArea[row][col].setAsBlocked();
         }
     }
 
     public List<Node> findPath() {
         openList.add(initialNode);
-        while (!isEmpty(openList)) {
+        while (!openList.isEmpty()) {
             Node currentNode = openList.poll();
             closedSet.add(currentNode);
             if (isFinalNode(currentNode)) {
-                return getPath(currentNode);
+                return generatePath(currentNode);
             } else {
                 addAdjacentNodes(currentNode);
             }
         }
         return new ArrayList<>();
     }
 
-    private List<Node> getPath(Node currentNode) {
+    private List<Node> generatePath(Node currentNode) {
         List<Node> path = new ArrayList<>();
         path.add(currentNode);
         Node parent;
-        while ((parent = currentNode.getParent()) != null) {
+        while ((parent = currentNode.parent()) != null) {
             path.add(0, parent);
             currentNode = parent;
         }
@@ -84,60 +84,63 @@ private void addAdjacentNodes(Node currentNode) {
     }
 
     private void addAdjacentLowerRow(Node currentNode) {
-        int row = currentNode.getRow();
-        int col = currentNode.getCol();
+        int row = currentNode.row();
+        int col = currentNode.col();
         int lowerRow = row + 1;
-        if (lowerRow < getSearchArea().length) {
-            if (col - 1 >= 0) {
-                checkNode(currentNode, col - 1, lowerRow, getDiagonalCost()); // Comment this line if diagonal movements are not allowed
-            }
-            if (col + 1 < getSearchArea()[0].length) {
-                checkNode(currentNode, col + 1, lowerRow, getDiagonalCost()); // Comment this line if diagonal movements are not allowed
-            }
-            checkNode(currentNode, col, lowerRow, getHvCost());
+        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);
     }
 
     private void addAdjacentMiddleRow(Node currentNode) {
-        int row = currentNode.getRow();
-        int col = currentNode.getCol();
+        int row = currentNode.row();
+        int col = currentNode.col();
         if (col - 1 >= 0) {
-            checkNode(currentNode, col - 1, row, getHvCost());
+            checkNode(currentNode, col - 1, row, hvCost);
         }
-        if (col + 1 < getSearchArea()[0].length) {
-            checkNode(currentNode, col + 1, row, getHvCost());
+        if (col + 1 < searchArea[0].length) {
+            checkNode(currentNode, col + 1, row, hvCost);
         }
     }
 
     private void addAdjacentUpperRow(Node currentNode) {
-        int row = currentNode.getRow();
-        int col = currentNode.getCol();
+        int row = currentNode.row();
+        int col = currentNode.col();
         int upperRow = row - 1;
-        if (upperRow >= 0) {
-            if (col - 1 >= 0) {
-                checkNode(currentNode, col - 1, upperRow, getDiagonalCost()); // Comment this if diagonal movements are not allowed
-            }
-            if (col + 1 < getSearchArea()[0].length) {
-                checkNode(currentNode, col + 1, upperRow, getDiagonalCost()); // Comment this if diagonal movements are not allowed
-            }
-            checkNode(currentNode, col, upperRow, getHvCost());
+        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 checkNode(Node currentNode, int col, int row, int cost) {
-        Node adjacentNode = getSearchArea()[row][col];
-        if (!adjacentNode.isBlock() && !getClosedSet().contains(adjacentNode)) {
-            if (!getOpenList().contains(adjacentNode)) {
-                adjacentNode.setNodeData(currentNode, cost);
-                getOpenList().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
-                    getOpenList().remove(adjacentNode);
-                    getOpenList().add(adjacentNode);
-                }
+        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);
             }
         }
     }
@@ -146,45 +149,5 @@ private boolean isFinalNode(Node currentNode) {
         return currentNode.equals(finalNode);
     }
 
-    private boolean isEmpty(PriorityQueue<Node> openList) {
-        return openList.isEmpty();
-    }
-
-    private void setBlock(int row, int col) {
-        this.searchArea[row][col].setBlock(true);
-    }
-
-    public void setInitialNode(Node initialNode) {
-        this.initialNode = initialNode;
-    }
-
-    public Node getFinalNode() {
-        return finalNode;
-    }
-
-    public void setFinalNode(Node finalNode) {
-        this.finalNode = finalNode;
-    }
-
-    public Node[][] getSearchArea() {
-        return searchArea;
-    }
-
-    public PriorityQueue<Node> getOpenList() {
-        return openList;
-    }
-
-    public Set<Node> getClosedSet() {
-        return closedSet;
-    }
-
-    public int getHvCost() {
-        return hvCost;
-    }
-
-    private int getDiagonalCost() {
-        return diagonalCost;
-    }
-
 }
 

src/com/ai/astar/AStarTest.java

@@ -11,7 +11,7 @@ public static void main(String[] args) {
         int cols = 7;
         AStar aStar = new AStar(rows, cols, initialNode, finalNode);
         int[][] blocksArray = new int[][]{{1, 3}, {2, 3}, {3, 3}};
-        aStar.setBlocks(blocksArray);
+        aStar.initBlocks(blocksArray);
         List<Node> path = aStar.findPath();
         for (Node node : path) {
             System.out.println(node);

src/com/ai/astar/Node.java

@@ -13,7 +13,7 @@ public class Node {
     private int h;
     private final int row;
     private final int col;
-    private boolean isBlock;
+    private boolean isBlocked;
     private Node parent;
 
     public Node(int row, int col) {
@@ -23,28 +23,51 @@ public Node(int row, int col) {
     }
 
     public void calculateHeuristic(Node finalNode) {
-        this.h = Math.abs(finalNode.getRow() - getRow()) + Math.abs(finalNode.getCol() - getCol());
+        this.h = Math.abs(finalNode.row() - row) + Math.abs(finalNode.col() - col);
     }
 
     public void setNodeData(Node currentNode, int cost) {
-        int gCost = currentNode.getG() + cost;
-        setParent(currentNode);
-        setG(gCost);
-        calculateFinalCost();
+        int gCost = currentNode.g() + cost;
+        this.parent = currentNode;
+        this.g = gCost;
+        this.f = g + h;
     }
 
     public boolean checkBetterPath(Node currentNode, int cost) {
-        int gCost = currentNode.getG() + cost;
-        if (gCost < getG()) {
+        int gCost = currentNode.g() + cost;
+        if (gCost < g()) {
             setNodeData(currentNode, cost);
             return true;
         }
         return false;
     }
 
-    private void calculateFinalCost() {
-        int finalCost = getG() + getH();
-        setF(finalCost);
+    public int g() {
+        return g;
+    }
+
+    public int f() {
+        return f;
+    }
+
+    public Node parent() {
+        return parent;
+    }
+
+    public boolean isBlocked() {
+        return isBlocked;
+    }
+
+    public void setAsBlocked() {
+        this.isBlocked = true;
+    }
+
+    public int row() {
+        return row;
+    }
+
+    public int col() {
+        return col;
     }
 
     @Override
@@ -60,56 +83,12 @@ public boolean equals(Object arg0) {
             return false;
         }
         Node other = (Node) arg0;
-        return this.getRow() == other.getRow() && this.getCol() == other.getCol();
+        return this.row() == other.row() && this.col() == other.col();
     }
 
     @Override
     public String toString() {
         return "Node [row=" + row + ", col=" + col + "]";
     }
 
-    public int getH() {
-        return h;
-    }
-
-    public int getG() {
-        return g;
-    }
-
-    public void setG(int g) {
-        this.g = g;
-    }
-
-    public int getF() {
-        return f;
-    }
-
-    public void setF(int f) {
-        this.f = f;
-    }
-
-    public Node getParent() {
-        return parent;
-    }
-
-    public void setParent(Node parent) {
-        this.parent = parent;
-    }
-
-    public boolean isBlock() {
-        return isBlock;
-    }
-
-    public void setBlock(boolean isBlock) {
-        this.isBlock = isBlock;
-    }
-
-    public int getRow() {
-        return row;
-    }
-
-    public int getCol() {
-        return col;
-    }
-
 }