[LBP] 권지후 사다리 2-5단계 미션 제출합니다

src/main/java/controller/LadderController.java

@@ -1,26 +1,62 @@
 package controller;
 
-import model.*;
+import model.Height;
+import model.Players;
+import model.PointGenerator;
+import model.Prizes;
+import model.Ladder;
+import model.LadderResult;
+import model.RandomValueGenerator;
+import model.Point;
+import view.InputView;
 import view.ResultView;
-
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
 import static model.Point.HAS_POINT;
 
 public class LadderController {
 
-    private static final int LADDER_SIZE = 4;
-    private static final int CHUNK_SIZE = 3;
+    private static final String ALL_PLAYERS = "all";
     private final ResultView resultView = new ResultView();
+    private final InputView inputView = new InputView();
 
     public void startLadder() {
-        PointGenerator pointGenerator = new PointGenerator(new Random());
-        LadderGame ladderGame = new LadderGame(new Size(LADDER_SIZE), new Size(LADDER_SIZE), pointGenerator);
-        List<Point> ladderPoints = ladderGame.getLadderPoints();
-        List<Boolean> points = formatLadderPoints(ladderPoints);
-        List<List<Boolean>> ladderLines = processLadderLines(points);
-        resultView.printLadder(ladderLines);
+        Players players = new Players(inputView.inputNames());
+        Prizes prizes = Prizes.createPrizes(inputView.inputResult(), players);
+        Height height = new Height(inputView.getMaxLadderHeight());
+        PointGenerator pointGenerator = new PointGenerator(new RandomValueGenerator());
+
+        Ladder ladder = Ladder.createLadder(players.size(), height.getValue(), pointGenerator);
+        LadderResult ladderResult = calculateLadderResult(ladder, players.getPlayers(), prizes);
+
+        printLadder(ladder, players, prizes);
+        printResult(ladderResult);
+    }
+
+    private LadderResult calculateLadderResult(Ladder ladder, List<String> players, Prizes prizes) {
+        LadderResult ladderResult = new LadderResult(ladder);
+        ladderResult.calculateResults(players, prizes);
+        return ladderResult;
+    }
+
+    private void printLadder(Ladder ladder, Players players, Prizes prizes) {
+        List<Boolean> points = formatLadderPoints(ladder.getPointsFromLines());
+        List<List<Boolean>> ladderLines = processLadderLines(points, players.size());
+        resultView.printLadder(ladderLines, players.getPlayers(), prizes.getPrize());
+    }
+
+    private void printResult(LadderResult ladderResult) {
+        while (true) {
+            String targetPlayerName = inputView.getTargetPlayerName();
+
+            if (targetPlayerName.equals(ALL_PLAYERS)) {
+                resultView.printAllResults(ladderResult.getValue());
+                break;
+            }
+            if (ladderResult.getValue().containsKey(targetPlayerName)) {
+                resultView.printSingleResult(ladderResult.getResultForPlayer(targetPlayerName));
+            }
+        }
     }
 
     private List<Boolean> formatLadderPoints(List<Point> ladderPoints) {
@@ -31,15 +67,16 @@ private List<Boolean> formatLadderPoints(List<Point> ladderPoints) {
         return formattedLadder;
     }
 
-    private List<List<Boolean>> processLadderLines(List<Boolean> ladderPoints) {
+    private List<List<Boolean>> processLadderLines(List<Boolean> ladderPoints, int numPlayers) {
+        int lineCount = numPlayers - 1;
         List<List<Boolean>> chunks = new ArrayList<>();
-        for (int i = 0; i < ladderPoints.size(); i += CHUNK_SIZE) {
-            chunks.add(getLadderSegment(ladderPoints, i));
+        for (int i = 0; i < ladderPoints.size(); i += lineCount) {
+            chunks.add(getLadderSegment(ladderPoints, i, lineCount));
         }
         return chunks;
     }
 
-    private List<Boolean> getLadderSegment(List<Boolean> ladderPoints, int startIndex) {
-        return ladderPoints.subList(startIndex, Math.min(startIndex + CHUNK_SIZE, ladderPoints.size()));
+    private List<Boolean> getLadderSegment(List<Boolean> ladderPoints, int startIndex, int lineCount) {
+        return ladderPoints.subList(startIndex, Math.min(startIndex + lineCount, ladderPoints.size()));
     }
 }

src/main/java/exception/ExceptionMessage.java

@@ -0,0 +1,24 @@
+package exception;
+
+public enum ExceptionMessage {
+    LADDER_HEIGHT_MIN_VALUE("사다리 높이는 최소 2 이상이어야 합니다."),
+    LADDER_SIZE_NEGATIVE("사다리 사이즈가 0보다 작을 수는 없습니다."),
+    LADDER_HEIGHT_NOT_NUMBER("사다리 높이는 숫자여야 합니다."),
+
+    PLAYER_NAME_MAX_LENGTH_EXCEEDED("참가자 이름은 최대 5글자를 초과할 수 없습니다."),
+    MIN_PLAYERS_REQUIRED("참가자는 최소 2명 이상이여야 합니다."),
+
+    RESULT_COUNT_MISMATCH("실행결과 개수와 참가자의 수는 동일해야 합니다."),
+    RESULT_NOT_NULL_OR_EMPTY("실행결과는 null이거나 공백일 수는 없습니다."),
+    NULL_OR_EMPTY_INPUT("입력값이 null이거나 비어있을 순 없습니다.");
+
+    private final String message;
+
+    ExceptionMessage(String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/model/Height.java

@@ -0,0 +1,24 @@
+package model;
+
+import exception.ExceptionMessage;
+
+public class Height {
+    private static final int MIN_HEIGHT = 2;
+
+    private final int value;
+
+    public Height(int value) {
+        validateValue(value);
+        this.value = value;
+    }
+
+    private void validateValue(int value) {
+        if (value < MIN_HEIGHT) {
+            throw new IllegalArgumentException(ExceptionMessage.LADDER_HEIGHT_MIN_VALUE.getMessage());
+        }
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/model/Ladder.java

@@ -10,11 +10,27 @@ public Ladder(List<Line> lines) {
         this.lines = List.copyOf(lines);
     }
 
+    public static Ladder createLadder(int playerCount, int maxHeight, PointGenerator pointGenerator) {
+        List<Line> lines = Line.createLines(playerCount, maxHeight, pointGenerator);
+        return new Ladder(lines);
+    }
+
+    public int move(int position) {
+        for (Line line : lines) {
+            position = line.move(position);
+        }
+        return position;
+    }
+
     public List<Point> getPointsFromLines() {
         List<Point> result = new ArrayList<>();
         for (Line line : lines) {
             result.addAll(line.getPointGroups());
         }
         return List.copyOf(result);
     }
+
+    public List<Line> getLines() {
+        return List.copyOf(lines);
+    }
 }

src/main/java/model/LadderResult.java

@@ -0,0 +1,35 @@
+package model;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LadderResult {
+    private static final String NO_RESULT = "결과 없음";
+    private final Map<String, String> results;
+    private final Ladder ladder;
+
+    public LadderResult(Ladder ladder) {
+        this.ladder = ladder;
+        this.results = new HashMap<>();
+    }
+
+    public void calculateResults(List<String> playerNames, Prizes prizes) {
+        List<String> prizeValues = prizes.getPrize();
+
+        for (String playerName : playerNames) {
+            int playerIndex = playerNames.indexOf(playerName);
+            playerIndex = ladder.move(playerIndex);
+            results.put(playerName, prizeValues.get(playerIndex));
+        }
+    }
+
+    public String getResultForPlayer(String name) {
+        return results.getOrDefault(name, NO_RESULT);
+    }
+
+    public Map<String, String> getValue() {
+        return Collections.unmodifiableMap(results);
+    }
+}

src/main/java/model/Line.java

@@ -1,6 +1,7 @@
 package model;
 
 import java.util.List;
+import java.util.stream.IntStream;
 
 public class Line {
     private final List<Point> points;
@@ -9,6 +10,32 @@ public Line(List<Point> points) {
         this.points = List.copyOf(points);
     }
 
+    public static List<Line> createLines(int playerCount, int maxHeight, PointGenerator pointGenerator) {
+        return IntStream.range(0, maxHeight)
+                .mapToObj(i -> new Line(pointGenerator.createLinePoints(new Size(playerCount))))
+                .toList();
+    }
+
+    public int move(int position) {
+        if(canMoveLeft(position)) {
+            return position -1;
+        }
+
+        if(canMoveRight(position)) {
+            return position + 1;
+        }
+        return position;
+    }
+
+    private boolean canMoveLeft(int position) {
+        return position > 0 && points.get(position - 1) == Point.HAS_POINT;
+    }
+
+    private boolean canMoveRight(int position) {
+        return position < points.size() && points.get(position) == Point.HAS_POINT;
+
+    }
+
     public List<Point> getPointGroups() {
         return List.copyOf(points);
     }

src/main/java/model/Player.java

@@ -0,0 +1,28 @@
+package model;
+
+import exception.ExceptionMessage;
+
+public class Player {
+
+    private static final int MAX_NAME_LENGTH = 5;
+    private final String value;
+
+    public Player(String value) {
+        validateValues(value);
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    private void validateValues(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException(ExceptionMessage.NULL_OR_EMPTY_INPUT.getMessage());
+        }
+
+        if (value.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException(ExceptionMessage.PLAYER_NAME_MAX_LENGTH_EXCEEDED.getMessage());
+        }
+    }
+}

src/main/java/model/Players.java

@@ -0,0 +1,38 @@
+package model;
+
+import exception.ExceptionMessage;
+
+import java.util.List;
+
+public class Players {
+
+    private static final int MIN_PLAYER_LENGTH = 2;
+    private final List<Player> players;
+
+    public Players(List<String> players) {
+        validatePlayers(players);
+        this.players = generatePlayers(players);
+    }
+
+    public int size() {
+        return players.size();
+    }
+
+    public List<String> getPlayers() {
+        return players.stream()
+                .map(Player::getValue)
+                .toList();
+    }
+
+    private List<Player> generatePlayers(List<String> players) {
+        return players.stream()
+                .map(Player::new)
+                .toList();
+    }
+
+    private void validatePlayers(List<String> players) {
+        if (players.size() < MIN_PLAYER_LENGTH) {
+            throw new IllegalArgumentException(ExceptionMessage.MIN_PLAYERS_REQUIRED.getMessage());
+        }
+    }
+}

src/main/java/model/PointGenerator.java

@@ -2,13 +2,12 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
 
 public class PointGenerator {
-    private final Random random;
+    private final RandomUtil randomUtil;
 
-    public PointGenerator(Random random) {
-        this.random = random;
+    public PointGenerator(RandomUtil randomUtil) {
+        this.randomUtil = randomUtil;
     }
 
     public List<Point> createLinePoints(Size width) {
@@ -28,7 +27,7 @@ private Point createPoint(boolean isPreviousLine) {
         if (isPreviousLine) {
             return Point.NO_POINT;
         }
-        int randomIndex = random.nextInt(points.size());
+        int randomIndex = randomUtil.generateRandomNumber();
         return points.get(randomIndex);
     }
 }

src/main/java/model/Prize.java

@@ -0,0 +1,23 @@
+package model;
+
+import exception.ExceptionMessage;
+
+public class Prize {
+
+    private final String value;
+
+    public Prize(String value) {
+        validateValue(value);
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    private void validateValue(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            throw new IllegalArgumentException(ExceptionMessage.RESULT_NOT_NULL_OR_EMPTY.getMessage());
+        }
+    }
+}