[2단계 - 사다리 게임 실행] 페드로(류형욱) 미션 제출합니다.

docs/README.md

@@ -1,3 +1,5 @@
+# 1단계 - 사다리 생성
+
 ## 주요 기능
 
 1. 참여할 사람 이름 입력
@@ -27,15 +29,34 @@
   - 왼쪽 경로 왼쪽에 항상 오른쪽 경로가 있어야 한다.
 
 ### 실행 결과 출력
-
 - [x] “실행 결과” 문구 출력
 - [x] 참여자 이름 출력
 - [x] 사다리 출력
 
 ### 예외 처리
-
 - [x] 유효한 참여자 이름이 아닐 경우 예외 발생
     - 이름의 길이는 1 이상 5이하여야 함
     - 이름에 포함되는 문자는 영문자와 숫자만 허용함
 - [x] 유효한 사다리 높이가 아닐 경우 예외 발생
-    - 높이는 항상 자연수여야 함
+    - 높이는 항상 자연수여야 함
+
+# 2단계 - 사다리 게임 실행
+
+## 기능 요구사항
+- 사다리 실행 결과를 출력해야 함
+  - 개인별 이름을 입력하면 개인별 결과를 출력함
+  - `all` 을 입력하면 전체 참여자의 실행 결과를 출력함
+
+### 참여할 사람의 이름
+- [x] 참여자의 이름은 `all` 일 수 없다.
+
+### 실행 결과 입력
+- [x] 실행 결과 입력
+  - 입력된 실행 결과의 개수는 참여자 수와 같아야 함
+
+### 사다리 타고 결과 출력
+- [x] 참여자들의 최종 도착지를 계산하는 기능
+- [x] 결과를 보고 싶은 사람을 입력받는 기능
+- [x] 실행 결과를 출력하는 기능
+  - 한 명의 결과를 출력하는 경우 '도착지' 만 출력
+  - 전체의 결과를 출력하는 경우 각 참여자의 이름과 도착지를 출력

src/main/java/ladder/controller/LadderController.java

@@ -1,27 +1,34 @@
 package ladder.controller;
 
+import java.util.Map;
+import ladder.dto.LineDto;
 import ladder.model.Ladder;
 import ladder.model.Players;
