🚀 4단계 - 사다리(리팩터링)

README.md

@@ -53,4 +53,54 @@
 - [x] 사다리 높이만큼 반복
 
 - 결과
-- [x] 사람별 사다리게임 결과
+- [x] 사람별 사다리게임 결과
+
+
+---
+
+TDD로 구현
+
+도메인
+1. point
+  current, right
+  둘다 true일 수는 없음
+  current > left로 이동
+  right > right로 이동
+  둘다 false > 그대로 아래로 이동
+
+  오류 방지
+  - 첫번째 point 생성
+  - 다음 point 생성
+  - 마지막 point 생성
+
+2. Cross
+  현재 위치 position
+  point
+
+  move
+  - right > index+1
+  - left > index-1
+  - down > index
+
+- [x] 출력
+  - "-----", "     "
+
+2. line 
+  crosses
+
+- [x] 출력 
+  - "|-----|      |-----|"
+
+3. ladder
+  lines
+
+- [x] 출력
+  - "|-----|      |-----|"
+  - "|     |------|     |"
+  - "|-----|      |-----|"
+
+- [x] 결과 조회
+
+
+Usernames
+- [x] 이름 중복 체크

src/main/java/nextstep/ladder/Cross.java

@@ -0,0 +1,30 @@
+package nextstep.ladder;
+
+public class Cross {
+    private int position;
+    private Point point;
+
+    public Cross(int position, Point point) {
+        this.position = position;
+        this.point = point;
+    }
+
+    public int move() {
+        if(point.move() == Direction.RIGHT) {
+            return position + 1;
+        } else if(point.move() == Direction.LEFT) {
+            return position - 1;
+        }
+
+        return position;
+    }
+
+    public String getCrossForPrint(String trueSymbol, String falseSymbol) {
+        if(point.move() == Direction.RIGHT) {
+            return trueSymbol;
+        }
+
+        return falseSymbol;
+    }
+
+}

src/main/java/nextstep/ladder/Direction.java

@@ -0,0 +1,7 @@
+package nextstep.ladder;
+
+public enum Direction {
+    LEFT,
+    RIGHT,
+    DOWN;
+}

src/main/java/nextstep/ladder/Ladder.java

