3주차 - Step4 사다리(리팩토링) 리뷰요청 드립니다..!

src/main/java/ladder/Application.java

@@ -4,23 +4,24 @@
 import ladder.view.InputView;
 import ladder.view.OutputView;
 
-import java.util.HashMap;
-import java.util.Map;
-
 public class Application {
+    private static final String ALL_RESULTS = "all";
 
     public static void main(String[] args) {
         Players players = Players.of(InputView.askPlayers());
-        Prizes prizes = Prizes.from(InputView.askPrizes(), players.numberOfPlayers());
+        Prizes prizes = Prizes.from(InputView.askPrizes());
         Height height = Height.from(InputView.askHeight());
 
-        Ladder ladder = Ladder.from(players, height);
-        OutputView.drawLadder(players, ladder, prizes);
+        GameInfo gameInfo = GameInfo.of(players, prizes);
+        Ladder ladder = Ladder.from(players.numberOfPlayers(), height);
 
-        GameResult gameResult = GameResult.of(players, ladder, prizes);
-        String wantedPlayer = InputView.askWhichResultWant();
+        LadderGame ladderGame = LadderGame.of(gameInfo, ladder);
+        GameResult gameResult = ladderGame.playGame();
 
-        if ("all".equals(wantedPlayer)) {
+        OutputView.printGame(ladderGame);
+
+        String wantedPlayer = InputView.askWhichResultWant();
+        if (ALL_RESULTS.equals(wantedPlayer)) {
             OutputView.printAllResult(gameResult);
             return;
         }

src/main/java/ladder/domain/Direction.java

@@ -0,0 +1,30 @@
+package ladder.domain;
+
+public enum Direction {
+
+    LEFT(true, false),
+    RIGHT(false, true),
+    PASS(false, false);
+
+    private boolean left;
+    private boolean right;
+
+    Direction(boolean left, boolean right) {
+        this.left = left;
+        this.right = right;
+    }
+
+    public boolean isRight() {
+        return right;
+    }
+
+    public Position move(Position position) {
+        if (left && !right) {
+            return position.moveToLeft();
+        }
+        if (!left && right) {
+            return position.moveToRight();
+        }
+        return position;
+    }
+}

src/main/java/ladder/domain/GameInfo.java

@@ -0,0 +1,44 @@
+package ladder.domain;
+
+public class GameInfo {
+    static final String ALERT_INVALID_NUMBER_OF_PRIZES = "상품의 수는 참여자 수와 같아야 합니다.";
+
+    private final Players players;
+    private final Prizes prizes;
+
+    private GameInfo(Players players, Prizes prizes) {
+        validationPrizes(players, prizes);
+        this.players = players;
+        this.prizes = prizes;
+    }
+
+    public static GameInfo of(Players players, Prizes prizes) {
+        return new GameInfo(players, prizes);
+    }
+
+    private void validationPrizes(Players players, Prizes prizes) {
+        if (players.numberOfPlayers() != prizes.numberOfPrizes()) {
+            throw new IllegalArgumentException(ALERT_INVALID_NUMBER_OF_PRIZES);
+        }
+    }
+
+    Player findPlayerByIndex(int index) {
+        return players.findPlayerByIndex(index);
+    }
+
+    Prize findPrizeByPosition(Position finalPosition) {
+        return prizes.findPrizeByPosition(finalPosition);
+    }
+
+    int numberOfPlayers() {
+        return players.numberOfPlayers();
+    }
+
+    public Players getPlayers() {
+        return players;
+    }
+
+    public Prizes getPrizes() {
+        return prizes;
+    }
+}

src/main/java/ladder/domain/GameResult.java

@@ -13,22 +13,8 @@ private GameResult(Map<Player, Prize> resultMap) {
         this.resultMap = new HashMap<>(resultMap);
     }
 
-    public static GameResult of(Players players, Ladder ladder, Prizes prizes) {
-        return new GameResult(playGame(players, ladder, prizes));
-    }
-
-    private static Map<Player, Prize> playGame(Players players, Ladder ladder, Prizes prizes) {
-        Map<Player, Prize> resultMap = new HashMap<>();
-        int numberOfPlayers = players.numberOfPlayers();
-
-        for (int i = 0; i < numberOfPlayers; i++) {
-            Player player = players.getPlayers().get(i);
-            Position finalPosition = ladder.goThroughLinesFrom(Position.from(i));
-            Prize prize = prizes.getPrizes().get(finalPosition.getPosition());
-
-            resultMap.put(player, prize);
-        }
-        return resultMap;
+    public static GameResult from(Map<Player, Prize> resultMap) {
+        return new GameResult(resultMap);
     }
 
     public String findResult(String wantedPlayer) {

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

@@ -14,10 +14,10 @@ private Ladder(List<Line> lines) {
         this.lines = new ArrayList<>(lines);
     }
 
-    public static Ladder from(Players players, Height height) {
+    public static Ladder from(int numberOfPlayers, Height height) {
         return new Ladder(IntStream
                 .range(0, height.getHeight())
-                .mapToObj((integer) -> Line.from(players.numberOfPlayers()))
+                .mapToObj((integer) -> Line.from(numberOfPlayers))
                 .collect(Collectors.toList()));
     }
 

src/main/java/ladder/domain/LadderGame.java

@@ -0,0 +1,45 @@
+package ladder.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LadderGame {
+
+    private final GameInfo gameInfo;
+    private final Ladder ladder;
+
+    private LadderGame(GameInfo gameInfo, Ladder ladder) {
+        this.gameInfo = gameInfo;
+        this.ladder = ladder;
+    }
+
+    public static LadderGame of(GameInfo gameInfo, Ladder ladder) {
+        return new LadderGame(gameInfo, ladder);
+    }
+
+    public GameResult playGame() {
+        Map<Player, Prize> resultMap = new HashMap<>();
+        int numberOfPlayers = gameInfo.numberOfPlayers();
+
+        for (int index = 0; index < numberOfPlayers; index++) {
+            Player player = gameInfo.findPlayerByIndex(index);
+            Position finalPosition = ladder.goThroughLinesFrom(Position.from(index));
+            Prize prize = gameInfo.findPrizeByPosition(finalPosition);
+
+            resultMap.put(player, prize);
+        }
+        return GameResult.from(resultMap);
+    }
+
+    public Players getPlayers() {
+        return gameInfo.getPlayers();
+    }
+
+    public Prizes getPrizes() {
+        return gameInfo.getPrizes();
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+}

src/main/java/ladder/domain/Line.java

@@ -6,29 +6,22 @@
 
 public class Line {
 
-    private List<Bar> bars;
+    private List<Point> points;
 
-    Line(List<Bar> bars) {
-        this.bars = new ArrayList<>(bars);
+    Line(List<Point> points) {
+        this.points = new ArrayList<>(points);
     }
 
     public static Line from(int numberOfPlayers) {
         LineMaker lineMaker = new LineMaker();
-        return new Line(lineMaker.generateBars(numberOfPlayers));
-    }
-
-    public List<Bar> getBars() {
-        return Collections.unmodifiableList(bars);
+        return new Line(lineMaker.generatePoints(numberOfPlayers));
     }
 
     Position travel(Position position) {
-        if (bars.get(position.getPosition()).isExist()) { //사용자의 현재 위치와 bar의 위치가 같으면 사용자의 현재위치가 1만큼 증가
-            return position.moveToRight();
-        }
-        if (position.getPosition() > 0 && bars.get(position.getLeftPosition()).isExist()) { //사용자의 현재 위치보다 bar의 위치가 1만큼 작으면 사용자의 현재위치는 1만큼 감소
-            return position.moveToLeft();
-        }
-        return position;
-    } //TODO: 이 로직을 Bar 객체로 위임하고 싶은데, Bar 2개를 사용해서 위치를 갱신하는 방식이라 이 곳에서 처리하는 상태
+        return points.get(position.getPosition()).move(position);
+    }
 
-}
+    public List<Point> getPoints() {
+        return Collections.unmodifiableList(points);
+    }
+}

src/main/java/ladder/domain/LineMaker.java

@@ -4,40 +4,50 @@
 import java.util.List;
 
 class LineMaker {
-    private static final int NUMBER_OF_FIRST_AND_LAST_BAR = 2;
+    private static final int NUMBER_OF_FIRST_AND_LAST_POINT = 2;
 
-    private List<Bar> randomBars;
-    private RandomBarGenerator barGenerator = new RandomBarGenerator();
+    private List<Point> randomPoints;
+    private RandomPointGenerator pointGenerator = new RandomPointGenerator();
 
-    List<Bar> generateBars(int numberOfPlayers) {
-        this.randomBars = new ArrayList<>();
-        generateFirstBar();
-        generateMiddleBars(numberOfPlayers);
-        generateLastBar();
-        return randomBars;
+    List<Point> generatePoints(int numberOfPlayers) {
+        this.randomPoints = new ArrayList<>();
+        generateFirstPoint();
+        generateMiddlePoints(numberOfPlayers);
+        generateLastPoint();
+        return randomPoints;
     }
 
-    private void generateFirstBar() {
-        randomBars.add(Bar.from(barGenerator.generateBar()));
+    private void generateFirstPoint() {
+        randomPoints.add(Point.makeFirstPoint(chooseDirection()));
     }
 
-    private void generateMiddleBars(int numberOfPlayers) {
-        int spaceForMiddleBars = numberOfPlayers - NUMBER_OF_FIRST_AND_LAST_BAR;
-        for (int i = 0; i < spaceForMiddleBars; i++) {
-            Bar previousBar = randomBars.get(i);
-            addNextBar(previousBar);
+    private void generateMiddlePoints(int numberOfPlayers) {
+        int spaceForMiddlePoints = numberOfPlayers - NUMBER_OF_FIRST_AND_LAST_POINT;
+        for (int i = 0; i < spaceForMiddlePoints; i++) {
+            Point previousPoint = randomPoints.get(i);
+            addNextPoint(previousPoint);
         }
     }
 
-    private void addNextBar(Bar previousBar) {
-        if (previousBar.isExist()) {
-            generateLastBar();
+    private void addNextPoint(Point previousPoint) {
+        if (previousPoint.isDirectionRight()) {
+            randomPoints.add(previousPoint.makeNextPoint(Direction.LEFT));
             return;
         }
-        randomBars.add(Bar.from(barGenerator.generateBar()));
+        randomPoints.add(previousPoint.makeNextPoint(chooseDirection()));
     }
 
-    private void generateLastBar() {
-        randomBars.add(Bar.from(Boolean.FALSE));
+    private void generateLastPoint() {
+        int currentlyLastIndex = randomPoints.size() - 1;
+        Point secondToLastPoint = randomPoints.get(currentlyLastIndex);
+        randomPoints.add(secondToLastPoint.makeLastPoint());
+    }
+
+    private Direction chooseDirection() {
+        Direction direction = Direction.PASS;
+        if (pointGenerator.generatePoint()) {
+            direction = Direction.RIGHT;
+        }
+        return direction;
     }
 }

src/main/java/ladder/domain/Players.java

@@ -35,6 +35,10 @@ public int numberOfPlayers() {
         return players.size();
     }
 
+    Player findPlayerByIndex(int index) {
+        return players.get(index);
+    }
+
     public List<Player> getPlayers() {
         return Collections.unmodifiableList(players);
     }