3주차 - Step3 사다리(게임 실행) 리뷰 요청드립니다.

README.md

@@ -11,25 +11,34 @@
 
 ## 구현 기능 목록
 
-- [x] 게임참가자(플레이어)의 이름을 입력받는다.
+- [x] 1. 게임참가자(플레이어)의 이름을 입력받는다.
     - [x] 입력된 이름들이 플레이어가 된다.
     - [x] 플레이어의 이름은 (,)로 구분된다.
         - [x] 예외 처리: (,) 사이의 공백 제거
     - [x] 플레이어의 이름은 최대 5글자이다.
         - [x] 예외 처리: 5글자가 넘거나 공백일 경우
     - [x] 플레이어는 최소 2명 있어야 한다. (사다리의 다리는 최소 2개 이상이므로) 
         - [x] 예외 처리: 플레이어가 2명 미만일 경우
-- [x] 사다리 높이를 입력받는다.
+- [x] 2. 실행 결과(당첨 상품)를 입력받는다.
+    - [x] 예외 처리: 5글자가 넘거나 공백일 경우
+    - [x] 예외 처리: 플레이어의 수와 상품의 수가 같지 않을 경우
+- [x] 3. 사다리 높이를 입력받는다.
     - [x] 예외 처리: 사다리 높이가 1 미만일 경우
-- [x] 플레이어들을 출력한다.
+- [x] 4. 플레이어들을 출력한다.
     - [x] 플레이어 이름
     - [x] 플레이어 이름이 5글자 미만일 경우 부족한 만큼 왼쪽으로 공백을 채운다.
-- [x] 사다리를 출력한다.
+- [x] 5. 사다리를 출력한다.
     - [x] 사다리의 열을 생성한다.
         - [x] 각 열은 기둥과 바(bar)로 이루어져있다.
         - [x] 기둥 사이를 잇는 바를 랜덤으로 생성한다.
         - [x] 바는 연속될 수 없다.
         - [x] 바는 '-' 5개로 이루어져있다.
     - [x] 입력받은 높이만큼 열을 추가한다.
-
+- [x] 6. 당첨 상품 들을 출력한다.
+- [x] 7. 사다리 게임을 실행한다.
+     - [x] 사용자의 현재 위치를 기준으로 사다리를 타고, 최종 위치를 계산한다.
+        - [x] 사용자의 현재 위치와 bar의 위치가 1만큼 작으면 사용자의 현재위치는 1만큼 감소
+        - [x] 사용자의 현재 위치보다 bar의 위치가 같으면 사용자의 현재위치가 1만큼 증가
+- [x] 8. 결과를 보고싶은 플레이어(혹은 전체)를 묻고 입력받는다.
+- [x] 9. 해당 플레이어(혹은 전체)의 실행 결과를 반환한다.
 

src/main/java/ladder/Application.java

@@ -1,19 +1,29 @@
 package ladder;
 
-import ladder.domain.Height;
-import ladder.domain.Ladder;
-import ladder.domain.Players;
+import ladder.domain.*;
 import ladder.view.InputView;
 import ladder.view.OutputView;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class Application {
 
     public static void main(String[] args) {
         Players players = Players.of(InputView.askPlayers());
+        Prizes prizes = Prizes.from(InputView.askPrizes(), players.numberOfPlayers());
         Height height = Height.from(InputView.askHeight());
 
         Ladder ladder = Ladder.from(players, height);
+        OutputView.drawLadder(players, ladder, prizes);
+
+        GameResult gameResult = GameResult.of(players, ladder, prizes);
+        String wantedPlayer = InputView.askWhichResultWant();
 
-        OutputView.printResult(players, ladder);
+        if ("all".equals(wantedPlayer)) {
+            OutputView.printAllResult(gameResult);
+            return;
+        }
+        OutputView.printSingleResult(gameResult.findResult(wantedPlayer));
     }
 }

src/main/java/ladder/domain/Bar.java

