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

src/main/java/controller/LadderController.java

@@ -1,26 +1,43 @@
 package controller;
 
 import model.*;
+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 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);
+        Players player = new Players(inputView.inputNames());
+        Prizes prizes = Prizes.form(inputView.inputResult(), player);
+        Height height = new Height(inputView.getMaxLadderHeight());
+        PointGenerator pointGenerator = new PointGenerator(new RandomValueGenerator());
+        LadderGame ladderGame = LadderGame.createGame(player, height, pointGenerator, prizes);
+
+        List<Boolean> points = formatLadderPoints(ladderGame.getLadderPoints());
         List<List<Boolean>> ladderLines = processLadderLines(points);
-        resultView.printLadder(ladderLines);
+        resultView.printLadder(ladderLines, player.getPlayers(), prizes.getPrize());
+        printResult(ladderGame);
+    }
+
+    private void printResult(LadderGame ladderGame) {
+        while (true) {
+            String targetPlayerName = inputView.getTargetPlayerName();
+
+            if (targetPlayerName.equals("all")) {
+                resultView.printAllResults(ladderGame.getAllResultForPlayers());
+                break;
+            }
+            if (ladderGame.hasResultForPlayer(targetPlayerName)) {
+                resultView.printSingleResult(ladderGame.getResultForPlayer(targetPlayerName));
+            }
+        }
     }
 
     private List<Boolean> formatLadderPoints(List<Point> ladderPoints) {

src/main/java/model/Height.java

@@ -0,0 +1,22 @@
+package model;
+
+public class Height {
+    private static final int MINIMUM_HEIGHT = 2;
+
+    private final int value;
+
+    public Height(int value) {
+        validateValue(value);
+        this.value = value;
+    }
+
+    private void validateValue(int value) {
+        if (value < MINIMUM_HEIGHT) {
+            throw new IllegalArgumentException("사다리 높이는 2 이상이여야 합니다.");
+        }
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/model/Ladder.java

@@ -17,4 +17,8 @@ public List<Point> getPointsFromLines() {
         }
         return List.copyOf(result);
     }
+
+    public List<Line> getLines() {
+        return List.copyOf(lines);
+    }
 }

src/main/java/model/LadderGame.java

@@ -1,27 +1,46 @@
 package model;
 
-import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.IntStream;
 
 public class LadderGame {
     private final Ladder ladder;
-    private final PointGenerator generator;
+    private final LadderResult ladderResult;
 
-    public LadderGame(Size width, Size height, PointGenerator generator) {
-        this.generator = generator;
-        this.ladder = new Ladder(generateLines(width, height));
+    public LadderGame(Ladder ladder, LadderResult ladderResult) {
+        this.ladder = ladder;
+        this.ladderResult = ladderResult;
     }
 
-    private List<Line> generateLines(Size width, Size height) {
-        List<Line> lines = new ArrayList<>();
-        for (int i = 0; i < height.getSize(); i++) {
-            List<Point> points = generator.createLinePoints(width);
-            lines.add(new Line(points));
-        }
-        return List.copyOf(lines);
+    public static LadderGame createGame(Players players, Height maxHeight,
+                                        PointGenerator pointGenerator,
+                                        Prizes prizes) {
+        Ladder ladder = new Ladder(generateLines(players.size(), maxHeight.getValue(), pointGenerator));
+        LadderResult ladderResult = new LadderResult(ladder);
+        ladderResult.calculateResults(players.getPlayers(), prizes);
+        return new LadderGame(ladder, ladderResult);
+    }
+
+    private static List<Line> generateLines(int playerCount, int maxHeight, PointGenerator pointGenerator) {
+        return IntStream.range(0, maxHeight)
+                .mapToObj(i -> new Line(pointGenerator.createLinePoints(new Size(playerCount))))
+                .toList();
     }
 
     public List<Point> getLadderPoints() {
         return ladder.getPointsFromLines();
     }
+
+    public String getResultForPlayer(String name) {
+        return ladderResult.getResultForPlayer(name);
+    }
+
+    public Map<String, String> getAllResultForPlayers() {
+        return ladderResult.getValue();
+    }
+
+    public boolean hasResultForPlayer(String name) {
+        return ladderResult.getValue().containsKey(name);
+    }
 }

src/main/java/model/LadderResult.java

@@ -0,0 +1,56 @@
+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<Line> lines = ladder.getLines();
+        List<String> prizeValues = prizes.getPrize();
+
+        for (String playerName : playerNames) {
+            int playerIndex = playerNames.indexOf(playerName);
+            for (Line line : lines) {
+                playerIndex = getNewIndexMove(playerIndex, line.getPointGroups());
+            }
+            results.put(playerName, prizeValues.get(playerIndex));
+        }
+    }
+
+    private int getNewIndexMove(int currentIndex, List<Point> points) {
+        if (canMoveLeft(currentIndex, points)) {
+            return currentIndex - 1;
+        }
+        if (canMoveRight(currentIndex, points)) {
+            return currentIndex + 1;
+        }
+        return currentIndex;
+    }
+
+    private boolean canMoveLeft(int currentIndex, List<Point> points) {
+        return currentIndex > 0 && points.get(currentIndex - 1) == Point.HAS_POINT;
+    }
+
+    private boolean canMoveRight(int currentIndex, List<Point> points) {
+        return currentIndex < points.size() && points.get(currentIndex) == Point.HAS_POINT;
+    }
+
+    public String getResultForPlayer(String name) {
+        return results.getOrDefault(name, NO_RESULT);
+    }
+
+    public Map<String, String> getValue() {
+        return Collections.unmodifiableMap(results);
+    }
+}

src/main/java/model/Player.java

@@ -0,0 +1,22 @@
+package model;
+
+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 values) {
+        if (values.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("참가자 이름은 5글자를 초과할 수 없습니다.");
+        }
+    }
+}

