2주차 미션 / 서버 4조 최재현

src/main/java/ladder/LadderGame.java

@@ -1,18 +1,18 @@
 package ladder;
 
-import ladder.creator.LadderCreator;
+import ladder.creator.LadderCreatorIF;
 
 public class LadderGame {
 
-    private final LadderCreator ladderCreator;
+    private final LadderCreatorIF ladderCreatorIF;
 
-    public LadderGame(LadderCreator ladderCreator) {
-        this.ladderCreator = ladderCreator;
+    public LadderGame(LadderCreatorIF ladderCreatorIF) {
+        this.ladderCreatorIF = ladderCreatorIF;
     }
 
     public int run(Position position) {
-        LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows());
-        ladderRunner.run(position);
-        return position.getValue();
+        LadderPosition ladderPosition = new LadderPosition(0, position.getValue());
+        LadderRunner ladderRunner = new LadderRunner(ladderCreatorIF.getRows());
+        return ladderRunner.run(ladderPosition);
     }
 }

src/main/java/ladder/LadderGameFactory.java

@@ -0,0 +1,14 @@
+package ladder;
+
+import ladder.creator.LadderCreator;
+import ladder.creator.RandomLadderCreator;
+
+public class LadderGameFactory {
+    public static LadderGame createLadderGame(LadderSize ladderSize) {
+        return new LadderGame(new LadderCreator(ladderSize));
+    }
+
+    public static LadderGame createRandomLadderGame(LadderSize ladderSize) {
+        return new LadderGame(new RandomLadderCreator(ladderSize));
+    }
+}

src/main/java/ladder/LadderPosition.java

