Import project structure

7 files changed, 1165 insertions, 0 deletions

diff --git a/src/ch/epfl/maze/tests/AnimalTest.java b/src/ch/epfl/maze/tests/AnimalTest.java
new file mode 100644
index 0000000..c4c9220
--- /dev/null
+++ b/src/ch/epfl/maze/tests/AnimalTest.java
@@ -0,0 +1,100 @@
+package ch.epfl.maze.tests;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import ch.epfl.maze.physical.Animal;
+import ch.epfl.maze.util.Direction;
+import ch.epfl.maze.util.Vector2D;
+
+/**
+ * Test case for {@code Animal} implementation.
+ * 
+ */
+
+public class AnimalTest extends TestCase {
+
+        /**
+         * Test case for {@code getPosition()}.
+         */
+
+        @Test
+        public void testGetPosition() {
+                Animal animal = new MockAnimal(new Vector2D(2, 1));
+
+                // checks getPosition()
+                assertEquals(new Vector2D(2, 1), animal.getPosition());
+        }
+
+        /**
+         * Test case for {@code setPosition(Vector2D position)}.
+         */
+
+        @Test
+        public void testSetPosition() {
+                Animal animal = new MockAnimal(new Vector2D(2, 1));
+
+                // checks setPosition(Vector2D position)
+                animal.setPosition(new Vector2D(3, 5));
+                assertEquals(new Vector2D(3, 5), animal.getPosition());
+        }
+
+        /**
+         * Test case for {@code update(Direction dir)}.
+         */
+
+        @Test
+        public void testUpdate() {
+                Animal animal = new MockAnimal(new Vector2D(2, 1));
+
+                // checks update(Direction dir) with NONE
+                animal.update(Direction.NONE);
+                assertEquals(new Vector2D(2, 1), animal.getPosition());
+
+                // checks update(Direction dir) with DOWN
+                animal.update(Direction.DOWN);
+                assertEquals(new Vector2D(2, 2), animal.getPosition());
+
+                // checks update(Direction dir) with UP
+                animal.update(Direction.UP);
+                assertEquals(new Vector2D(2, 1), animal.getPosition());
+
+                // checks update(Direction dir) with RIGHT
+                animal.update(Direction.RIGHT);
+                assertEquals(new Vector2D(3, 1), animal.getPosition());
+
+                // checks update(Direction dir) with LEFT
+                animal.update(Direction.LEFT);
+                assertEquals(new Vector2D(2, 1), animal.getPosition());
+        }
+
+        /**
+         * Mock class that makes {@code Animal} concrete.
+         * 
+         */
+
+        private class MockAnimal extends Animal {
+
+                /**
+                 * Creates a concrete instance of the {@code Animal} class.
+                 * 
+                 * @param labyrinth
+                 *            Actual maze
+                 */
+
+                public MockAnimal(Vector2D position) {
+                        super(position);
+                }
+
+                @Override
+                public Direction move(Direction[] choices) {
+                        return null;
+                }
+
+                @Override
+                public Animal copy() {
+                        return null;
+                }
+        }
+}
diff --git a/src/ch/epfl/maze/tests/Competition.java b/src/ch/epfl/maze/tests/Competition.java
new file mode 100644
index 0000000..4ed42b6
--- /dev/null
+++ b/src/ch/epfl/maze/tests/Competition.java
@@ -0,0 +1,163 @@
+package ch.epfl.maze.tests;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import ch.epfl.maze.physical.Animal;
+import ch.epfl.maze.physical.Maze;
+import ch.epfl.maze.physical.zoo.Bear;
+import ch.epfl.maze.physical.zoo.Hamster;
+import ch.epfl.maze.physical.zoo.Monkey;
+import ch.epfl.maze.physical.zoo.Mouse;
+import ch.epfl.maze.physical.zoo.Panda;
+import ch.epfl.maze.physical.zoo.SpaceInvader;
+import ch.epfl.maze.simulation.MazeSimulation;
+import ch.epfl.maze.simulation.Simulation;
+import ch.epfl.maze.util.LabyrinthGenerator;
+
+/**
+ * Competition of the {@code SpaceInvader} against the other animals.
+ * <p>
+ * The rules are the following :
+ * <ul>
+ * <li>The {@code SpaceInvader} will be confronted to every animal at the same
+ * time in one simulation.</li>
+ * <li>The result will be the outcomes of 1,000 rounds.</li>
+ * <li>If the {@code SpaceInvader} exits the maze earlier than one animal, it
+ * will earn 1 point in the rivalry against it. If it exits later, then it will
+ * lose 1 point in this rivalry. In case of draw, it will earn no points.</li>
+ * <li>After the 1,000 simulations, the {@code SpaceInvader} will be declared
+ * winner against one animal if it obtained a positive score in the rivalry
+ * against it.</li>
+ * </ul>
+ *
+ */
+
+public class Competition {
+
+        static final String COMPETITION_MAZE_FILE = "labyrinth.txt";
+        static final int NUMBER_OF_ROUNDS = 1000;
+        static HashMap<String, Integer> rivalries;
+
+        /**
+         * Launches the competition between the {@code SpaceInvader} and the other
+         * animals.
+         */
+
+        @BeforeClass
+        public static void setUpClass() {
+                int[][] labyrinth = LabyrinthGenerator.readFromFile(COMPETITION_MAZE_FILE);
+                Maze m = new Maze(labyrinth);
+                Simulation simulation = new MazeSimulation(m);
+
+                // adds a Mouse
+                m.addAnimal(new Mouse(m.getStart()));
+
+                // adds a Monkey
+                m.addAnimal(new Monkey(m.getStart()));
+
+                // adds a Hamster
+                m.addAnimal(new Hamster(m.getStart()));
+
+                // adds a Bear (if coded)
+                // m.addAnimal(new Bear(m.getStart()));
+
+                // adds a Panda
+                m.addAnimal(new Panda(m.getStart()));
+
+                // adds a Space Invader
+                m.addAnimal(new SpaceInvader(m.getStart()));
+
+                rivalries = new HashMap<String, Integer>();
+                rivalries.put("Mouse", 0);
+                rivalries.put("Hamster", 0);
+                rivalries.put("Monkey", 0);
+                //rivalries.put("Bear", 0); // if coded
+                rivalries.put("Panda", 0);
+
+                System.out.print("Launching competition, please wait... ");
+                for (int i = 0; i < NUMBER_OF_ROUNDS; i++) {
+                        simulation.restart();
+                        while (!simulation.isOver()) {
+                                simulation.move(null);
+                        }
+
+                        int result = MazeSimulation.COUNTER_LIMIT;
+                        Map<Integer, List<Animal>> arrivalTimes = simulation.getArrivalTimes();
+                        for (Map.Entry<Integer, List<Animal>> entry : arrivalTimes.entrySet()) {
+                                for (Animal a : entry.getValue()) {
+                                        if (a.getClass() == SpaceInvader.class) {
+                                                result = entry.getKey();
+                                        }
+                                }
+                        }
+
+                        for (Map.Entry<Integer, List<Animal>> entry : arrivalTimes.entrySet()) {
+                                for (Animal a : entry.getValue()) {
+                                        String animalName = a.getClass().getSimpleName();
+                                        if (!"SpaceInvader".equals(animalName)) {
+                                                int score = rivalries.get(animalName);
+                                                int adversary = entry.getKey();
+                                                if (adversary < result) {
+                                                        rivalries.put(animalName, --score);
+                                                } else if (adversary > result) {
+                                                        rivalries.put(animalName, ++score);