[2단계 - 사다리 게임] 미아(이종미) 미션 제출합니다.

README.md

@@ -6,6 +6,13 @@
 2. 입력 받은 사다리 높이에 해당하는 사다리를 생성한다.
     1. 각 사다리 높이마다 참가자 수만큼 사다리 발판(`—----`) 유무를 결정한다.
     2. 사다리 발판은 이웃할 수 없다. (`|-----|-----|`)
+3. 사다리 타기를 진행한다.
+    1. 입력된 참가자 순서대로 사다리를 탄다.
+    2. 한 계단씩 내려가며 좌우에 발판이 있는지 확인한다.
+    3. 발판이 있는 쪽으로 이동한다.
+    4. 마지막 계단까지 마치면 해당 참가자의 결과를 저장한다.
+4. 사다리 타기 어플리케이션을 종료한다.
+    1. `all` 이 입력되면 종료한다.
 
 ## 입출력 기능
 
@@ -14,12 +21,18 @@
 1. 사람 이름 목록을 입력한다.
     1. 사람 이름을 쉼표(,)를 기준으로 구분한다.
     2. 최대 5글자의 알파벳으로 이루어진 이름을 가진다.
-2. 사다리 높이를 입력한다.
+2. 실행 결과를 입력한다.
+    1. 참여할 사람 수만큼 입력한다. 
+3. 사다리 높이를 입력한다.
     1. 1 이상이다.
 
 ### 출력
 
 1. 사다리를 출력한다.
     1. 참가자 이름의 순서는 입력된 순서로 출력한다.
-    2. 각 참가자 이름은 6자의 길이로 출력한다.
+    2. 각 참가자 이름은 5자의 길이로 출력한다.
     3. 참가자 이름과 사다리 세로선(`|`)은 오른쪽 정렬된다.
+    4. 하단에 사다리 결과를 입력된 순서로 출력한다.
+2. 사다리를 탄 결과를 출력한다.
+    1. 참가자 이름을 입력한 경우, 해당 참가자의 결과를 출력한다.
+    2. `all` 을 입력한 경우, 모든 참가자의 결과를 출력한다.

src/main/java/ladder/Application.java

@@ -1,12 +1,10 @@
 package ladder;
 
 import ladder.controller.LadderGame;
-import ladder.manager.LadderGameManager;
 
 public class Application {
     public static void main(String[] args) {
-        LadderGameManager ladderGameManager = new LadderGameManager();
-        LadderGame ladderGame = ladderGameManager.createLadderGame();
+        LadderGame ladderGame = new LadderGame();
         ladderGame.run();
     }
 }

src/main/java/ladder/controller/LadderGame.java

@@ -1,33 +1,37 @@
 package ladder.controller;
 
+import ladder.domain.generator.LadderStepGenerator;
+import ladder.domain.generator.RandomLadderStepGenerator;
 import ladder.domain.ladder.Height;
 import ladder.domain.ladder.Ladder;
+import ladder.domain.result.GameResults;
+import ladder.domain.result.LadderGamePrize;
 import ladder.domain.participant.Participants;
 import ladder.exception.ExceptionHandler;
 import ladder.view.InputView;
 import ladder.view.OutputView;
 
 import java.util.List;