@@ -0,0 +1,18 @@
+package ladder.domain;
+
+public class Bar {
+
+    private final boolean bar;
+
+    private Bar(boolean bar) {
+        this.bar = bar;
+    }
+
+    public static Bar from(boolean doesBarExist) {
+        return new Bar(doesBarExist);
+    }
+
+    public boolean isExist() {
+        return bar;
+    }
+}

src/main/java/ladder/domain/BarGenerator.java

@@ -1,5 +1,6 @@
 package ladder.domain;
 
+@FunctionalInterface
 public interface BarGenerator {
 
     boolean generateBar();

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

@@ -0,0 +1,46 @@
+package ladder.domain;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class GameResult {
+    private static final String ALERT_FOR_INVALID_PLAYER_NAME = "입력하신 플레이어는 존재하지 않습니다.";
+
+    private final Map<Player, Prize> resultMap;
+
+    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 String findResult(String wantedPlayer) {
+        Player playerWanted = resultMap.keySet().stream()
+                .filter(player -> player.isSame(wantedPlayer))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(ALERT_FOR_INVALID_PLAYER_NAME));
+
+        return resultMap.get(playerWanted).getPrize();
+    }
+
+    public Map<Player, Prize> getResultMap() {
+        return Collections.unmodifiableMap(resultMap);
+    }
+}

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