src/main/java/model/Players.java

@@ -0,0 +1,36 @@
+package model;
+
+import java.util.List;
+
+public class Players {
+
+    private static final int MITMUM_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() < MITMUM_PLAYER_LENGTH) {
+            throw new IllegalArgumentException("참가자는 2명 이상이여야 합니다.");
+        }
+    }
+}

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,22 @@
+package model;
+
+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.isEmpty()) {
+            throw new IllegalArgumentException("실행결과는 null이거나 공백일 수는 없습니다.");
+        }
+    }
+}
+

src/main/java/model/Prizes.java

@@ -0,0 +1,35 @@
+package model;
+
+import java.util.List;
+
+public class Prizes {
+
+    private final List<Prize> prize;
+
+    public Prizes(List<Prize> prize) {
+        this.prize = prize;
+    }
+
+    public static Prizes form(List<String> result, Players players) {
+        validatePrize(result, players);
+        return new Prizes(generatePrize(result));
+    }
+
+    public List<String> getPrize() {
+        return prize.stream()
+                .map(Prize::getValue)
+                .toList();
+    }
+
+    private static List<Prize> generatePrize(List<String> result) {
+        return result.stream()
+                .map(Prize::new)
+                .toList();
+    }
+
+    private static void validatePrize(List<String> prizes, Players players) {
+        if (prizes.size() != players.size()) {
+            throw new IllegalArgumentException("실행결과 개수와 참가자의 수는 동일해야 합니다.");
+        }
+    }
+}

src/main/java/model/RandomUtil.java

@@ -0,0 +1,5 @@
+package model;
+
+public interface RandomUtil {
+    int generateRandomNumber();
+}

src/main/java/model/RandomValueGenerator.java

@@ -0,0 +1,13 @@
+package model;
+
+import java.util.Random;
+
+public class RandomValueGenerator implements RandomUtil {
+    private static final int RANDOM_BOUND = 2;
+    private static final Random random = new Random();
+
+    @Override
+    public int generateRandomNumber() {
+        return random.nextInt(RANDOM_BOUND);
+    }
+}

src/main/java/test/FixedNumberGenerator.java

@@ -0,0 +1,16 @@
+package test;
+
+import model.RandomUtil;
+
+public class FixedNumberGenerator implements RandomUtil {
+    private final int fixedNumber;
+
+    public FixedNumberGenerator(int fixedNumber) {
+        this.fixedNumber = fixedNumber;
+    }
+
+    @Override
+    public int generateRandomNumber() {
+        return fixedNumber;
+    }
+}