+import java.util.Objects;
 
 public class LadderGame {
-    private final InputView inputView;
-    private final OutputView outputView;
-    private final ExceptionHandler exceptionHandler;
+    private static final String FINISH_COMMAND = "all";
 
-    public LadderGame(
-            final InputView inputView,
-            final OutputView outputView,
-            final ExceptionHandler exceptionHandler) {
-        this.inputView = inputView;
-        this.outputView = outputView;
-        this.exceptionHandler = exceptionHandler;
-    }
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private final ExceptionHandler exceptionHandler = new ExceptionHandler(outputView);
 
     public void run() {
         final Participants participants = exceptionHandler.retryOnException(this::createParticipants);
+        final LadderGamePrize ladderGamePrize = exceptionHandler.retryOnException(this::readLadderGameResult);
         final int width = participants.getNecessaryLadderWidth();
         final Ladder ladder = createLadder(width);
-        printLadder(participants, ladder);
+        participants.playAll(ladder);
+        final GameResults gameResults = ladderGamePrize.calculdateGameResults(participants);
+
+        printLadder(participants, ladder, ladderGamePrize);
+        printGameResult(gameResults);
+
         inputView.closeResource();
     }
 
@@ -38,17 +42,45 @@ private Participants createParticipants() {
 
     private Ladder createLadder(final int stepWidth) {
         final Height height = exceptionHandler.retryOnException(this::readLadderHeight);
-        return new Ladder(height, stepWidth);
+        final LadderStepGenerator ladderStepGenerator = new RandomLadderStepGenerator();
+        return new Ladder(height, stepWidth, ladderStepGenerator);
+    }
+
+    private LadderGamePrize readLadderGameResult() {
+        final List<String> ladderGameResult = inputView.readLadderGameResult();
+        return new LadderGamePrize(ladderGameResult);
     }
 
     private Height readLadderHeight() {
         final int ladderHeight = inputView.readLadderHeight();
         return new Height(ladderHeight);
     }
 
-    private void printLadder(final Participants participants, final Ladder ladder) {
-        outputView.printResultPrefix();
+    private void printLadder(
+            final Participants participants,
+            final Ladder ladder,
+            final LadderGamePrize ladderGamePrize) {
+        outputView.printLadderPrefix();
         outputView.printParticipants(participants);
         outputView.printLadder(ladder);
+        outputView.printLadderGamePrize(ladderGamePrize);
+    }
+
+    private void printGameResult(final GameResults gameResults) {
+        boolean retry = true;
+        while (retry) {
+            retry = exceptionHandler.retryOnException(() -> printGameResultByCommand(gameResults));
+        }
+    }
+
+    private boolean printGameResultByCommand(final GameResults gameResults) {
+        final String gameResultTarget = inputView.readGameResultTarget();
+        if (Objects.equals(gameResultTarget, FINISH_COMMAND)) {
+            outputView.printAllGameResults(gameResults);
+            return false;
+        }
+        final String personalGameResult = gameResults.findByName(gameResultTarget);
+        outputView.printPersonalGameResult(personalGameResult);
+        return true;
     }
 }

src/main/java/ladder/domain/generator/LadderStepGenerator.java

@@ -0,0 +1,7 @@
+package ladder.domain.generator;
+
+import ladder.domain.ladder.LadderStep;
+
+public interface LadderStepGenerator {
+    LadderStep generate(final int stepWidth);
+}

src/main/java/ladder/domain/generator/RandomLadderStepGenerator.java

@@ -7,10 +7,11 @@
 import java.util.List;
 import java.util.Random;
 
-public class RandomLadderStepGenerator {
+public class RandomLadderStepGenerator implements LadderStepGenerator {
     private static final Random random = new Random();
 
-    static public LadderStep generate(final int stepWidth) {
+    @Override
+    public LadderStep generate(final int stepWidth) {
         final List<Path> ladderPaths = new ArrayList<>();
         while (ladderPaths.size() < stepWidth) {
             final Path currentPath = generatePath();
@@ -19,7 +20,7 @@ static public LadderStep generate(final int stepWidth) {
         return new LadderStep(ladderPaths);
     }
 
-    static private Path generatePath() {
+    private Path generatePath() {
         final boolean isAvailable = random.nextBoolean();
         return Path.from(isAvailable);
     }

src/main/java/ladder/domain/ladder/Height.java

@@ -1,9 +1,5 @@
 package ladder.domain.ladder;
 
-import ladder.exception.ladder.InvalidHeightRangeException;
-
-import java.util.List;
-
 public class Height {
     private static final int MIN_HEIGHT = 1;
 
@@ -16,7 +12,7 @@ public Height(final int value) {
 
     private void validateHeightRange(final int value) {
         if (value < MIN_HEIGHT) {
-            throw new InvalidHeightRangeException();
+            throw new IllegalArgumentException("사다리 높이는 1 이상의 정수입니다.");
         }
     }
 

src/main/java/ladder/domain/ladder/Ladder.java

@@ -1,6 +1,6 @@
 package ladder.domain.ladder;
 
-import ladder.domain.generator.RandomLadderStepGenerator;
+import ladder.domain.generator.LadderStepGenerator;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -10,20 +10,36 @@
 public class Ladder {
     private final List<LadderStep> ladderSteps;
 
-    public Ladder(final Height height, final int stepWidth) {
-        this.ladderSteps = generateLadderSteps(height, stepWidth);
+    public Ladder(
+            final Height height,
+            final int stepWidth,
+            final LadderStepGenerator ladderStepGenerator) {
+        final List<LadderStep> generatedLadderSteps = generateLadderSteps(height, stepWidth, ladderStepGenerator);
+        this.ladderSteps = unmodifiableList(generatedLadderSteps);
     }
 
-    private List<LadderStep> generateLadderSteps(final Height height, final int stepWidth) {
+    private List<LadderStep> generateLadderSteps(
+            final Height height,
+            final int stepWidth,
+            final LadderStepGenerator ladderStepGenerator) {
         final List<LadderStep> ladderSteps = new ArrayList<>();
         while (height.isGreaterThan(ladderSteps.size())) {
-            final LadderStep currentLadderStep = RandomLadderStepGenerator.generate(stepWidth);
+            final LadderStep currentLadderStep = ladderStepGenerator.generate(stepWidth);
             ladderSteps.add(currentLadderStep);
         }
         return ladderSteps;
     }
 
+    public int playFrom(int startPosition) {
+        int nextPosition = -1;
+        for (LadderStep step : ladderSteps) {
+            nextPosition = step.findNextPosition(startPosition);
+            startPosition = nextPosition;
+        }
+        return nextPosition;
+    }
+
     public List<LadderStep> getLadderSteps() {
-        return unmodifiableList(ladderSteps);
+        return ladderSteps;
     }
 }

src/main/java/ladder/domain/ladder/LadderStep.java

@@ -17,7 +17,7 @@ public LadderStep(List<Path> ladderPaths) {
     private List<Path> correctLadderPaths(List<Path> ladderPaths) {
         final List<Path> correctedLadderPaths = new ArrayList<>();
         Path prevPath = EMPTY;
-        for (Path currentPath: ladderPaths) {
+        for (Path currentPath : ladderPaths) {
             final Path correctedPath = correctPath(prevPath, currentPath);
             correctedLadderPaths.add(correctedPath);
             prevPath = correctedPath;
@@ -26,12 +26,25 @@ private List<Path> correctLadderPaths(List<Path> ladderPaths) {
     }
 
     private Path correctPath(final Path prevPath, final Path currentPath) {
-        if(prevPath.equals(EMPTY)) {
+        if (prevPath.equals(EMPTY)) {
             return currentPath;
         }
         return EMPTY;
     }
 
+    public int findNextPosition(final int position) {
+        if (position > 0 && isExistIn(position - 1)) {
+            return position - 1;
+        } else if (position < ladderPaths.size() && isExistIn(position)) {
+            return position + 1;
+        }
+        return position;
+    }
+
+    private boolean isExistIn(final int position) {
+        return ladderPaths.get(position).isExist();
+    }
+
     public List<Path> getLadderPaths() {
         return ladderPaths;
     }

src/main/java/ladder/domain/ladder/Path.java

@@ -1,14 +1,8 @@
 package ladder.domain.ladder;
 
 public enum Path {
-    EMPTY("     "),
-    EXIST("-----");
-
-    private final String shape;
-
-    Path(final String shape) {
-        this.shape = shape;
-    }
+    EMPTY,
+    EXIST;
 
     public static Path from(final boolean isAvailable) {
         if (isAvailable) {
@@ -20,8 +14,4 @@ public static Path from(final boolean isAvailable) {
     public boolean isExist() {
         return this.equals(EXIST);
     }
-
-    public String getShape() {
-        return shape;
-    }
 }

src/main/java/ladder/domain/participant/Participant.java

@@ -1,30 +1,26 @@
 package ladder.domain.participant;
 
-import ladder.exception.participant.InvalidNameLengthException;
-import ladder.exception.participant.NonAlphabeticNameException;
-
 public class Participant {
     private static final int MAX_NAME_LENGTH = 5;
     private static final String NAME_REGEX = "^[a-zA-Z]*$";
 
     private final String name;
 
-    public Participant(String name) {
-        name = name.trim();
+    public Participant(final String name) {
         validateNameLength(name);
-        validateIsAlphabetic(name);
+        validateAlphabeticName(name);
         this.name = name;
     }
 
     private void validateNameLength(final String name) {
         if (name.isEmpty() || name.length() > MAX_NAME_LENGTH) {
-            throw new InvalidNameLengthException();
+            throw new IllegalArgumentException("이름은 1에서 5자 사이로 입력해 주세요.");
         }
     }
 
-    private static void validateIsAlphabetic(final String name) {
+    private void validateAlphabeticName(final String name) {
         if (!name.matches(NAME_REGEX)) {
-            throw new NonAlphabeticNameException();
+            throw new IllegalArgumentException("이름은 영어로 입력해 주세요.");
         }
     }