Import project structure

5 files changed, 1294 insertions, 0 deletions

diff --git a/src/ch/epfl/maze/util/Action.java b/src/ch/epfl/maze/util/Action.java
new file mode 100644
index 0000000..491627f
--- /dev/null
+++ b/src/ch/epfl/maze/util/Action.java
@@ -0,0 +1,101 @@
+package ch.epfl.maze.util;
+
+/**
+ * Immutable action that encapsulates a choice made by an animal and information
+ * about it, such as if it was successful or not, and if the animal will die
+ * <i>while</i> performing it.
+ * 
+ */
+
+public final class Action {
+
+        /* variables defining the action */
+        private final Direction mDirection;
+        private final boolean mSuccess;
+        private final boolean mDies;
+
+        /**
+         * Constructs a successful action of an animal towards a specified
+         * direction, that does not die between two squares.
+         * 
+         * @param dir
+         *            Direction towards which the action needs to be performed
+         */
+
+        public Action(Direction dir) {
+                if (dir != null) {
+                        mDirection = dir;
+                } else {
+                        mDirection = Direction.NONE;
+                }
+                mSuccess = true;
+                mDies = false;
+        }
+
+        /**
+         * Constructs an action of an animal towards a specified direction, with a
+         * specified success, that does not die between two squares.
+         * 
+         * @param dir
+         *            Direction towards which the action needs to be performed
+         * @param successful
+         *            Determines whether this action was successful
+         */
+
+        public Action(Direction dir, boolean successful) {
+                mDirection = dir;
+                mSuccess = successful;
+                mDies = false;
+        }
+
+        /**
+         * Constructs an action of an animal towards a specified direction, with a
+         * specified success, and that also specifies if the animal dies between two
+         * squares.
+         * 
+         * @param dir
+         *            Direction towards which the action needs to be performed
+         * @param successful
+         *            Determines whether this action was successful
+         * @param dies
+         *            Determines whether the action will die between two squares
+         */
+
+        public Action(Direction dir, boolean successful, boolean dies) {
+                mDirection = dir;
+                mSuccess = successful;
+                mDies = dies;
+        }
+
+        /**
+         * Retrieves the direction towards which the action shall move.
+         * 
+         * @return Direction of the action
+         */
+
+        public Direction getDirection() {
+                return mDirection;
+        }
+
+        /**
+         * Determines if the action was successful or not.
+         * 
+         * @return <b>true</b> if the action was successful, <b>false</b> otherwise
+         */
+
+        public boolean isSuccessful() {
+                return mSuccess;
+        }
+
+        /**
+         * Determines if the animal performing the action dies while moving from a
+         * square to another.
+         * 
+         * @return <b>true</b> if the action dies between two squares, <b>false</b>
+         *         otherwise
+         */
+
+        public boolean diesBetweenSquares() {
+                return mDies;
+        }
+}
diff --git a/src/ch/epfl/maze/util/Direction.java b/src/ch/epfl/maze/util/Direction.java
new file mode 100644
index 0000000..a75ba7f
--- /dev/null
+++ b/src/ch/epfl/maze/util/Direction.java
@@ -0,0 +1,235 @@
+package ch.epfl.maze.util;
+
+/**
+ * Directions that an animal can take to move. They represent the four cardinal
+ * points ({@code DOWN, UP, RIGHT, LEFT}) from the frame of reference of the
+ * labyrinth, plus a default one : {@code NONE}.
+ * 
+ */
+
+public enum Direction {
+        DOWN, UP, RIGHT, LEFT, NONE;
+
+        /**
+         * Returns the integer value of the direction
+         * 
+         * @return Integer value of the direction
+         */
+
+        public int intValue() {
+                switch (this) {
+                case DOWN:
+                        return 0;
+
+                case UP:
+                        return 1;
+
+                case RIGHT:
+                        return 2;
+
+                case LEFT:
+                        return 3;
+
+                case NONE:
+                default:
+                        return 4;
+                }
+        }
+
+        /**
+         * Converts the direction into an orthonormal vector, when possible.
+         * 
+         * @return Orthonormal {@code Vector2D} that represents the direction.
+         */
+
+        public Vector2D toVector() {
+                switch (this) {
+                case DOWN:
+                        return new Vector2D(0, 1);
+
+                case UP:
+                        return new Vector2D(0, -1);
+
+                case RIGHT:
+                        return new Vector2D(1, 0);
+
+                case LEFT:
+                        return new Vector2D(-1, 0);
+
+                case NONE:
+                default:
+                        return new Vector2D(0, 0);
+                }
+        }
+
+        /**
+         * Reverses the direction.
+         * 
+         * @return The opposite direction.
+         */
+
+        public Direction reverse() {
+                switch (this) {
+                case DOWN:
+                        return UP;
+
+                case UP:
+                        return DOWN;
+
+                case RIGHT:
+                        return LEFT;
+
+                case LEFT:
+                        return RIGHT;
+
+                case NONE:
+                default:
+                        return NONE;
+                }
+        }
+
+        /**
+         * Determines whether the argument is the opposite of another.
+         * 
+         * @param d
+         *            The direction to compare with
+         * @return <b>true</b> if the direction is the opposite the argument,
+         *         <b>false</b> otherwise
+         */
+
+        public boolean isOpposite(Direction d) {
+                return this == d.reverse();
+        }
+
+        /**
+         * Converts the argument relative to the frame of reference given by the
+         * direction that calls the method.
+         * 
+         * @param dir
+         *            The direction to convert
+         * @return The direction converted to the frame of reference given by the
+         *         direction called.
+         */
+
+        public Direction relativeDirection(Direction dir) {
+                switch (this) {
+                case DOWN:
+                        return dir.reverse();
+
+                case UP:
+                        return dir;
+
+                case RIGHT: