Updated variable namings and README

Author: pgeadas

README.md

@@ -1,14 +1,25 @@
 # A-Star-Java-Implementation
-A* also called A Star, algorithm java implementation
 
-This is a java implementation of the A Star algorithm. I couldn't find any good java implementations of this famous AI algorithm on the web so I decided to make my own. 
+A*, also called A Star, is a graph traversal and path search algorithm, which is used in many fields of computer science due to its completeness, optimality, and optimal efficiency.
 
-The implementation includes 3 files:
-  - AStar.java : Main algorithm class.
-  - Node.java : Class for the nodes used by the algorithm.
-  - AStarTest.java : Class with a main method and a simple test for the algorithm implementation
+The implementation includes several files:
+  - AStar.java: Main algorithm class.
+  - Node.java: Class for the nodes used by the algorithm.
+  - searchstrategy package: Strategy pattern with several map search algorithms: 
+    1. Diagonals - when enabled, also considers diagonal moves
+    2. Manhattan distance - default mode, only considers vertical and horizontal moves
 
-## Search Area
+
+## A* specifications
+
+- For node n, gScore[n] is the cost of the cheapest path currently known from start to n.
+- For node n, fScore[n] = gScore[n] + heuristic(n), where gScore(n) is the distance from the starting node to n
+    and h(n) is a heuristic value of estimation distance from node n to finish node.
+- h(n) is a heuristic value of estimation distance from node n to finish node
+
+## Example provided
+
+### Search Area
 
               0   1   2   3   4   5   6
          0    -   -   -   -   -   -   -
@@ -18,7 +29,7 @@ The implementation includes 3 files:
          4    -   -   -   -   -   -   -
          5    -   -   -   -   -   -   -
 
-## Search Path with diagonals
+### Search Path with diagonals
 
               0   1   2   3   4   5   6
          0    -   -   -   *   -   -   -
@@ -28,7 +39,7 @@ The implementation includes 3 files:
          4    -   -   -   -   -   -   -
          5    -   -   -   -   -   -   -
 
-## Search Path without diagonals
+### Search Path without diagonals
 
               0   1   2   3   4   5   6
          0    -   -   *   *   *   -   -

app/src/main/java/com/ai/astar/domain/AStar.java

@@ -1,22 +1,22 @@
 package com.ai.astar.domain;
 
 import com.ai.astar.domain.searchstrategy.DiagonalMapChecker;
