started a3p1

vmsaif · vmsaif · commit 234a53e7163b · 2023-08-03T20:31:46.000-05:00
diff --git a/A2_Q1/README.md b/A2_Q1/README.md
@@ -1,2 +1,41 @@
-[Ant](https://www.pngegg.com/en/png-zblks)
-[food](https://www.pngegg.com/en/png-medpx)
+# Ant Path Finding using A* 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.
+
+### Option 2: Directly Run
+
+- Just run the A2_Q1.jar file to start.
+
+## 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.
+
+
+
diff --git a/A2_Q1/src/AStarSearch.java b/A2_Q1/src/AStarSearch.java
@@ -1,163 +1,123 @@
 
-
-import java.awt.Color;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
 import java.util.ArrayList;
-
 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 ArrayList<ArrayList<Tile>> allPath2D = new ArrayList<ArrayList<Tile>>();
-    
+
     public AStarSearch(Tile[][] tiles, Ant ant, Tile start, Tile goal) {
         this.tiles = tiles;
         this.start = start;
         this.goal = goal;
         this.ant = ant;
     }
-    
+
     public ArrayList<Tile> search() {
 
         ArrayList<Tile> output = new ArrayList<>();
         ArrayList<Tile> closedSet = new ArrayList<>();
-        
-        // create openSet and add start to it 
+
+        // 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){
-            
+
+        // while openSet is not empty
+        while (openSet.size() > 0 && foundGoal == false && noPath == false) {
+            // create a row for each iteration for drawing purposes
+            ArrayList<Tile> row = new ArrayList<>();
+
             // check if first element in openSet is goal
             Tile current = openSet.poll();
-            // System.out.println("current: " + current);
-            ArrayList<Tile> row = new ArrayList<>();
             allPath2D.add(row);
             row.add(current);
-            // System.out.println();
-            // System.out.println("Removing Main Grid ["+current.getX()+"]["+current.getY()+"] F:" + current.getF() + " G:" + current.getG() + " H:" + current.getH());
-            
-            if(current.equals(goal) && noPath == false){
+
+            if (current.equals(goal) && noPath == false) {
                 // reconstruct path
                 output = reconstructPath(current);
                 foundGoal = true;
                 // ant.stopSearch();
 
             } else {
-                // remove current from openSet and add to closedSet
-                // openSet.remove(current);
+                // not goal, add to closedSet
                 closedSet.add(current);
 
                 // get neighbors of current/ outgoing connections
                 PriorityQueue<Tile> neighbors = getNeighbors(current);
 
-                // printQueue(neighbors);
-
-                // for each neighbor of current, evaluate cost 
-                while(neighbors.size() > 0){
+                // for each neighbor of current, evaluate cost
+                while (neighbors.size() > 0) {
                     Tile currNeighbor = neighbors.poll();
-                    
-                    // System.out.println("--Polled Grid ["+currNeighbor.getX()+"]["+currNeighbor.getY()+"] F:" + currNeighbor.getF() + " G:" + currNeighbor.getG() + " H:" + currNeighbor.getH());
-                    
+
                     // if neighbor is not in closedSet and not obstacle, then evaluate cost
-                    if(!closedSet.contains(currNeighbor) && !currNeighbor.isObstacle()){
+                    if (!closedSet.contains(currNeighbor) && !currNeighbor.isObstacle()) {
                         row.add(currNeighbor);
                         double tempCost = current.getG() + currNeighbor.getCost();
-                        
-                        // System.out.println("tempCost:  " + tempCost + " gCost: " + current.getG() + " current: " + current.getCost());
-
-                        boolean betterPath = false;
 
                         // check for a shorter route
-                        if(!openSet.contains(currNeighbor)){
+                        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;
-                            
-                            // System.out.println("ADDING Grid ["+currNeighbor.getX()+"]["+currNeighbor.getY()+"] F:" + currNeighbor.getF() + " G:" + currNeighbor.getG() + " H:" + currNeighbor.getH());
-
-                        } else { 
+                        } else {
                             // openSet contains neighbor, check if shorter route
-                            
-                            if (tempCost < currNeighbor.getG()){
-                                // found a shorter route, update g cost
+                            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
-                        if(betterPath){
+                        // 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)){
-                            // System.out.println("ADDING Grid ["+currNeighbor.getX()+"]["+currNeighbor.getY()+"] F:" + currNeighbor.getF() + " G:" + currNeighbor.getG() + " H:" + currNeighbor.getH());
+                        if (!openSet.contains(currNeighbor)) {
                             openSet.add(currNeighbor);
-                            
                         }
-                        
-
-                        // System.out.println("--Polled Grid ["+currNeighbor.getX()+"]["+currNeighbor.getY()+"] F:" + currNeighbor.getF() + " G:" + currNeighbor.getG() + " H:" + currNeighbor.getH());
-
-    
-                        // update GUI after each iteration of the search algorithm
 
                     } // end if statement
-                    // System.out.println(" Grid ["+currNeighbor.getX()+"]["+currNeighbor.getY()+"] F:" + currNeighbor.getF() + " G:" + currNeighbor.getG() + " H:" + currNeighbor.getH());
 
                 } // end while loop
 
-                
-
-                
             } // end else(not goal)
 
             // if openSet is empty, then no path
-            if(openSet.size() == 0){
+            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);
-        // System.out.println("Grid [1][0] F:" + tiles[1][0].getF() + " G:" + tiles[1][0].getG() + " H:" + tiles[1][0].getH());
-        // System.out.println("Grid [1][1] F:" + tiles[1][1].getF() + " G:" + tiles[1][1].getG() + " H:" + tiles[1][1].getH());    
-
         return output;
     }
 
-
     private double getHeuristic(Tile currNeighbor, Tile goal) {
 
         // manhattan distance between current neighbor and goal
@@ -171,47 +131,47 @@ 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]);
+        if (x > 0 && y > 0) {
+            neighbors.add(tiles[x - 1][y - 1]);
         }
         // top
-        if(y > 0){
-            neighbors.add(tiles[x][y-1]);
+        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]);
+        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]);
+        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]);
+        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]);
+        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]);
+        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]);
+        if (x > 0) {
+            neighbors.add(tiles[x - 1][y]);
         }
 
         return neighbors;
     }
