[2단계 - 사다리 생성] 제이미(임정수) 미션 제출합니다.

docs/README.md

@@ -4,13 +4,14 @@
 
 ## 📚 도메인 모델 네이밍 사전
 
-| 한글명   | 영문명          | 설명                  |
-|-------|--------------|---------------------|
-| 참가자   | Participants | 사다리 게임에 참가하는 사람들을 지칭 |
-| 사람    | Person       | 사람을 지칭              |
-| 맵     | Map          | 맵 정보 지칭             |
-| 사다리   | Ladder       | 사다리 지칭              |
-| 라인    | Line         | 사다리의 한줄을 지칭         |
+| 한글명 | 영문명          | 설명                   |
+|-----|--------------|----------------------|
+| 참가자 | Participants | 사다리 게임에 참가하는 사람들을 지칭 |
+| 사람  | Person       | 사람을 지칭               |
+| 맵   | Map          | 맵 정보 지칭              |
+| 사다리 | Ladder       | 사다리 지칭               |
+| 라인  | Line         | 사다리의 한줄을 지칭          |
+| 결과  | Result       | 실행 결과를 지칭            |
 
 <br>
 
@@ -28,6 +29,12 @@
     - [x] 이름은 빈문자 혹은 공백으로만 이루어지면 안 된다
 
 
+- 사다리 게임
+    - [x] 사다리를 생성한다.
+    - [x] 사다리 게임의 결과를 판단한다.
+    - [ ] 보고싶은 사람의 사다리 게임의 결과를 전달한다. 
+
+
 - 맵 (사다리)
     - [x] 사다리의 높이는 숫자여야 한다.
     - [x] 사다리의 최소 높이는 1이다.
@@ -43,13 +50,34 @@
         - [x] 연속으로 연결상태를 가질 수 없다.
 
 
+- 참가자
+  - [x] 사람은 10명까지 ( 테스트 원할한 범위 )
+  - [x] 사람은 2명 이상이다.
+  - [x] 사람이름은 ',' 로 구분한다.
+  - [x] 중복된 이름을 가질 수 없다.
+
+
+- 결과들
+    - [x] 결과는 사람 수 만큼이다.
+    - [x] 결과는은 ',' 로 구분한다.
+    - [x] all을 받은 경우 전체 결과를 반환한다.
+    - [x] 사람 이름을 받은 경우 해당 사람의 결과를 반환한다.
+
+
+- 결과
+    - [x] 사다리의 결과는 최대 5글자까지 가능하다
+    - [x] 결과는 빈문자 혹은 공백으로만 이루어지면 안 된다
+
 - 출력
     - [x] 사람 이름은 5자 기준으로 출력하기에 폭도 이에 맞춘다.
+    - [x] 보고 싶은 사람의 실행 결과를 출력한다.
 
 
 - 입력
     - [x] 참여자 이름을 입력한다.
     - [x] 최대 사다리 높이를 입력한다.
+    - [x] 실행 결과를 입력한다.
+    - [x] 결과를 보고 싶은 사람의 이름을 입력한다.
 
 ## 요구 사항
 
@@ -60,6 +88,10 @@
 - [x] 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
     - [x] |-----|-----| 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다.
       <br>
+- [x] 실행 결과를 쉼표(,)를 기준으로 구분한다.
+- [x] 사다리 결과 출력 시 결과도 함께 출력한다.
+- [x] 결과를 보고 싶은 사람 이름을 입력한다. (all 입력 시 전체 결과 출력)
+- [x] all이 아닐 경우 결과 보고 싶은 사람 이름을 다시 물어야 한다.
 
 ## 📌 Commit Convention
 

src/main/java/Application.java

@@ -1,4 +1,4 @@
-import controller.RadderGameController;
+import controller.LadderGameController;
 import util.RandomBooleanGenerator;
 import view.input.InputView;
 import view.output.OutputView;
@@ -9,7 +9,7 @@ public static void main(String[] args) {
         InputView inputView = new InputView();
         OutputView outputView = new OutputView();
         RandomBooleanGenerator randomBooleanGenerator = new RandomBooleanGenerator();
-        RadderGameController radderGameController = new RadderGameController();
-        radderGameController.play(inputView, outputView, randomBooleanGenerator);
+        LadderGameController ladderGameController = new LadderGameController();
+        ladderGameController.play(inputView, outputView, randomBooleanGenerator);
     }
 }

src/main/java/controller/LadderGameController.java

