WF agent shared memory graph implementation

src/main/java/app/model/agents/AgentImp.java

@@ -4,7 +4,6 @@
 import app.controller.linAlg.Intersection;
 import app.controller.linAlg.Vector;
 import app.controller.linAlg.VectorSet;
-import app.controller.soundEngine.SoundRay;
 import app.controller.soundEngine.SoundVector;
 import app.model.Move;
 import app.model.agents.Cells.GraphCell;
@@ -14,7 +13,6 @@
 import javafx.scene.paint.Color;
 import lombok.Getter;
 import lombok.Setter;
-import org.jgrapht.graph.DefaultEdge;
 import org.jgrapht.graph.DefaultWeightedEdge;
 
 import java.util.ArrayList;
@@ -35,7 +33,7 @@ public class AgentImp implements Agent
     @Getter protected VectorSet seen;
     @Getter protected AgentView agentViewWindow;
 
-    @Getter protected static MemoryGraph<GraphCell, DefaultWeightedEdge> world;
+    @Getter @Setter protected static MemoryGraph<GraphCell, DefaultWeightedEdge> world;
 
     public AgentImp(Vector position, Vector direction, double radius, Team team)
     {

src/main/java/app/model/agents/Cells/GraphCell.java

@@ -66,4 +66,10 @@ public boolean equals(Object obj)
         }
         return false;
     }
+
+    @Override
+    public String toString()
+    {
+        return XY;
+    }
 }

src/main/java/app/model/agents/MemoryGraph.java

@@ -2,19 +2,22 @@
 
 import app.controller.linAlg.Vector;
 import app.model.agents.Cells.GraphCell;
-
 import lombok.Getter;
-import org.jgrapht.Graph;
+import lombok.Setter;
 import org.jgrapht.graph.SimpleWeightedGraph;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 
 public class MemoryGraph<Object, DefaultWeightedEdge> extends SimpleWeightedGraph
 {
     @Getter private HashMap<String, GraphCell> vertices = new HashMap<>();
     @Getter private HashMap<String, Vector> cardinalDirections = new HashMap<>();
-    private int travelDistance;
+    @Getter private int travelDistance;
+
+    @Getter @Setter private GraphCell initialWallFollowPos;
     @Getter private double obstaclePheromoneValue = 1000.0;
 
     public MemoryGraph(int distance)
@@ -38,7 +41,7 @@ public void add_or_adjust_Vertex(Vector position)
         }
     }
 
-    private GraphCell addNewVertex(Vector position)
+    protected GraphCell addNewVertex(Vector position)
     {
         Vector vertexCentre = determineVertexCentre(position);
         GraphCell cell = new GraphCell(vertexCentre);
@@ -65,12 +68,12 @@ public void setVertexAsObstacle(Vector currentPosition, Vector movement)
         obstacleVertex.setPheromone(obstaclePheromoneValue);
     }
 
-    private void modifyVertex(GraphCell cell)
+    protected void modifyVertex(GraphCell cell)
     {
         cell.setOccupied(true);
     }
 
-    private void connectNeighbouringVertices(GraphCell currentCell)
+    protected void connectNeighbouringVertices(GraphCell currentCell)
     {
         Vector currentPosition = currentCell.getPosition();
         for(Vector cardinal: cardinalDirections.values())
@@ -121,18 +124,24 @@ public void leaveVertex(Vector position, double pheromoneValue)
         cell.updatePheromone(pheromoneValue);
     }
 
+    public void leaveVertex(Vector position)
+    {
+        GraphCell cell = getVertexAt(position);
+        cell.setOccupied(false);
+    }
+
     public GraphCell getVertexAt(Vector position)
     {
         return vertices.get(keyGenerator(position));
     }
 
-    private String keyGenerator(Vector position)
+    protected String keyGenerator(Vector position)
     {
         Vector centrePosition = determineVertexCentre(position);
         return centrePosition.getX() + " " + centrePosition.getY();
     }
 
-    private Vector determineVertexCentre(Vector position)
+    protected Vector determineVertexCentre(Vector position)
     {
         int x_centre = calculateDimensionCentre(position.getX());
         int y_centre = calculateDimensionCentre(position.getY());
@@ -170,4 +179,57 @@ public void evaporateWorld()
             cell.evaporate();
         }
     }
+
+    public ArrayList<GraphCell> getVerticesWithUnexploredNeighbours()
+    {
+        // TODO currently checking if vertex has less than 4 neighbours
+        //  but should also check if they're direct neighbours or neighbours through portals?
+        ArrayList<GraphCell> unexploredFrontier = new ArrayList<>();
+        for (String v : vertices.keySet())
+        {
+            GraphCell vertex = vertices.get(v);
+            if (!vertex.getObstacle() && edgesOf(vertex).size() < 4)
+            {
+                unexploredFrontier.add(vertex);
+            }
+        }
+        return unexploredFrontier;
+    }
+
+    public Vector getNeighbourDir(GraphCell agentCell, GraphCell neighbour)
+    {
+        if (agentCell.getX() == neighbour.getX() && neighbour.getY() == agentCell.getY())
+        {
+            return new Vector(0,0);
+        }
+        else if (agentCell.getX() == neighbour.getX() && neighbour.getY() < agentCell.getY())
+        {
+            return new Vector(0,-1);  // north of agent
+        }
+        else if (agentCell.getX() == neighbour.getX() && neighbour.getY() > agentCell.getY())
+        {
+            return new Vector(0,1);  // south of agent
+        }
+        else if (agentCell.getY() == neighbour.getY() && neighbour.getX() < agentCell.getX())
+        {
+            return new Vector(-1,0);  // west of agent
+        }
+        else if (agentCell.getY() == neighbour.getY() && neighbour.getX() > agentCell.getX())
+        {
+            return new Vector(1,0);  // east of agent
+        }
+        return new Vector();
+    }
+
+    public String getDirectionStr(double directionAngle)
+    {
+        for (Map.Entry<String,Vector> dir : cardinalDirections.entrySet())
+        {
+            if (dir.getValue().getAngle() == directionAngle)
+            {
+                return dir.getKey();
+            }
+        }
+        throw new RuntimeException("No cardinal direction matches given angle.");
+    }
 }