adding some refacoring stuffs.

Author: Kun Cai

README.md

@@ -7,4 +7,6 @@
 
 2) assume robot can only move through spaces " " within the maze
 3) the explorer should search for a path from the starting position "S" to the "F" position until it finds one or until it exhausts all possibilities. 
-In addition, it should mark the path it finds (if any) in the maze.
+In addition, it should mark the path it finds (if any) in the maze.
+4) assume the maze map is sealed completed in a way that no empty spaces are allowed in each edge of the maze map.
+5) assume the explorer will randomly select an open route to proceed if there were more than one adjacent empty spaces to current square/cell.

maze.iml

@@ -7,11 +7,14 @@
       <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
       <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" type="java-test-resource" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="Maven: junit:junit:4.6" level="project" />
+    <orderEntry type="library" name="Maven: junit:junit:4.9" level="project" />
+    <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.1" level="project" />
+    <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-all:1.3" level="project" />
   </component>
 </module>
 

pom.xml

@@ -12,7 +12,14 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.6</version>
+            <version>4.9</version>
         </dependency>
+
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-all</artifactId>
+            <version>1.3</version>
+        </dependency>
+
     </dependencies>
 </project>

src/main/java/uk/gov/dwp/maze/AppMain.java

@@ -0,0 +1,16 @@
+package uk.gov.dwp.maze;
+
+/**
+ * Created by User on 28/10/2014.
+ */
+public class AppMain {
+
+    public static void main(String[] args) {
+        MazeBuilder builder = new FileMazeBuilder("src/main/resources/maze3.txt");
+        Maze maze = builder.build();
+        System.out.println(maze);
+
+        Explorer e = new Explorer(maze);
+        e.exploreMaze();
+    }
+}

src/main/java/uk/gov/dwp/maze/Direction.java