@@ -7,17 +7,21 @@ public class Height {
     private final int height;
 
     private Height(int inputHeight) {
-        if (inputHeight < MINIMUM_LADDER_HEIGHT) {
-            throw new IllegalArgumentException(ALERT_MINIMUM_LADDER_HEIGHT);
-        }
+        validationHeight(inputHeight);
         this.height = inputHeight;
     }
 
     public static Height from(int inputHeight) {
         return new Height(inputHeight);
     }
 
-    public int getHeight() {
+    private void validationHeight(int inputHeight) {
+        if (inputHeight < MINIMUM_LADDER_HEIGHT) {
+            throw new IllegalArgumentException(ALERT_MINIMUM_LADDER_HEIGHT);
+        }
+    }
+
+    int getHeight() {
         return height;
     }
 }

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

@@ -1,5 +1,6 @@
 package ladder.domain;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -10,7 +11,7 @@ public class Ladder {
     private List<Line> lines;
 
     private Ladder(List<Line> lines) {
-        this.lines = lines;
+        this.lines = new ArrayList<>(lines);
     }
 
     public static Ladder from(Players players, Height height) {
@@ -20,6 +21,13 @@ public static Ladder from(Players players, Height height) {
                 .collect(Collectors.toList()));
     }
 
+    Position goThroughLinesFrom(Position position) {
+        for (Line line : lines) {
+            position = line.travel(position);
+        }
+        return position;
+    }
+
     public List<Line> getLines() {
         return Collections.unmodifiableList(lines);
     }

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

@@ -6,9 +6,9 @@
 
 public class Line {
 
-    private List<Boolean> bars;
+    private List<Bar> bars;
 
-    private Line(List<Boolean> bars) {
+    Line(List<Bar> bars) {
         this.bars = new ArrayList<>(bars);
     }
 
@@ -17,7 +17,18 @@ public static Line from(int numberOfPlayers) {
         return new Line(lineMaker.generateBars(numberOfPlayers));
     }
 
-    public List<Boolean> getBars() {
+    public List<Bar> getBars() {
         return Collections.unmodifiableList(bars);
     }
+
+    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개를 사용해서 위치를 갱신하는 방식이라 이 곳에서 처리하는 상태
+
 }

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

@@ -4,29 +4,40 @@
 import java.util.List;
 
 class LineMaker {
+    private static final int NUMBER_OF_FIRST_AND_LAST_BAR = 2;
 
-    private List<Boolean> randomBars = new ArrayList<>();
-    private BarGeneratorImpl barGenerator = new BarGeneratorImpl();
+    private List<Bar> randomBars;
+    private RandomBarGenerator barGenerator = new RandomBarGenerator();
 
-    List<Boolean> generateBars(int numberOfPlayers) {
-        randomBars.add(barGenerator.generateBar());
-        for (int i = 1; i < numberOfPlayers - 1; i++) {
-            boolean previousBarExist = randomBars.get(i - 1);
-            addNextBar(previousBarExist);
-        }
-        addBlankBar();
+    List<Bar> generateBars(int numberOfPlayers) {
+        this.randomBars = new ArrayList<>();
+        generateFirstBar();
+        generateMiddleBars(numberOfPlayers);
+        generateLastBar();
         return randomBars;
     }
 
-    private void addNextBar(boolean previousBarExist) {
-        if (previousBarExist) {
-            addBlankBar();
+    private void generateFirstBar() {
+        randomBars.add(Bar.from(barGenerator.generateBar()));
+    }
+
+    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 addNextBar(Bar previousBar) {
+        if (previousBar.isExist()) {
+            generateLastBar();
             return;
         }
-        randomBars.add(barGenerator.generateBar());
+        randomBars.add(Bar.from(barGenerator.generateBar()));
     }
 
-    private void addBlankBar() {
-        randomBars.add(false);
+    private void generateLastBar() {
+        randomBars.add(Bar.from(Boolean.FALSE));
     }
 }

src/main/java/ladder/domain/Player.java

@@ -25,6 +25,10 @@ private void validationPlayerName(String name) {
         }
     }
 
+    boolean isSame(String wantedPlayer) {
+        return wantedPlayer.equals(name);
+    }
+
     public String getName() {
         return name;
     }

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

@@ -1,5 +1,6 @@
 package ladder.domain;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -13,10 +14,8 @@ public class Players {
     private final List<Player> players;
 
     private Players(List<Player> players) {
-        if (players.size() < MINIMUM_NUMBER_OF_PLAYERS) {
-            throw new IllegalArgumentException(ALERT_SHORTAGE_OF_NUMBER_OF_PLAYERS);
-        }
-        this.players = players;
+        validationPlayers(players);
+        this.players = new ArrayList<>(players);
     }
 
     public static Players of(String inputNames) {
@@ -26,6 +25,12 @@ public static Players of(String inputNames) {
                 .collect(Collectors.toList()));
     }
 
+    private void validationPlayers(List<Player> players) {
+        if (players.size() < MINIMUM_NUMBER_OF_PLAYERS) {
+            throw new IllegalArgumentException(ALERT_SHORTAGE_OF_NUMBER_OF_PLAYERS);
+        }
+    }
+
     public int numberOfPlayers() {
         return players.size();
     }

src/main/java/ladder/domain/Position.java

@@ -0,0 +1,49 @@
+package ladder.domain;
+
+public class Position {
+
+    private static final int MOVE_ONE_STEP_TO_RIGHT = 1;
+    private static final int MOVE_ONE_STEP_TO_LEFT = -1;
+    static final String ALERT_UNMOVABLE_TO_LEFT = "더 이상 왼쪽으로 이동할 수 없습니다.";
+    private int position;
+
+    private Position(int currentPosition) {
+        this.position = currentPosition;
+    }
+
+    public static Position from(int currentPosition) {
+        return new Position(currentPosition);
+    }
+
+    public boolean isSameWith(int targetPosition) {
+        return position == targetPosition;
+    }
+
+    Position moveToRight() {
+        return from(this.position + MOVE_ONE_STEP_TO_RIGHT);
+    }
+
+    Position moveToLeft() {
+        validationMovableToLeft();
+        return from(this.position + MOVE_ONE_STEP_TO_LEFT);
+    }
+
+    int getPosition() {
+        return position;
+    }
+
+    int getLeftPosition() {
+        validationMovableToLeft();
+        return this.position + MOVE_ONE_STEP_TO_LEFT;
+    }
+
+    private void validationMovableToLeft() {
+        if (unmovableToLeft()) {
+            throw new IllegalArgumentException(ALERT_UNMOVABLE_TO_LEFT);
+        }
+    }
+
+    private boolean unmovableToLeft() {
+        return position <= 0;
+    }
+}