@@ -0,0 +1,53 @@
+package ladder;
+
+public class LadderPosition {
+
+    private Position x;
+    private Position y;
+
+    public LadderPosition(Position x, Position y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public LadderPosition(int x, int y) {
+        this.x = Position.from(x);
+        this.y = Position.from(y);
+    }
+
+    public Position getX() {
+        return x;
+    }
+
+    public Position getY() {
+        return y;
+    }
+
+    public int getValueX() {
+        return x.getValue();
+    }
+
+    public int getValueY() {
+        return y.getValue();
+    }
+
+    public Boolean isNthRow(int n) {
+        return x.getValue() == n;
+    }
+
+    public Boolean isNthNode(int n) {
+        return y.getValue() == n;
+    }
+
+    public void goLeft() {
+        y.prev();
+    }
+
+    public void goRight() {
+        y.next();
+    }
+
+    public void goDown() {
+        x.next();
+    }
+}

src/main/java/ladder/LadderRunner.java

@@ -8,10 +8,49 @@ public LadderRunner(Row[] rows) {
         this.rows = rows;
     }
 
-    public int run(Position position) {
+    public int run(LadderPosition ladderPosition) {
         for (int i = 0; i < rows.length; i++) {
-            rows[i].nextPosition(position);
+            printLadder("Before", ladderPosition);
+            rows[i].nextPosition(ladderPosition);
+            printLadder("After", ladderPosition);
+            ladderPosition.goDown();
         }
-        return position.getValue();
+        return ladderPosition.getValueY();
+    }
+
+    private void printLadder(String title, LadderPosition ladderPosition) {
+        String printString = title
+                + '\n'
+                + getLadderString(ladderPosition);
+        System.out.println(printString);
+    }
+
+    private String getLadderString(LadderPosition ladderPosition) {
+        StringBuilder ladderStringBuilder = new StringBuilder();
+
+        for (int i = 0; i < rows.length; i++) {
+            ladderStringBuilder.append(getNthRowString(i, ladderPosition))
+                    .append('\n');
+        }
+        return ladderStringBuilder.toString();
+    }
+
+    private String getNthRowString(int n, LadderPosition ladderPosition) {
+        String rowString = rows[n].getRowString();
+        if (ladderPosition.isNthRow(n)) {
+            rowString = insertAsterisk(rowString, ladderPosition);
+        }
+        return rowString;
+    }
+
+    private String insertAsterisk(String rowString, LadderPosition ladderPosition) {
+        String[] nodeStrings = rowString.split(" ");
+        StringBuilder stringBuilder = new StringBuilder();
+
+        for (int i = 0; i < nodeStrings.length; i++) {
+            stringBuilder.append(nodeStrings[i])
+                    .append(ladderPosition.isNthNode(i) ? "* " : " ");
+        }
+        return stringBuilder.toString();
     }
 }

src/main/java/ladder/LadderSize.java

@@ -0,0 +1,31 @@
+package ladder;
+
+public class LadderSize {
+    private GreaterThanOne numberOfRow;
+    private GreaterThanOne numberOfPerson;
+
+    public LadderSize(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) {
+        this.numberOfRow = numberOfRow;
+        this.numberOfPerson = numberOfPerson;
+    }
+
+    public GreaterThanOne getNumberOfRow() {
+        return numberOfRow;
+    }
+
+    public GreaterThanOne getNumberOfPerson() {
+        return numberOfPerson;
+    }
+
+    public int getNumberOfRowValue() {
+        return numberOfRow.getNumber();
+    }
+
+    public int getNumberOfPersonValue() {
+        return numberOfPerson.getNumber();
+    }
+
+    public int getMaxLineCount() {
+        return (int)(numberOfRow.getNumber() * numberOfPerson.getNumber() * 0.3);
+    }
+}

src/main/java/ladder/Node.java

@@ -14,13 +14,13 @@ public static Node from(Direction direction) {
         return new Node(direction);
     }
 
-    public void move(Position position) {
+    public void move(LadderPosition ladderPosition) {
         if (isRight()) {
-            position.next();
+            ladderPosition.goRight();
             return;
         }
         if (isLeft()) {
-            position.prev();
+            ladderPosition.goLeft();
             return;
         }
     }
@@ -48,4 +48,9 @@ private boolean isLeft() {
     private boolean isNone() {
         return direction == NONE;
     }
+
+    @Override
+    public String toString() {
+        return Integer.toString(direction.getValue());
+    }
 }

src/main/java/ladder/Row.java

@@ -18,18 +18,24 @@ public void drawLine(Position startPosition) {
         setDirectionBetweenNextPosition(startPosition);
     }
 
-    public void nextPosition(Position position) {
-        validatePosition(position);
+    public void nextPosition(LadderPosition ladderPosition) {
+        validateLadderPosition(ladderPosition);
 
-        nodes[position.getValue()].move(position);
+        nodes[ladderPosition.getValueY()].move(ladderPosition);
     }
 
+
+
     private void setDirectionBetweenNextPosition(Position position) {
         nodes[position.getValue()].setRightNode();
         position.next();
         nodes[position.getValue()].setLeftNode();
     }
 
+    private void validateLadderPosition(LadderPosition ladderPosition) {
+        validatePosition(ladderPosition.getY());
+    }
+
     private void validatePosition(Position position) {
         if (isInvalidPosition(position) ) {
             throw new IllegalArgumentException(ExceptionMessage.INVALID_POSITION.getMessage());
@@ -58,4 +64,14 @@ private boolean isLineAtNextPosition(Position position) {
         return lineAtPosition;
     }
 
+    public String getRowString() {
+        StringBuilder rowStringBuilder = new StringBuilder();
+
+        for (Node node : nodes) {
+            rowStringBuilder.append(node.toString())
+                    .append(" ");
+
+        }
+        return rowStringBuilder.toString();
+    }
 }

src/main/java/ladder/creator/LadderCreator.java

@@ -1,24 +1,30 @@
 package ladder.creator;
 
-import ladder.GreaterThanOne;
-import ladder.Position;
-import ladder.Row;
+import ladder.*;
 
-public class LadderCreator {
+
+public class LadderCreator implements LadderCreatorIF {
 
     private final Row[] rows;
 
-    public LadderCreator(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) {
-        rows = new Row[numberOfRow.getNumber()];
-        for (int i = 0; i < numberOfRow.getNumber(); i++) {
-            rows[i] = new Row(numberOfPerson);
+    public LadderCreator(LadderSize ladderSize) {
+        int numberOfRow = ladderSize.getNumberOfRowValue();
+
+        rows = new Row[numberOfRow];
+        for (int i = 0; i < numberOfRow; i++) {
+            rows[i] = new Row(ladderSize.getNumberOfPerson());
         }
     }
 
-    public void drawLine(Position row, Position col) {
+    @Override
+    public void drawLine(LadderPosition ladderPosition) {
+        Position row = ladderPosition.getX();
+        Position col = ladderPosition.getY();
+
         rows[row.getValue()].drawLine(col);
     }
 
+    @Override
     public Row[] getRows() {
         return rows;
     }

src/main/java/ladder/creator/LadderCreatorIF.java

@@ -0,0 +1,11 @@
+package ladder.creator;
+
+import ladder.LadderPosition;
+import ladder.Position;
+import ladder.Row;
+
+public interface LadderCreatorIF {
+    public abstract void drawLine(LadderPosition ladderPosition);
+
+    public abstract Row[] getRows();
+}

src/main/java/ladder/creator/RandomLadderCreator.java

@@ -0,0 +1,48 @@
+package ladder.creator;
+
+import ladder.LadderPosition;
+import ladder.LadderSize;
+import ladder.Row;
+
+import java.util.HashSet;
+
+public class RandomLadderCreator implements LadderCreatorIF{
+
+    private final LadderCreator ladderCreator;
+    private final LadderSize ladderSize;
+
+    public RandomLadderCreator(LadderSize ladderSize) {
+        ladderCreator = new LadderCreator(ladderSize);
+        this.ladderSize = ladderSize;
+        initLadder();
+    }
+
+    private void initLadder() {
+        HashSet<LadderPosition> linePositionSet = new HashSet<>();
+        int maxLineCount = ladderSize.getMaxLineCount();
+        int maxRowNumber = ladderSize.getNumberOfRowValue();
+        int maxNodeNumber = ladderSize.getNumberOfPersonValue() - 1;
+
+        while (linePositionSet.size() < maxLineCount) {
+            int x = (int)(Math.random() * maxRowNumber);
+            int y = (int)(Math.random() * maxNodeNumber);
+            LadderPosition ladderPosition = new LadderPosition(x, y);
+
+            try {
+                drawLine(ladderPosition);
+                linePositionSet.add(ladderPosition);
+            } catch (IllegalArgumentException ignored) {
+            }
+        }
+    }
+
+    @Override
+    public void drawLine(LadderPosition ladderPosition) {
+        ladderCreator.drawLine(ladderPosition);
+    }
+
+    @Override
+    public Row[] getRows() {
+        return ladderCreator.getRows();
+    }
+}