@@ -1,64 +1,53 @@
 package nextstep.ladder;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class Ladder {
-    private Usernames usernames;
-    private Lines lines;
-    private List<String> results;
+    private static final String LADDER_DELIMITER = "\n";
 
-    public Ladder(Usernames usernames, Lines lines, List<String> results) {
-        this.usernames = usernames;
-        this.lines = lines;
-        this.results = results;
-    }
+    private List<Line> lines;
 
-    public String getResultsForPrint() {
-        return results.stream()
-                .map(d -> String.format("%-6s", d))
-                .collect(Collectors.joining());
+    public Ladder(int countOfPerson, int height) {
+        this.lines = createLines(countOfPerson, height);
     }
 
-    public String getLadderForPrint(String trueSymbol, String falseSymbol) {
-        return String.join("\n",
-                usernames.toString(),
-                lines.toString(trueSymbol, falseSymbol),
-                getResultsForPrint()
-        );
+    public Ladder(List<Line> lines) {
+        this.lines = new ArrayList<>(lines);
     }
 
-    public String getResult(String resultUsername) {
-        if ("all".equals(resultUsername)) {
-            return getAllResult();
+    private List<Line> createLines(int countOfPerson, int height) {
+        List<Line> nLines = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            nLines.add(new Line(countOfPerson));
         }
 
-        return getResultByUsername(resultUsername);
+        return nLines;
     }
 
-    private Map<String, String> getResultMap() {
-        Map<String, String> result = IntStream.range(0, usernames.size())
-                .boxed()
-                .collect(Collectors.toMap(
-                        i -> usernames.getValues().get(i).getUsername(),
-                        i -> results.get(lines.getPersonFinalResultIndex(i))
-                ));
-
-        return result;
+    public int move(int position) {
+        int index = position;
+        for (Line line : lines) {
+            index = line.move(index);
+        }
+        return index;
     }
 
-    private String getAllResult() {
-        Map<String, String> resultMap = getResultMap();
-
-        return resultMap.entrySet()
-                .stream()
-                .map(d -> d.getKey() + " : " + d.getValue()).collect(Collectors.joining("\n"));
+    public String getLadderForPrint(String trueSymbol, String falseSymbol) {
+        return lines.stream()
+                .map(line -> line.getLineForPrint(trueSymbol, falseSymbol))
+                .collect(Collectors.joining(LADDER_DELIMITER));
     }
 
-    private String getResultByUsername(String resultUsername) {
-        return getResultMap().get(resultUsername);
+    //todo lines.get(0).getCrossSize()
+    public Map<Integer, Integer> getAllResult() {
+        return IntStream.range(0, lines.get(0).getCrossSize())
+                .boxed()
+                .collect(Collectors.toMap(i -> i, i -> move(i)));
     }
 
 }

src/main/java/nextstep/ladder/LadderMain.java

@@ -9,10 +9,12 @@ public static void main(String[] args) {
         if (usernames.size() != results.size()) {
             throw new IllegalArgumentException("참여할 사람 수와 입력한 실행 결과의 수가 다릅니다.");
         }
-        Ladder ladder = new Ladder(usernames, new Lines(InputView.inputHeight(), usernames.size()), results);
+        Ladder ladder = new Ladder(usernames.size(), InputView.inputHeight());
+        ResultView.printUsernames(usernames);
         ResultView.printLadder(ladder);
+        ResultView.printResults(results);
 
         String resultUserName = InputView.inputResultUserName();
-        ResultView.printResult(ladder.getResult(resultUserName));
+        ResultView.printResult(resultUserName, usernames, ladder, results);
     }
 }

src/main/java/nextstep/ladder/Line.java

@@ -1,27 +1,59 @@
 package nextstep.ladder;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
 
 public class Line {
-    private Points points;
+    private static final Random RANDOM = new Random();
+    private static final String LINE_DELIMITER = "|";
+
+    private List<Cross> crosses;
 
     public Line(int countOfPerson) {
-        points = new Points(countOfPerson);
+        createCrosses(countOfPerson);
+    }
+
+    public Line(List<Cross> crosses) {
+        this.crosses = crosses;
     }
 
-    public Line(Points points) {
-        this.points = points;
+    private void createCrosses(int countOfPerson) {
+        crosses = new ArrayList<>();
+
+        Point point = Point.first(RANDOM.nextBoolean());
+        for (int i = 0; i < countOfPerson; i++) {
+            point = updatePoint(i, countOfPerson, point);
+            crosses.add(new Cross(i, point));
+        }
     }
 
-    public String toString(String trueSymbol, String falseSymbol) {
-        return points.toString(trueSymbol, falseSymbol);
+    private Point updatePoint(int index, int countOfPerson, Point currentPoint) {
+        if (index == countOfPerson - 1) {
+            return currentPoint.last();
+        }
+        if (index > 0) {
+            return currentPoint.next(RANDOM.nextBoolean());
+        }
+        return currentPoint;
     }
 
-    public Integer getResultIndex(int index) {
-        return points.getResultIndex(index);
+    //todo
+    public int move(int position) {
+        return this.crosses.get(position).move();
     }
 
-    @Override
-    public String toString() {
-        return points.toString();
+    //todo
+    public int getCrossSize() {
+        return crosses.size();
     }
+
+    public String getLineForPrint(String trueSymbol, String falseSymbol) {
+        return LINE_DELIMITER
+                + crosses.stream()
+                .map(cross -> cross.getCrossForPrint(trueSymbol, falseSymbol))
+                .collect(Collectors.joining(LINE_DELIMITER));
+    }
+
 }

src/main/java/nextstep/ladder/Point.java

@@ -1,31 +1,40 @@
 package nextstep.ladder;
 
 public class Point {
-    private boolean left;
+    private boolean current;
     private boolean right;
 
-    public Point(boolean left, boolean right) {
-        this.left = left;
+    public Point(boolean current, boolean right) {
+        if (current && right) {
+            throw new IllegalArgumentException("유효하지 않은 값입니다.");
+        }
+        this.current = current;
         this.right = right;
     }
 
-    public boolean getRight() {
-        return right;
+    public static Point first(boolean right) {
+        return new Point(false, right);
     }
 
-    public String getLineSymbol(String trueSymbol, String falseSymbol) {
-        return right ? trueSymbol : falseSymbol;
+    public Point next(boolean right) {
+        if (this.right) {
+            return new Point(this.right, false);
+        }
+        return new Point(this.right, right);
     }
 
-    public int getResultIndex(int index) {
-        return left ? index - 1 : (right ? index + 1 : index);
+    public Point last() {
+        return new Point(this.right, false);
     }
 
-    @Override
-    public String toString() {
-        return "Point{" +
-                "left=" + left +
-                ", right=" + right +
-                '}';
+    public Direction move() {
+        if (current) {
+            return Direction.LEFT;
+        }
+        if (right) {
+            return Direction.RIGHT;
+        }
+
+        return Direction.DOWN;
     }
 }