Use Set instead of array for Direction choices

13 files changed, 158 insertions, 98 deletions

diff --git a/src/ch/epfl/maze/physical/Animal.java b/src/ch/epfl/maze/physical/Animal.java
index 34a1136..04c4baf 100644
--- a/src/ch/epfl/maze/physical/Animal.java
+++ b/src/ch/epfl/maze/physical/Animal.java
@@ -3,6 +3,10 @@ package ch.epfl.maze.physical;
 import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.Set;
+
 /**
  * Animal inside a {@code World} that can move depending on the available
  * choices it has at its position.
@@ -44,7 +48,20 @@ abstract public class Animal {
      *                World.getChoices(Vector2D)})
      * @return The next direction of the animal, chosen in {@code choices}
      */
-    abstract public Direction move(Direction[] choices);
+    abstract public Direction move(Set<Direction> choices);
+
+    /**
+     * Retrieves the next direction of the animal, by selecting one choice among
+     * the ones available from its position.
+     *
+     * @param choices The choices left to the animal at its current position (see
+     *                {@link ch.epfl.maze.physical.World#getChoices(Vector2D)
+     *                World.getChoices(Vector2D)})
+     * @return The next direction of the animal, chosen in {@code choices}
+     */
+    public final Direction move(Direction[] choices) {
+        return this.move(EnumSet.copyOf(Arrays.asList(choices)));
+    }
 
     /**
      * Updates the animal position with a direction.
diff --git a/src/ch/epfl/maze/physical/GhostPredator.java b/src/ch/epfl/maze/physical/GhostPredator.java
index e4a64b3..c1cfca8 100644
--- a/src/ch/epfl/maze/physical/GhostPredator.java
+++ b/src/ch/epfl/maze/physical/GhostPredator.java
@@ -3,8 +3,8 @@ package ch.epfl.maze.physical;
 import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.EnumSet;
+import java.util.Set;
 
 /**
  * Predator ghost that have two different modes and a home position in the labyrinth.
@@ -138,11 +138,11 @@ abstract public class GhostPredator extends Predator {
      * Selects the best Direction in the given choices by minimizing the Euclidean distance to the targeted position.
      *
      * @param targetPosition The targeted position
-     * @param choices        An array of Direction choices
-     * @return An array of optimal Direction choices
+     * @param choices        A set of Direction choices
+     * @return A set of optimal Direction choices
      */
-    private Direction[] selectBestPaths(Vector2D targetPosition, Direction[] choices) {
-        List<Direction> bestPaths = new ArrayList<>();
+    private Set<Direction> selectBestPaths(Vector2D targetPosition, Set<Direction> choices) {
+        Set<Direction> bestPaths = EnumSet.noneOf(Direction.class);
         double minDist = Double.MAX_VALUE;
 
         for (Direction dir : choices) {
@@ -157,7 +157,7 @@ abstract public class GhostPredator extends Predator {
                 bestPaths.add(dir);
         }
 
-        return bestPaths.toArray(new Direction[bestPaths.size()]);
+        return bestPaths;
     }
 
     /**
@@ -179,11 +179,11 @@ abstract public class GhostPredator extends Predator {
     }
 
     @Override
-    public Direction move(Direction[] choices, Daedalus daedalus) {
+    public Direction move(Set<Direction> choices, Daedalus daedalus) {
         this.countCycle();
 
-        Direction[] smartChoices = choices.length > 1 ? this.excludeOrigin(choices) : choices;
-        Direction[] bestPaths = this.selectBestPaths(this.getTargetPosition(daedalus), smartChoices);
+        Set<Direction> smartChoices = choices.size() > 1 ? this.excludeOrigin(choices) : choices;
+        Set<Direction> bestPaths = this.selectBestPaths(this.getTargetPosition(daedalus), smartChoices);
         return this.move(bestPaths);
     }
 
diff --git a/src/ch/epfl/maze/physical/Predator.java b/src/ch/epfl/maze/physical/Predator.java
index 0b20ca0..5f0a3bb 100644
--- a/src/ch/epfl/maze/physical/Predator.java
+++ b/src/ch/epfl/maze/physical/Predator.java
@@ -3,6 +3,10 @@ package ch.epfl.maze.physical;
 import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.Set;
+
 /**
  * Predator that kills a prey when they meet with each other in the labyrinth.
  *
@@ -34,6 +38,24 @@ abstract public class Predator extends ProbabilisticAnimal {
      * @param daedalus The world in which the animal moves
      * @return The next direction of the animal, chosen in {@code choices}
      */
-    abstract public Direction move(Direction[] choices, Daedalus daedalus);
+    abstract public Direction move(Set<Direction> choices, Daedalus daedalus);
+
+    /**
+     * Retrieves the next direction of the animal, by selecting one choice among
+     * the ones available from its position.
+     * <p>
+     * In this variation, the animal knows the world entirely. It can therefore
+     * use the position of other animals in the daedalus to hunt more
+     * effectively.
+     *
+     * @param choices  The choices left to the animal at its current position (see
+     *                 {@link ch.epfl.maze.physical.World#getChoices(Vector2D)
+     *                 World.getChoices(Vector2D)})
+     * @param daedalus The world in which the animal moves
+     * @return The next direction of the animal, chosen in {@code choices}
+     */
+    public final Direction move(Direction[] choices, Daedalus daedalus) {
+        return this.move(EnumSet.copyOf(Arrays.asList(choices)), daedalus);
+    }
 
 }
diff --git a/src/ch/epfl/maze/physical/Prey.java b/src/ch/epfl/maze/physical/Prey.java
index 26fe92b..3654807 100644
--- a/src/ch/epfl/maze/physical/Prey.java
+++ b/src/ch/epfl/maze/physical/Prey.java
@@ -3,6 +3,10 @@ package ch.epfl.maze.physical;
 import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.Set;
+
 /**
  * Prey that is killed by a predator when they meet each other in the labyrinth.
  *
@@ -34,6 +38,24 @@ abstract public class Prey extends ProbabilisticAnimal {
      * @param daedalus The world in which the animal moves
      * @return The next direction of the animal, chosen in {@code choices}
      */
-    abstract public Direction move(Direction[] choices, Daedalus daedalus);
+    abstract public Direction move(Set<Direction> choices, Daedalus daedalus);
+
+    /**
+     * Retrieves the next direction of the animal, by selecting one choice among
+     * the ones available from its position.
+     * <p>
+     * In this variation, the animal knows the world entirely. It can therefore
+     * use the position of other animals in the daedalus to evade predators more
+     * effectively.
+     *
+     * @param choices  The choices left to the animal at its current position (see
+     *                 {@link ch.epfl.maze.physical.World#getChoices(Vector2D)
+     *                 World.getChoices(Vector2D)})
+     * @param daedalus The world in which the animal moves
+     * @return The next direction of the animal, chosen in {@code choices}
+     */
+    public final Direction move(Direction[] choices, Daedalus daedalus) {
+        return this.move(EnumSet.copyOf(Arrays.asList(choices)), daedalus);
+    }
 
 }
diff --git a/src/ch/epfl/maze/physical/ProbabilisticAnimal.java b/src/ch/epfl/maze/physical/ProbabilisticAnimal.java
index 650cecf..e461e8c 100644
--- a/src/ch/epfl/maze/physical/ProbabilisticAnimal.java
+++ b/src/ch/epfl/maze/physical/ProbabilisticAnimal.java
@@ -4,8 +4,9 @@ import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
 import java.util.ArrayList;