@@ -6,20 +6,66 @@ public class Explorer {
 
     private boolean backward;
     private boolean done;
-    private int[] movement;
     private Maze maze;
 
-    public Explorer() {
+    public Explorer(Maze maze) {
+        if (maze == null)
+            throw new IllegalArgumentException("Null maze in explorer.");
 
+        this.maze = maze;
     }
 
-    public void exploreMaze(Maze m){
-        this.maze = m;
-        if (move(3, 3)) {
+    public void exploreMaze() {
+        Square startSquare = maze.getStartSquare();
+        if (move(startSquare.getRow(), startSquare.getColumn())) {
             System.out.println(maze);
         }
     }
 
+    /**
+     * print the accumulated paths lead to the 'F' point.
+     */
+    public String printExplorersPath() {
+        StringBuilder result = new StringBuilder(maze.getWidth() * maze.getHeight());
+
+        Square[][] map = maze.getSquare();
+        for (int row = 0; row < maze.getHeight(); row++) {
+            for (int col = 0; col < maze.getWidth(); col++) {
+
+                if (map[row][col].isWalled()) {
+                    result.append('X');
+                } else if (map[row][col].isStart()) {
+                    result.append('S');
+                } else if (map[row][col].isExit()) {
+                    result.append('F');
+                } else if (maze.getPath().isOnPath(maze.getSquare(row, col))) {
+                    result.append('.');
+                } else {
+                    result.append(' ');
+                }
+            }
+            result.append('\n');
+        }
+        System.out.println(result.toString());
+        return result.toString();
+    }
+
+    /**
+     * Get the previous explored square.
+     *
+     * @return {@link uk.gov.dwp.maze.Square} previously explored in current path.
+     */
+    public Square getPreviousExplored() {
+        return maze.getPath().getPreviousExploredSquare();
+    }
+
+    /**
+     * 
+     *
+     * @param row
+     * @param col
+     * @return
+     */
     private boolean move(final int row, final int col){
         //System.out.println(maze);
         Square currentSquare = maze.getSquare(row, col);
@@ -33,18 +79,19 @@ private boolean move(final int row, final int col){
             done = true;
             return true;
         } else {
-            // can hit dead end if goes into this block - so we need to going backward until there is another open square.
+            // can hit dead end if goes into this block - so we need to going backward until it hits another open route.
             maze.markExplored(row, col, true);
             Square nextSquare = turn(row, col);
 
             if (nextSquare != null) {
                 if (move(nextSquare.getRow(), nextSquare.getColumn())) {
                     System.out.println(maze);
+                    printExplorersPath();
                     return !done;
                 }
             } else {
                 // get previous explored square
-                Square previousExplored = maze.getPreviousExplored();
+                Square previousExplored = getPreviousExplored();
                 this.backward = true;
                 if (move(previousExplored.getRow(), previousExplored.getColumn())) {
                     System.out.println(maze);
@@ -56,46 +103,47 @@ private boolean move(final int row, final int col){
     }
 
     /**
+     * Randomly turn left/right, may also choose forward/backward
      *
-     * @param row
-     * @param col
+     * @param row row ordinal
+     * @param col column ordinal
      * @return null if there are not open square in the next move.
      */
     private Square turn(final int row, final int col){
         Set<Square> openSquares = getOpenAdjacentSquares(row, col);
-        List<Square> list = new ArrayList<Square>();
-        list.addAll(openSquares);
-
         // if there are more than one open squares in front randomly pick one up.
-        int size = list.size();
+        int size = openSquares.size();
         if (size > 0) {
             Random generator = new Random();
             int index = generator.nextInt(size);
-            return list.get(index);
+            return openSquares.toArray(new Square[size])[index];
         }
         return null;
     }
 
+    /**
+     * Finding the adjacent empty spaces to the current square.
+     *
+     * TODO simplify this method and get rid of if/else
+     *
+     * @param currentRow row ordinal
+     * @param currentCol column ordinal
+     * @return open Squares in a Set
+     */
     private Set<Square> getOpenAdjacentSquares(final int currentRow, final int currentCol) {
         Set<Square> openSquares = new HashSet<Square>();
 
         for (int i = 0; i <= 3; i ++) {
             if (i == 0 && maze.getSquare(currentRow, currentCol - 1).isOpen() &&
                     !maze.isExplored(currentRow, currentCol - 1)) {
                 openSquares.add(maze.getSquare(currentRow, currentCol - 1));
-            }
-
-            if (i == 1 && maze.getSquare(currentRow - 1, currentCol).isOpen() &&
+            } else if (i == 1 && maze.getSquare(currentRow - 1, currentCol).isOpen() &&
                     !maze.isExplored(currentRow - 1, currentCol)) {
                 openSquares.add(maze.getSquare(currentRow - 1, currentCol));
-            }
-
-            if (i == 2 && maze.getSquare(currentRow + 1, currentCol).isOpen() &&
+            } else if (i == 2 && maze.getSquare(currentRow + 1, currentCol).isOpen() &&
                     !maze.isExplored(currentRow + 1, currentCol)) {
                 openSquares.add(maze.getSquare(currentRow + 1, currentCol));
-            }
-
-            if (i == 3 && maze.getSquare(currentRow, currentCol + 1).isOpen() &&
+            } else if (i == 3 && maze.getSquare(currentRow, currentCol + 1).isOpen() &&
                     !maze.isExplored(currentRow, currentCol + 1)) {
                 openSquares.add(maze.getSquare(currentRow, currentCol + 1));
             }

src/main/java/uk/gov/dwp/maze/Explorer.java

@@ -0,0 +1,29 @@
+package uk.gov.dwp.maze;
+
+import java.io.File;
+
+/**
+ * Created by kcai on 28/10/2014.
+ */
+public class FileMazeBuilder implements MazeBuilder {
+
+    private File file;
+
+    public FileMazeBuilder(String filePath) {
+        try {
+            this.file = new File(filePath);
+        } catch (NullPointerException npe) {
+            throw new IllegalArgumentException("File path cannot be null.");
+        }
+    }
+
+    @Override
+    public Maze build() {
+        try {
+            Square[][] map = MazeFactory.buildMazeMap(file);
+            return new Maze(map);
+        } catch (IllegalArgumentException ia) {
+            return null;
+        }
+    }
+}