@@ -0,0 +1,86 @@
+package controller;
+
+import domain.*;
+import util.BooleanGenerator;
+import view.input.InputView;
+import view.output.OutputView;
+
+public class LadderGameController {
+
+    private static final String GET_RESULT_ALL = "all";
+
+    public void play(InputView inputView, OutputView outputView, BooleanGenerator booleanGenerator) {
+        Participants participants = setParticipants(inputView);
+        Results results = setResults(inputView, participants);
+        Ladder ladder = generateLadder(inputView, participants, booleanGenerator);
+
+        LadderGame ladderGame = new LadderGame(participants, results, ladder);
+        printLadder(outputView, ladderGame);
+
+        printResult(inputView, outputView, ladderGame);
+    }
+
+    private Participants setParticipants(InputView inputView) {
+        try {
+            String participantNames = inputView.enterParticipantNames();
+            return new Participants(participantNames);
+        } catch (IllegalArgumentException exception) {
+            inputView.printErrorMessage(exception);
+            return setParticipants(inputView);
+        }
+    }
+
+    private Results setResults(InputView inputView, Participants participants) {
+        try {
+            String results = inputView.enterResults();
+            return new Results(results, participants.getParticipantCount());
+        } catch (IllegalArgumentException exception) {
+            inputView.printErrorMessage(exception);
+            return setResults(inputView, participants);
+        }
+    }
+
+    private Ladder generateLadder(InputView inputView, Participants participants, BooleanGenerator booleanGenerator) {
+        try {
+            Height height = new Height(inputView.enterHeight());
+            Weight weight = new Weight(participants.getParticipantCount());
+            return new Ladder(height, weight, booleanGenerator);
+        } catch (IllegalArgumentException exception) {
+            inputView.printErrorMessage(exception);
+            return generateLadder(inputView, participants, booleanGenerator);
+        }
+    }
+
+    private void printLadder(OutputView outputView, LadderGame ladderGame) {
+        outputView.printLadder(ladderGame.getParticipants(), ladderGame.getLadder(),
+                ladderGame.getResults());
+    }
+
+    private void printResult(InputView inputView, OutputView outputView, LadderGame ladderGame) {
+        boolean isContinue = true;
+        while (isContinue) {
+            isContinue = getResult(inputView, outputView, ladderGame);
+        }
+    }
+
+    private boolean getResult(InputView inputView, OutputView outputView, LadderGame ladderGame) {
+        try {
+            String inputResult = inputView.enterGetResult();
+            return getResultByInput(outputView, ladderGame, inputResult);
+        } catch (IllegalArgumentException exception) {
+            inputView.printErrorMessage(exception);
+            return true;
+        }
+    }
+
+    private boolean getResultByInput(OutputView outputView, LadderGame ladderGame, String inputValue) {
+        if (GET_RESULT_ALL.equals(inputValue)) {
+            outputView.printMatchAllResult(ladderGame.getGameAllResult(),
+                    ladderGame.getParticipants());
+            return false;
+        }
+
+        outputView.printMatchResult(ladderGame.getGameResultByName(inputValue));
+        return true;
+    }
+}

src/main/java/domain/GameResult.java

@@ -0,0 +1,30 @@
+package domain;
+
+import exception.NotFindPersonException;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GameResult {
+
+    private final Map<Person, Result> ladderResult;
+
+    public GameResult(Map<Person, Result> ladderResult) {
+        this.ladderResult = new HashMap<>(ladderResult);
+    }
+
+    public Map<Person, Result> getAllResult() {
+        return ladderResult;
+    }
+
+    public Result getResultByName(String name) {
+        Person findPerson = new Person(name);
+        return ladderResult.entrySet()
+                           .stream()
+                           .filter(resultEntry -> resultEntry.getKey()
+                                                             .equals(findPerson))
+                           .findFirst()
+                           .orElseThrow(NotFindPersonException::new)
+                           .getValue();
+    }
+}

src/main/java/domain/Ladder.java

@@ -1,16 +1,46 @@
 package domain;
 
+import util.BooleanGenerator;
+
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public class Ladder {
 
     private final List<Line> lines;
 
-    public Ladder(List<Line> lines) {
-        this.lines = lines;
+    public Ladder(Height height, Weight weight, BooleanGenerator booleanGenerator) {
+        this.lines = generate(height, weight, booleanGenerator);
+    }
+
+    private List<Line> generate(Height height, Weight weight, BooleanGenerator booleanGenerator) {
+        return IntStream.range(0, height.getHeight())
+                        .mapToObj((count) -> new Line(weight.getWeight(), booleanGenerator))
+                        .collect(Collectors.toList());
     }
 
     public List<Line> getLines() {
-        return List.copyOf(lines);
+        return lines;
+    }
+
+    public int getResultIndex(int index) {
+        int resultIndex = index;
+        for (Line line : lines) {
+            resultIndex = getNextIndex(index, line);
+        }
+
+        return resultIndex;
+    }
+
+    private int getNextIndex(int index, Line line) {
+        if (line.canMoveLeft(index)) {
+            return index - 1;
+        }
+        if (line.canMoveRight(index)) {
+            return index + 1;
+        }
+
+        return index;
     }
 }