3 files changed, 659 insertions, 0 deletions

diff --git a/src/ch/epfl/maze/simulation/DaedalusSimulation.java b/src/ch/epfl/maze/simulation/DaedalusSimulation.java
new file mode 100644
index 0000000..2082772
--- /dev/null
+++ b/src/ch/epfl/maze/simulation/DaedalusSimulation.java
@@ -0,0 +1,364 @@
+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.util.Action;
+import ch.epfl.maze.util.Direction;
+import ch.epfl.maze.util.Vector2D;
+
+/**
+ * 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()) {
+                                if (entry.getKey() == Integer.MIN_VALUE) {
+                                        recordTable += "-- ";
+                                        recordTable += prey.getClass().getSimpleName();
+                                        recordTable += " - never finished\n";
+                                } else {
+                                        recordTable += position + ". ";
+                                        recordTable += prey.getClass().getSimpleName();
+                                        if (entry.getKey() == Integer.MAX_VALUE) {
+                                                recordTable += " - has survived\n";
+                                        } else {
+                                                recordTable += " - " + entry.getKey() + " steps\n";
+                                        }
+                                }
+                        }
+                        position += entry.getValue().size();
+                }
+
+                return recordTable;
+        }
+
+        @Override
+        public void restart() {
+                mDaedalus.reset();
+                mArrivalTimes.clear();
+                mStepCounter = 0;
+        }
+
+        @Override
+        public void stop() {
+                List<Prey> forgottenPreys = new LinkedList<Prey>();
+                for (Prey prey : mDaedalus.getPreys()) {
+                        forgottenPreys.add(prey);
+                        mDaedalus.removePrey(prey);
+                }
+                mArrivalTimes.put(Integer.MIN_VALUE, forgottenPreys);
+        }
+
+        /**
+         * Moves the predators in the daedalus.
+         * 
+         * @param listener
+         *            The listener to which the function will notify the changes
+         *            (can be null)
+         */
+
+        private void movePredators(Animation listener) {
+                List<Predator> predators = mDaedalus.getPredators();
+                for (int i = 0; i < predators.size(); i++) {
+                        Predator predator = predators.get(i);
+                        Vector2D position = predator.getPosition();
+                        Vector2D newPosition = position;
+                        Direction[] choices = mDaedalus.getChoices(position);
+
+                        // tries to make predator move
+                        Direction choice;
+                        try {
+                                choice = predator.move(choices, mDaedalus);
+                                if (!predator.getPosition().equals(position)) {
+                                        System.err.println("Error : Predator position changed while choosing direction.");
+                                        System.err.println("\tDid you call setPosition(Vector2D) or update(Direction) ?\n");
+                                        predator.setPosition(position);
+                                        choice = null;
+                                }
+                        } catch (Exception E) {
+                                System.err.print("Exception occurred while moving animals: ");
+                                E.printStackTrace();
+                                choice = null;
+                        }
+
+                        // if predator could move
+                        Action action;
+                        if (choice != null) {
+                                newPosition = position.addDirectionTo(choice);
+
+                                int x = newPosition.getX();
+                                int y = newPosition.getY();
+
+                                if (mDaedalus.isFree(x, y)) {