365 baseline evasion agents

src/main/java/app/controller/linAlg/Intersection.java

@@ -155,6 +155,16 @@ public static boolean hasIntersection(Vector p_1, Vector p_2, Vector p_3, Vector
         return findIntersection(p_1, p_2, p_3, p_4) != null;
     }
 
+    public static boolean hasIntersection(Line l1, Line l2)
+    {
+        return findIntersection(l1.a, l1.b, l2.a, l2.b) != null;
+    }
+
+    public static Vector findIntersection(Line l1, Line l2)
+    {
+        return findIntersection(l1.a, l1.b, l2.a, l2.b);
+    }
+
     public static boolean hasIntersection(Vector a, Vector b, Ray r)
     {
         return findIntersection(a, b, r) != null;

src/main/java/app/controller/linAlg/Line.java

@@ -1,13 +1,14 @@
 package app.controller.linAlg;
 
-import app.model.agents.Agent;
 import lombok.AllArgsConstructor;
+import lombok.ToString;
 
 @AllArgsConstructor
+@ToString
 public class Line
 {
-    private Vector a;
-    private Vector b;
+    public Vector a;
+    public Vector b;
 
     public boolean liesOn(Vector v)
     {

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

@@ -10,8 +10,8 @@
 import app.model.Type;
 import app.model.agents.Capture.BaselineCaptureAgent;
 import app.model.agents.Capture.CaptureAgent;
+import app.model.agents.Evasion.*;
 import app.model.agents.Capture.DijkstraCaptureAgent;
-import app.model.agents.Evasion.EvasionAgent;
 import app.view.agentView.AgentView;
 import app.view.simulation.Info;
 import javafx.scene.canvas.GraphicsContext;
@@ -283,7 +283,7 @@ public Agent nextState()
         else if(this.type == Type.INTRUDER)
         {
             if(isTypeSeen(Type.GUARD))
-                return new EvasionAgent(this);
+                return new RunAwayAgent(this);
 
             if(isTypeSeen(Type.TARGET))
                 return new TargetAgent(this);

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

@@ -3,9 +3,9 @@
 import app.controller.linAlg.Vector;
 import app.model.Type;
 import app.model.agents.ACO.*;
-import app.model.agents.Capture.DijkstraCaptureAgent;
-import app.model.agents.Evasion.EvasionAgent;
-import app.model.agents.Evasion.EvasionStrategy;
+import app.model.agents.Evasion.*;
+import app.model.agents.Capture.*;
+
 import app.model.agents.WallFollow.WFMedDirHeuristic;
 import app.model.agents.WallFollow.WFHighDirHeuristic;
 import app.model.agents.WallFollow.WallFollowAgent;
@@ -21,7 +21,9 @@ public enum AgentType
     WALL_FOLLOW,
     EVASION_RANDOM,
     EVASION_DIRECTED,
-    EVASION_RANDOMDIRECTED,
+    EVASION_DISTANCE_MAX,
+    EVASION_HIDEY,
+    EVASION_RUNAWAY,
     WALL_FOLLOW_MED_DIR_HEURISTIC,
     WALL_FOLLOW_HIGH_DIR_HEURISTIC,
     CAPTURE_DIJKSTRA,
@@ -53,28 +55,30 @@ public static Agent agentOf(AgentType agentType, Vector position, Vector directi
                 return new WallFollowAgent(position, direction, radius, type, 20);
             }
             case EVASION_RANDOM -> {
-                return new EvasionAgent(position, direction, radius, type, EvasionStrategy.RANDOM);
+                return new EvasionRandom(position, direction, radius, type);
             }
             case EVASION_DIRECTED -> {
-                return new EvasionAgent(position, direction, radius, type, EvasionStrategy.DIRECTED);
+                return new EvasionDirected(position, direction, radius, type);
+            }
+            case EVASION_DISTANCE_MAX -> {
+                return new EvasionDistanceMax(position, direction, radius, type);
+            }
+            case EVASION_HIDEY -> {
+                return new HideyAgent(position, direction, radius, type);
             }
-            case EVASION_RANDOMDIRECTED -> {
-                return new EvasionAgent(position, direction, radius, type, EvasionStrategy.RANDOMDIRECTED);
+            case EVASION_RUNAWAY -> {
+                return new RunAwayAgent(position, direction, radius, type);
             }
-            case WALL_FOLLOW_MED_DIR_HEURISTIC ->
-            {
+            case WALL_FOLLOW_MED_DIR_HEURISTIC -> {
                 return new WFMedDirHeuristic(position, direction, radius, type, 20);
             }
-            case WALL_FOLLOW_HIGH_DIR_HEURISTIC ->
-            {
+            case WALL_FOLLOW_HIGH_DIR_HEURISTIC -> {
                 return new WFHighDirHeuristic(position, direction, radius, type, 20);
             }
-            case CAPTURE_DIJKSTRA ->
-            {
+            case CAPTURE_DIJKSTRA -> {
                  return new DijkstraCaptureAgent(position, direction, radius, type, 20);
             }
-            case RANDOM ->
-            {
+            case RANDOM -> {
                 return new AgentImp(position, direction, radius, type);
             }
             default -> throw new RuntimeException("Agent type not recognized");

src/main/java/app/model/agents/Evasion/EvasionDirected.java

@@ -0,0 +1,66 @@
+package app.model.agents.Evasion;
+
+import app.controller.linAlg.Vector;
+import app.model.Move;
+import app.model.Type;
+import app.model.agents.Agent;
+
+public class EvasionDirected extends EvasionRandom
+{
+    protected Vector intelligentDirection;
+    protected boolean intelligenceFlag = false;
+
+    public EvasionDirected(Vector position, Vector direction, double radius, Type type)
+    {
+        super(position, direction, radius, type);
+    }
+
+    public EvasionDirected(Agent other)
+    {
+        super(other);
+    }
+
+    @Override
+    public Move move()
+    {
+        if(moveFailed)
+        {
+            direction = direction.rotate(90);
+            return super.nextMove();
+        }
+        else
+        {
+            updateKnowledge();
+            return nextMove();
+        }
+    }
+
+    @Override
+    protected Move nextMove()
+    {
+        if(intelligenceFlag)
+        {
+            return new Move(intelligentDirection.normalise(), intelligentDirection);
+        }
+        return super.nextMove();
+    }
+
+    @Override
+    protected void updateKnowledge()
+    {
+        Vector closestGuardSeen = closestTypePos(Type.GUARD);
+
+        if(closestGuardSeen != null)
+        {
+            counter = 0;
+            Vector safeDirection = position.sub(closestGuardSeen);
+            intelligentDirection = safeDirection.normalise().scale(moveLength);
+            intelligenceFlag = true;
+        }
+        else
+        {
+            counter ++;
+            intelligenceFlag = false;
+        }
+    }
+}