-    
+
     public ArrayList<Tile> reconstructPath(Tile current) {
         ArrayList<Tile> path = new ArrayList<>();
 
@@ -220,10 +180,9 @@ public ArrayList<Tile> reconstructPath(Tile current) {
 
             // move to the previous node
             current = current.getCameFrom();
-            // System.out.println("Path: (" + current.getX() + ", " + current.getY()+")");
         }
 
         return path;
     }
-    
+
 }
diff --git a/A2_Q1/src/Ant.java b/A2_Q1/src/Ant.java
@@ -50,14 +50,15 @@ 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 ArrayList<Tile> getPath() {
-        // find the path and store it in path arraylist
         
+        // find the path and store it in path arraylist
         if(path == null){
             this.search();
         }
diff --git a/A2_Q1/src/App.java b/A2_Q1/src/App.java
@@ -13,12 +13,10 @@
 public class App {
     public static void main(String[] args) throws Exception {
         Game game = new Game();
-        JFrame frame = new JFrame("A2_P1");
+        JFrame frame = new JFrame("A2_Q1");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setSize(900, 700);
-
         frame.add(game);
-        // frame.pack();
         frame.setVisible(true);
     }
 }
diff --git a/A2_Q1/src/Game.java b/A2_Q1/src/Game.java

Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,15 @@ public void draw(Graphics g, int tileSize) {`
`50`	`50`	`g.drawImage(antImage, antX, antY, tileSize, tileSize, null);`
`51`	`51`	`}`
`52`	`52`
	`53`	`+ // search for the path from start to goal using A* search`
`53`	`54`	`public void search() {`
`54`	`55`	`aStarSearch = new AStarSearch(tiles, this, start, goal);`
`55`	`56`	`path = aStarSearch.search();`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`public ArrayList<Tile> getPath() {`
`59`		`- // find the path and store it in path arraylist`
`60`	`60`
	`61`	`+ // find the path and store it in path arraylist`
`61`	`62`	`if(path == null){`
`62`	`63`	`this.search();`
`63`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,10 @@`
`13`	`13`	`public class App {`
`14`	`14`	`public static void main(String[] args) throws Exception {`
`15`	`15`	`Game game = new Game();`
`16`		`- JFrame frame = new JFrame("A2_P1");`
	`16`	`+ JFrame frame = new JFrame("A2_Q1");`
`17`	`17`	`frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);`
`18`	`18`	`frame.setSize(900, 700);`
`19`		`-`
`20`	`19`	`frame.add(game);`
`21`		`- // frame.pack();`
`22`	`20`	`frame.setVisible(true);`
`23`	`21`	`}`
`24`	`22`	`}`