+import ladder.service.LadderGame;
 import ladder.view.InputView;
 import ladder.view.OutputView;
 
 import java.util.List;
 
 public class LadderController {
-    private Players ladderPlayers;
-    private Ladder ladder;
+    private static final String QUERY_FOR_ALL_REWARD = "all";
+    private LadderGame ladderGame;
 
     public void start() {
         init();
-        printResult();
+        showGame();
+        showReward(readLookupTarget());
     }
 
     private void init() {
-        ladderPlayers = Players.from(readPlayerNames());
+        Players ladderPlayers = Players.from(readPlayerNames());
 
         int height = readLadderHeight();
         int width = ladderPlayers.getSize();
-        ladder = Ladder.of(height, width);
+
+        List<String> rewards = readRewards();
+        Ladder ladder = Ladder.of(height, width);
+        ladderGame = LadderGame.from(ladderPlayers, rewards, ladder);
     }
 
     private List<String> readPlayerNames() {
@@ -32,9 +39,29 @@ private int readLadderHeight() {
         return InputView.inputLadderHeight();
     }
 
-    private void printResult() {
-        OutputView.printResultDescription();
-        OutputView.printPlayerNames(ladderPlayers.getPlayerNames());
-        OutputView.printLadder(ladder.toLineDtoList());
+    private List<String> readRewards() {
+        return InputView.inputRewards();
+    }
+
+    private String readLookupTarget() {
+        return InputView.inputLookupTarget();
+    }
+
+    private void showGame() {
+        OutputView.printGame(
+                ladderGame.getPlayerNames(),
+                LineDto.asList(ladderGame.getLadder()),
+                ladderGame.getRewards()
+        );
+    }
+
+    private void showReward(String target) {
+        Map<String, String> result = ladderGame.play();
+
+        if (target.equals(QUERY_FOR_ALL_REWARD)) {
+            OutputView.printRewardForAll(result);
+            return;
+        }
+        OutputView.printRewardForTarget(result.get(target));
     }
 }

src/main/java/ladder/dto/LineDto.java

@@ -1,5 +1,6 @@
 package ladder.dto;
 
+import ladder.model.Ladder;
 import ladder.model.Line;
 
 import java.util.List;
@@ -15,6 +16,12 @@ public static LineDto from(Line line) {
         return new LineDto(line.getConnected());
     }
 
+    public static List<LineDto> asList(Ladder ladder) {
+        return ladder.getLadder().stream()
+                .map(LineDto::from)
+                .toList();
+    }
+
     public List<Boolean> getConnected() {
         return connected;
     }

src/main/java/ladder/model/Ladder.java

@@ -1,7 +1,7 @@
 package ladder.model;
 
+import java.util.Collections;
 import java.util.stream.IntStream;
-import ladder.dto.LineDto;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -36,37 +36,55 @@ private static boolean notNaturalNumber(int value) {
     }
 
     private static List<LadderPath> makeRandomRow(int width) {
-        List<LadderPath> randomPath = new ArrayList<>(generatePairableRandomPath(width));
+        List<LadderPath> randomPaths = new ArrayList<>();
 
-        if (randomPath.size() < width) {
-            randomPath.add(LadderPath.STAY);
+        while (randomPaths.size() < width) {
+            randomPaths.add(generateRandomPath(randomPaths, width));
         }
 
-        return randomPath;
+        return randomPaths;
     }
 
-    private static List<LadderPath> generatePairableRandomPath(int maxWidth) {
-        List<LadderPath> randomPathWithPair = new ArrayList<>();
-
-        while (randomPathWithPair.size() < maxWidth - 1) {
-            randomPathWithPair.addAll(generateRandomPath());
+    private static LadderPath generateRandomPath(List<LadderPath> currentPaths, int width) {
+        if (isLastPathConnected(currentPaths)) {
+            return LadderPath.LEFT;
         }
 
-        return randomPathWithPair;
-    }
+        boolean isLastElement = currentPaths.size() == width - 1;
+        if (isLastElement) {
+            return LadderPath.STAY;
+        }
 
-    private static List<LadderPath> generateRandomPath() {
         boolean isConnectedPath = random.nextBoolean();
-
         if (isConnectedPath) {
-            return List.of(LadderPath.RIGHT, LadderPath.LEFT);
+            return LadderPath.RIGHT;
         }
-        return List.of(LadderPath.STAY);
+        return LadderPath.STAY;
     }
 
-    public List<LineDto> toLineDtoList() {
-        return ladder.stream()
-                .map(LineDto::from)
-                .toList();
+    private static boolean isLastPathConnected(List<LadderPath> currentPaths) {
+        if (currentPaths.isEmpty()) {
+            return false;
+        }
+
+        LadderPath lastPath = currentPaths.get(currentPaths.size() - 1);
+        return lastPath.equals(LadderPath.RIGHT);
+    }
+
+    public List<Integer> climb() {
+        List<Integer> result = new ArrayList<>(IntStream.range(0, getWidth())
+                .boxed()
+                .toList());
+        ladder.forEach(line -> result.replaceAll(line::climbDown));
+
+        return result;
+    }
+
+    public List<Line> getLadder() {
+        return Collections.unmodifiableList(ladder);
+    }
+
+    public int getWidth() {
+        return ladder.get(0).size();
     }
 }

src/main/java/ladder/model/LadderPath.java

@@ -1,5 +1,19 @@
 package ladder.model;
 
 public enum LadderPath {
-    STAY, LEFT, RIGHT;
+    LEFT(true, -1),
+    STAY(false, 0),
+    RIGHT(true, 1);
+
+    final boolean connected;
+    final int direction;
+
+    LadderPath(boolean connected, int direction) {
+        this.connected = connected;
+        this.direction = direction;
+    }
+
+    public static boolean isPathExist(LadderPath leftPath, LadderPath rightPath) {
+        return leftPath.equals(RIGHT) && rightPath.equals(LEFT);
+    }
 }

src/main/java/ladder/model/Line.java

@@ -7,10 +7,12 @@
 
 public class Line {
     private final List<LadderPath> row;
+    private final List<Boolean> connected;
 
     public Line(List<LadderPath> row) {
         validate(row);
         this.row = row;
+        this.connected = calculateConnectedPosition();
     }
 
     private void validate(List<LadderPath> row) {
@@ -22,6 +24,12 @@ private void validate(List<LadderPath> row) {
         }
     }
 
+    private List<Boolean> calculateConnectedPosition() {
+        return IntStream.range(0, row.size() - 1)
+                .mapToObj(idx -> LadderPath.isPathExist(row.get(idx), row.get(idx + 1)))
+                .toList();
+    }
+
     private boolean isLeftOnFirst(List<LadderPath> row) {
         return row.get(0) == LEFT;
     }
@@ -44,13 +52,16 @@ private boolean isRightAlwaysExistBeforeLeft(List<LadderPath> row) {
                 .allMatch(idx -> row.get(idx).equals(RIGHT));
     }
 
-    public int size() {
-        return row.size();
+    public int climbDown(int position) {
+        LadderPath path = row.get(position);
+        return position + path.direction;
     }
 
     public List<Boolean> getConnected() {
-        return IntStream.range(0, row.size() - 1)
-                .mapToObj(idx -> row.get(idx).equals(RIGHT))
-                .toList();
+        return connected;
+    }
+
+    public int size() {
+        return row.size();
     }
 }

src/main/java/ladder/model/Player.java

@@ -13,14 +13,17 @@ public Player(String name) {
 
     private void validate(String name) {
         if (isNameLengthLongerThanMaxLength(name)) {
-            throw new IllegalArgumentException("이름의 길이는 5를 초과할 수 없다.");
+            throw new IllegalArgumentException("이름의 길이는 5를 초과할 수 없습니다.");
         }
         if (isNameEmpty(name)) {
             throw new IllegalArgumentException("이름이 비어 있습니다.");
         }
         if (!isNameFormatValid(name)) {
             throw new IllegalArgumentException("이름은 영문자와 숫자로 구성되어야 합니다.");
         }
+        if (isProhibitedName(name)) {
+            throw new IllegalArgumentException("사용할 수 없는 이름입니다.");
+        }
     }
 
     private boolean isNameLengthLongerThanMaxLength(String name) {
@@ -35,6 +38,10 @@ private boolean isNameFormatValid(String name) {
         return name.matches(NAME_PATTERN);
     }
 
+    private boolean isProhibitedName(String name) {
+        return name.equals("all");
+    }
+
     public String getName() {
         return name;
     }

src/main/java/ladder/service/LadderGame.java

@@ -0,0 +1,69 @@
+package ladder.service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import ladder.model.Ladder;
+import ladder.model.Players;
+
+public class LadderGame {
+    private final Players players;
+    private final List<String> rewards;
+    private final Ladder ladder;
+
+    private LadderGame(Players ladderPlayers, List<String> rewards, Ladder ladder) {
+        this.players = ladderPlayers;
+        this.rewards = rewards;
+        this.ladder = ladder;
+    }
+
+    public static LadderGame from(Players ladderPlayers, List<String> rewards, Ladder ladder) {
+        validate(ladderPlayers, rewards, ladder);
+        return new LadderGame(ladderPlayers, rewards, ladder);
+    }
+
+    private static void validate(Players players, List<String> rewards, Ladder ladder) {
+        if (playerAndLadderDoesNotMatch(players, ladder)) {
+            throw new IllegalArgumentException("참여자의 수와 사다리의 폭이 일치하지 않습니다.");
+        }
+        if (playerAndRewardDoesNotMatch(players, rewards)) {
+            throw new IllegalArgumentException("참여자의 수와 실행 결과의 수가 일치하지 않습니다.");
+        }
+    }
+
+    private static boolean playerAndLadderDoesNotMatch(Players players, Ladder ladder) {
+        return players.getSize() != ladder.getWidth();
+    }
+
+    private static boolean playerAndRewardDoesNotMatch(Players players, List<String> rewards) {
+        return players.getSize() != rewards.size();
+    }
+
+    public Map<String, String> play() {
+        List<Integer> positionAfterClimb = ladder.climb();
+        List<String> playersPositionAfterClimb = positionAfterClimb.stream()
+                .map(players.getPlayerNames()::get)
+                .toList();
+
+        return createGameResult(playersPositionAfterClimb);
+    }
+
+    private Map<String, String> createGameResult(List<String> finalPosition) {
+        return IntStream.range(0, finalPosition.size())
+                .boxed()
+                .collect(Collectors.toMap(finalPosition::get, rewards::get));
+    }
+
+    public List<String> getPlayerNames() {
+        return players.getPlayerNames();
+    }
+
+    public List<String> getRewards() {
+        return rewards;
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+}