Reformat imported code

3 files changed, 575 insertions, 595 deletions

diff --git a/src/ch/epfl/maze/simulation/DaedalusSimulation.java b/src/ch/epfl/maze/simulation/DaedalusSimulation.java
index 2082772..8b60b57 100644
--- a/src/ch/epfl/maze/simulation/DaedalusSimulation.java
+++ b/src/ch/epfl/maze/simulation/DaedalusSimulation.java
@@ -1,364 +1,349 @@
 package ch.epfl.maze.simulation;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
 import ch.epfl.maze.graphics.Animation;
-import ch.epfl.maze.physical.Animal;
-import ch.epfl.maze.physical.Daedalus;
-import ch.epfl.maze.physical.Predator;
-import ch.epfl.maze.physical.Prey;
-import ch.epfl.maze.physical.World;
+import ch.epfl.maze.physical.*;
 import ch.epfl.maze.util.Action;
 import ch.epfl.maze.util.Direction;
 import ch.epfl.maze.util.Vector2D;
 
+import java.util.*;
+
 /**
  * Simulation of a predation environment. Handles the next moves of every
  * predator and prey in a Daedalus, as well as the animation by notifying
  * changes to it. The simulation finishes when every prey has been caught.
- * 
  */
 
 public final class DaedalusSimulation implements Simulation {
 
-        /* limit to the step counter, over which the animals are considered lost */
-        public static final int COUNTER_LIMIT = 10000;
-
-        /* simulation components */
-        private Daedalus mDaedalus;
-        private Map<Integer, List<Prey>> mArrivalTimes;
-        private int mStepCounter;
-
-        /* collision check variables */
-        private Map<Prey, List<Vector2D>> mPreyMoves;
-        private Map<Predator, List<Vector2D>> mPredatorMoves;
-
-        /**
-         * Constructs a simulation with a {@code Daedalus} to simulate.
-         * 
-         * @param daedalus
-         *            The daedalus to simulate
-         */
-
-        public DaedalusSimulation(Daedalus daedalus) {
-                mDaedalus = daedalus;
-                mArrivalTimes = new TreeMap<Integer, List<Prey>>(Collections.reverseOrder());
-                mStepCounter = 0;
-                mPreyMoves = new HashMap<Prey, List<Vector2D>>();
-                mPredatorMoves = new HashMap<Predator, List<Vector2D>>();
-        }
-
-        @Override
-        public void move(Animation listener) {
-                if (isOver()) {
-                        return;
-                }
-
-                // clears moves maps
-                mPreyMoves.clear();
-                mPredatorMoves.clear();
-
-                // increments counter
-                mStepCounter++;
-
-                // if counter exceeded the limit, it considers preys safe
-                if (mStepCounter > COUNTER_LIMIT) {
-                        List<Prey> preys = mDaedalus.getPreys();
-                        List<Prey> safePreys = new LinkedList<Prey>();
-                        for (Prey prey : preys) {
-                                mDaedalus.removePrey(prey);
-                                safePreys.add(prey);
-                        }
-
-                        mArrivalTimes.put(Integer.MAX_VALUE, safePreys); // infinite
-                        return;
-                }
-
-                // asks predators and preys to move
-                movePredators(listener);
-                movePreys(listener);
-
-                // checks collisions
-                checkCollisions(listener);
-
-                // notifies animation that all the changes are done
-                if (listener != null) {
-                        listener.doneUpdating();
-                }
-        }
-
-        @Override
-        public boolean isOver() {
-                return mDaedalus.isSolved();
-        }
-
-        @Override
-        public World getWorld() {
-                return mDaedalus;
-        }
-
-        @Override
-        public int getSteps() {
-                return mStepCounter;
-        }
-
-        @Override
-        public Map<Integer, List<Animal>> getArrivalTimes() {
-                TreeMap<Integer, List<Animal>> arrivalTimes = new TreeMap<Integer, List<Animal>>();
-                for (Map.Entry<Integer, List<Prey>> entry : mArrivalTimes.entrySet()) {
-                        int time = entry.getKey();
-                        List<Animal> animals = new ArrayList<Animal>(entry.getValue());
-                        arrivalTimes.put(time, animals);
-                }
-
-                return arrivalTimes;
-        }
-
-        @Override
-        public String getRecordTable() {
-                String recordTable = "";
-                int position = 1;
-                for (Map.Entry<Integer, List<Prey>> entry : mArrivalTimes.entrySet()) {
-                        // only returns the 10 first
-                        if (position > 10) {
-                                return recordTable;
-                        }
-
-                        for (Prey prey : entry.getValue()) {
+    /* limit to the step counter, over which the animals are considered lost */
+    public static final int COUNTER_LIMIT = 10000;
+
+    /* simulation components */
+    private Daedalus mDaedalus;
+    private Map<Integer, List<Prey>> mArrivalTimes;
+    private int mStepCounter;
+
+    /* collision check variables */
+    private Map<Prey, List<Vector2D>> mPreyMoves;
+    private Map<Predator, List<Vector2D>> mPredatorMoves;
+
+    /**
+     * Constructs a simulation with a {@code Daedalus} to simulate.
+     *
+     * @param daedalus The daedalus to simulate
+     */
+
+    public DaedalusSimulation(Daedalus daedalus) {
+        mDaedalus = daedalus;
+        mArrivalTimes = new TreeMap<Integer, List<Prey>>(Collections.reverseOrder());
+        mStepCounter = 0;
+        mPreyMoves = new HashMap<Prey, List<Vector2D>>();
+        mPredatorMoves = new HashMap<Predator, List<Vector2D>>();
+    }
+
+    @Override
+    public void move(Animation listener) {
+        if (isOver()) {
+            return;
+        }
+
+        // clears moves maps
+        mPreyMoves.clear();
+        mPredatorMoves.clear();
+
+        // increments counter
+        mStepCounter++;
+
+        // if counter exceeded the limit, it considers preys safe
+        if (mStepCounter > COUNTER_LIMIT) {
+            List<Prey> preys = mDaedalus.getPreys();
+            List<Prey> safePreys = new LinkedList<Prey>();
+            for (Prey prey : preys) {
+                mDaedalus.removePrey(prey);
+                safePreys.add(prey);
+            }
+
+            mArrivalTimes.put(Integer.MAX_VALUE, safePreys); // infinite
+            return;
+        }
+
+        // asks predators and preys to move
+        movePredators(listener);
+        movePreys(listener);
+
+        // checks collisions
+        checkCollisions(listener);
+
+        // notifies animation that all the changes are done
+        if (listener != null) {
+            listener.doneUpdating();
+        }
+    }
+
+    @Override
+    public boolean isOver() {
+        return mDaedalus.isSolved();
+    }
+
+    @Override
+    public World getWorld() {
+        return mDaedalus;
+    }
+
+    @Override
+    public int getSteps() {
+        return mStepCounter;
+    }
+
+    @Override
+    public Map<Integer, List<Animal>> getArrivalTimes() {
+        TreeMap<Integer, List<Animal>> arrivalTimes = new TreeMap<Integer, List<Animal>>();
+        for (Map.Entry<Integer, List<Prey>> entry : mArrivalTimes.entrySet()) {
+            int time = entry.getKey();
+            List<Animal> animals = new ArrayList<Animal>(entry.getValue());
+            arrivalTimes.put(time, animals);
+        }
+
+        return arrivalTimes;
+    }
+
+    @Override
+    public String getRecordTable() {
+        String recordTable = "";
+        int position = 1;
+        for (Map.Entry<Integer, List<Prey>> entry : mArrivalTimes.entrySet()) {
+            // only returns the 10 first
+            if (position > 10) {
+                return recordTable;
+            }
+
+            for (Prey prey : entry.getValue()) {
+                if (entry.getKey() == Integer.MIN_VALUE) {