updated gitignore cache

Author: vmsaif

.gitignore

@@ -0,0 +1,26 @@
+# Compiled class file
+*.class
+
+    "java.codeGeneration.generateJavadocCustomTagValueValueValueValueTag": true,
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+    "java.codeGeneration.generateJavadocCustomTagValueValueValueValueDocRoot": true,
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+
+    "java.codeGeneration.generateJavadocCustomTagValueValueValueValueInheritDoc": true,
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# Visual Studio Code files
+.vscode/*

README.md

@@ -0,0 +1,39 @@
+# Ant Path Finding using A* Algorithm
+
+[![Hits](https://hits.sh/github.com/vmsaif/ant-path-finding-using-A-Star-algorithm.svg?label=Visits&color=100b75)](https://hits.sh/github.com/vmsaif/ant-path-finding-using-A-Star-algorithm/)
+
+## Logic and Design of Program
+
+The program uses the A* algorithm to find the shortest path from the ant to the food. The ant is the start and the food is the goal. The ant can move in 8 directions. 
+
+When the game starts, the user is asked to select 
+
+-the start and the goal cells
+-the obstacle cells
+-the nature of the terrain for each cell between
+    - Open Terrain	
+    - Grassland
+    - Swampland
+    - Obstacles
+
+After the user has selected the cells, the program calculates the shortest path from the ant to the food. The program uses the A* algorithm to find the shortest path. The A* algorithm uses a heuristic function to find the shortest path. The heuristic function used in this program is the Manhattan distance. The program shows the search evaluation of the A* algorithm. When the path is found, the ant starts moving from the start cell to the goal cell.
+
+## Compiling and Running
+
+### Compiling
+The game uses a simple state machine to manage the different states of the game. 
+
+- Run the command `javac -d bin src/*.java` to compile the Java files in the `src` directory to `bin/` directory.
+- Run the command `java -cp bin/ App` to run the main game.
+
+## Resources
+
+### Images
+- [Ant Image](https://www.pngegg.com/en/png-zblks)
+- [Food Image](https://www.pngegg.com/en/png-medpx)
+
+### Bugs:
+I have not found any bugs in the program yet. If you find any, please let me know.
+
+
+

ant.png

@@ -0,0 +1,188 @@
+
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import javax.swing.JPanel;
+
+public class AStarSearch extends JPanel {
+
+    private Tile[][] tiles;
+    private Tile start;
+    private Tile goal;
+    private Ant ant;
+    private LinkedList<LinkedList<Tile>> allPath2D = new LinkedList<LinkedList<Tile>>();
+
+    public AStarSearch(Tile[][] tiles, Ant ant, Tile start, Tile goal) {
+        this.tiles = tiles;
+        this.start = start;
+        this.goal = goal;
+        this.ant = ant;
+    }
+
+    public LinkedList<Tile> search() {
+
+        LinkedList<Tile> output = new LinkedList<>();
+        LinkedList<Tile> closedSet = new LinkedList<>();
+
+        // create openSet and add start to it
+        PriorityQueue<Tile> openSet = new PriorityQueue<Tile>();
+
+        // add start to openSet
+        openSet.add(start);
+
+        boolean foundGoal = false;
+        boolean noPath = false;
+
+        // while openSet is not empty
+        while (openSet.size() > 0 && foundGoal == false && noPath == false) {
+            // create a row for each iteration for drawing purposes
+            LinkedList<Tile> row = new LinkedList<>();
+
+            // check if first element in openSet is goal
+            Tile current = openSet.poll();
+            allPath2D.add(row);
+            row.add(current);
+
+            if (current.equals(goal) && noPath == false) {
+                // reconstruct path
+                output = reconstructPath(current);
+                foundGoal = true;
+                // ant.stopSearch();
+
+            } else {
+                // not goal, add to closedSet
+                closedSet.add(current);
+
+                // get neighbors of current/ outgoing connections
+                PriorityQueue<Tile> neighbors = getNeighbors(current);
+
+                // for each neighbor of current, evaluate cost
+                while (neighbors.size() > 0) {
+                    Tile currNeighbor = neighbors.poll();
+
+                    // if neighbor is not in closedSet and not obstacle, then evaluate cost
+                    if (!closedSet.contains(currNeighbor) && !currNeighbor.isObstacle()) {
+                        row.add(currNeighbor);
+                        double tempCost = current.getG() + currNeighbor.getCost();
+
+                        // check for a shorter route
+                        boolean betterPath = false;
+                        if (!openSet.contains(currNeighbor)) {
+                            // if neighbor is not in openSet, add to openSet and add g cost
+                            currNeighbor.setG(tempCost);
+                            betterPath = true;
+                        } else {
+                            // openSet contains neighbor, check if shorter route
+                            if (tempCost < currNeighbor.getG()) {
+                                // found a shorter route, update g cost then update the priority queue
+                                openSet.remove(currNeighbor);
+                                currNeighbor.setG(tempCost);
+                                openSet.add(currNeighbor);
+                                betterPath = true;
+                            }
+                        }
+
+                        // set neighbor's heuristic estimated cost to goal and f cost if a better path
+                        // is found
+                        if (betterPath) {
+                            currNeighbor.setH(getHeuristic(currNeighbor, goal));
+
+                            // set neighbor's f
+                            currNeighbor.setF(currNeighbor.getG() + currNeighbor.getH());
+
+                            // record previous node
+                            currNeighbor.setCameFrom(current);
+
+                        }
+
+                        // add neighbor to openSet if not already in it
+                        if (!openSet.contains(currNeighbor)) {
+                            openSet.add(currNeighbor);
+                        }
+
+                    } // end if statement
+
+                } // end while loop
+
+            } // end else(not goal)
+
+            // if openSet is empty, then no path
+            if (openSet.size() == 0) {
+                System.out.println("No path found");
+                noPath = true;
+            }
+
+        } // end main while loop
+
+        // the list of all paths for drawing purposes
+        ant.setAllPath2D(allPath2D);
+        return output;
+    }
+
+    private double getHeuristic(Tile currNeighbor, Tile goal) {
+
+        // manhattan distance between current neighbor and goal
+        int dx = Math.abs(currNeighbor.getX() - goal.getX());
+        int dy = Math.abs(currNeighbor.getY() - goal.getY());
+        return dx + dy;
+    }
+
+    private PriorityQueue<Tile> getNeighbors(Tile tile) {
+
+        PriorityQueue<Tile> neighbors = new PriorityQueue<>();
+
+        // get the indexes of the tile from the neighbors 2d array
+
+        int x = tile.getX();
+        int y = tile.getY();
+
+        // add neighbours including diagonals
+        // top left
+        if (x > 0 && y > 0) {
+            neighbors.add(tiles[x - 1][y - 1]);
+        }
+        // top
+        if (y > 0) {
+            neighbors.add(tiles[x][y - 1]);
+        }
+        // top right
+        if (x < tiles.length - 1 && y > 0) {
+            neighbors.add(tiles[x + 1][y - 1]);
+        }
+        // right
+        if (x < tiles.length - 1) {
+            neighbors.add(tiles[x + 1][y]);
+        }
+        // bottom right
+        if (x < tiles.length - 1 && y < tiles[0].length - 1) {
+            neighbors.add(tiles[x + 1][y + 1]);
+        }
+        // bottom
+        if (y < tiles[0].length - 1) {
+            neighbors.add(tiles[x][y + 1]);
+        }
+        // bottom left
+        if (x > 0 && y < tiles[0].length - 1) {
+            neighbors.add(tiles[x - 1][y + 1]);
+        }
+        // left
+        if (x > 0) {
+            neighbors.add(tiles[x - 1][y]);
+        }
+
+        return neighbors;
+    }
+
+    public LinkedList<Tile> reconstructPath(Tile current) {
+        LinkedList<Tile> path = new LinkedList<>();
+        System.out.println("Path found");
+        while (current != null) {
+            path.add(current);
+
+            // move to the previous node
+            current = current.getCameFrom();
+        }
+
+        return path;
+    }
+
+}

food.png

@@ -0,0 +1,88 @@
+/* -----------------------------------------------------------------------------
+    Author: Saif Mahmud
+    Date: 2023-22-07
+*/
+
+import java.awt.Graphics;
+import java.awt.Image;
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedList;
+
+import javax.imageio.ImageIO;
+
+public class Ant {
+
+    private int antX;
+    private int antY;
+    private Tile start;
+    private Tile goal;
+    private Tile[][] tiles;
+    private Image antImage;
+    private LinkedList<Tile> path;
+    private Graphics g;
+
+    private AStarSearch aStarSearch;
+    private LinkedList<LinkedList<Tile>> allPath2D = new LinkedList<LinkedList<Tile>>();
+
+    public Ant(Tile start, Tile goal, int tileSize, Tile[][] tiles) {
+        this.start = start;
+        this.goal = goal;
+        this.tiles = tiles;
+        loadAntImg();
+        antX = start.getX()*tileSize;
+        antY = start.getY()*tileSize;
+    }
+
+    private void loadAntImg() {
+        try {
+            antImage = ImageIO.read(new File("ant.png"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void draw(Graphics g, int tileSize) {
+        g.drawImage(antImage, antX, antY, tileSize, tileSize, null);
+    }
+   
+    // search for the path from start to goal using A* search
+    public void search() {
+        aStarSearch = new AStarSearch(tiles, this, start, goal);
+        path = aStarSearch.search();
+    }
+
+    public LinkedList<Tile> getPath() {
+        
+        // find the path and store it in path LinkedList
+        if(path == null){
+            this.search();
+        }
+        return path;
+    }
+
+
+    public void setAllPath2D(LinkedList<LinkedList<Tile>> allPath2D) {
+        this.allPath2D = allPath2D;
+    }
+
+    public LinkedList<LinkedList<Tile>> getAllPath2D() {
+        return allPath2D;
+    }
+
+    public int getX() {
+        return antX;
+    }
+
+    public int getY() {
+        return antY;
+    }
+    public void setX(int x) {
+        antX = x;
+    }
+
+    public void setY(int y) {
+        antY = y;
+    }
+
+}// end class Ant

src/AStarSearch.java

@@ -0,0 +1,18 @@
+/* -----------------------------------------------------------------------------
+    Author: Saif Mahmud
+    Date: 2023-22-07
+    Description: Main class to run the game
+*/
+
+import javax.swing.JFrame;
+
+public class App {
+    public static void main(String[] args) throws Exception {
+        Game game = new Game();
+        JFrame frame = new JFrame("A2_Q1");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setSize(900, 700);
+        frame.add(game);
+        frame.setVisible(true);
+    }
+}