-import com.ai.astar.domain.searchstrategy.HorizontalVerticalChecker;
+import com.ai.astar.domain.searchstrategy.ManhattanMapChecker;
 import com.ai.astar.domain.searchstrategy.MapChecker;
 import com.ai.astar.domain.searchstrategy.NoOpChecker;
 
 import java.util.*;
 
 public class AStar {
-    private static final int DEFAULT_HV_COST = 10; // Horizontal - Vertical Cost
+    private static final int DEFAULT_MANHATTAN_COST = 10;
     private static final int DEFAULT_DIAGONAL_COST = 14;
     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;
+    private final MapChecker manhattanChecker;
 
     public AStar(
             int rows,
@@ -30,7 +30,7 @@ public AStar(
         this.initialNode = initialNode;
         this.finalNode = finalNode;
         this.searchArea = new Node[rows][cols];
-        this.openList = new PriorityQueue<>(Comparator.comparingInt(Node::f));
+        this.openList = new PriorityQueue<>(Comparator.comparingInt(Node::fScore));
         initNodes();
         initBlocks(blocksArray);
         this.closedSet = new HashSet<>();
@@ -39,11 +39,11 @@ public AStar(
         } else {
             this.diagonalsChecker = new NoOpChecker(null, null, null);
         }
-        this.hvChecker = new HorizontalVerticalChecker(searchArea, openList, closedSet, hvCost);
+        this.manhattanChecker = new ManhattanMapChecker(searchArea, openList, closedSet, hvCost);
     }
 
     public AStar(int rows, int cols, Node initialNode, Node finalNode, int[][] blocksArray, boolean searchDiagonals) {
-        this(rows, cols, initialNode, finalNode, blocksArray, searchDiagonals, DEFAULT_DIAGONAL_COST, DEFAULT_HV_COST);
+        this(rows, cols, initialNode, finalNode, blocksArray, searchDiagonals, DEFAULT_DIAGONAL_COST, DEFAULT_MANHATTAN_COST);
     }
 
     private void initNodes() {
@@ -105,17 +105,17 @@ private void addAdjacentNodes(Node currentNode) {
 
     private void addAdjacentLowerRow(Node currentNode, int row, int col) {
         diagonalsChecker.checkNode(currentNode, col, row + 1);
-        hvChecker.checkNode(currentNode, col, row + 1);
+        manhattanChecker.checkNode(currentNode, col, row + 1);
     }
 
     private void addAdjacentMiddleRow(Node currentNode, int row, int col) {
-        hvChecker.checkNode(currentNode, col - 1, row);
-        hvChecker.checkNode(currentNode, col + 1, row);
+        manhattanChecker.checkNode(currentNode, col - 1, row);
+        manhattanChecker.checkNode(currentNode, col + 1, row);
     }
 
     private void addAdjacentUpperRow(Node currentNode, int row, int col) {
         diagonalsChecker.checkNode(currentNode, col, row - 1);
-        hvChecker.checkNode(currentNode, col, row - 1);
+        manhattanChecker.checkNode(currentNode, col, row - 1);
     }
 
     private boolean isFinalNode(Node currentNode) {

app/src/main/java/com/ai/astar/domain/Node.java

@@ -2,9 +2,9 @@
 
 public class Node {
 
-    private int g;
-    private int f;
-    private int heuristic;
+    private int gScore;
+    private int fScore;
+    private int h;
     private final int row;
     private final int col;
     private boolean isBlocked;
@@ -21,31 +21,38 @@ public static Node of(int row, int col) {
     }
 
     public void calculateHeuristic(Node finalNode) {
-        this.heuristic = Math.abs(finalNode.row() - row) + Math.abs(finalNode.col() - col);
+        this.h = Math.abs(finalNode.row() - row) + Math.abs(finalNode.col() - col);
     }
 
     public void updateNode(Node currentNode, int cost) {
-        int gCost = currentNode.g() + cost;
         this.parent = currentNode;
-        this.g = gCost;
-        this.f = g + heuristic;
+        updateGScore(currentNode.gScore(), cost);
+        updateFScore();
     }
 
     public boolean checkBetterPath(Node currentNode, int cost) {
-        int gCost = currentNode.g() + cost;
-        if (gCost < g()) {
+        int gCost = currentNode.gScore() + cost;
+        if (gCost < gScore()) {
             updateNode(currentNode, cost);
             return true;
         }
         return false;
     }
 
-    public int g() {
-        return g;
+    public int gScore() {
+        return gScore;
     }
 
-    public int f() {
-        return f;
+    private void updateGScore(int currentGScore, int cost) {
+        this.gScore = currentGScore + cost;
+    }
+
+    public int fScore() {
+        return fScore;
+    }
+
+    private void updateFScore() {
+        this.fScore = gScore + h;
     }
 
     public Node parent() {

app/src/main/java/com/ai/astar/domain/searchstrategy/HorizontalVerticalChecker.java

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

app/src/main/java/com/ai/astar/domain/searchstrategy/ManhattanMapChecker.java

@@ -18,7 +18,7 @@ protected MapChecker(Node[][] searchArea, PriorityQueue<Node> openList, Set<Node
         this.columns = searchArea == null ? 0 : searchArea[0].length;
     }
 
-    void check(Node currentNode, int col, int row, int cost) {
+    protected void check(Node currentNode, int col, int row, int cost) {
         if (row < 0 || row >= searchArea.length) {
             return;
         }