[1단계 - 사다리 생성] 제이(이재윤) 미션 제출합니다.

README.md

@@ -5,3 +5,47 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 기능 요구사항
+
+1. 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다.
+    1. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+2. 사람 이름은 쉼표(,)를 기준으로 구분한다.
+3. 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
+4. 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+5. |-----|-----| 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다.
+
+---
+
+## 기능 리스트
+
+- 입력에서 처리해야하는 예외
+    - [x] height -> 숫자만 가능하도록
+
+- Player(PlayerName)
+    - 예외
+        - [x] 이름은 최소 1자 이상, 최대 5글자
+    - [x] 이름의 길이를 반환한다.
+
+- Players
+    - 예외
+        - [x] 참여 가능 플레이어 수는 2명 이상, 10명 이하이다.
+        - [x] 참여 플레이어의 이름 중 중복된 이름이 있으면 안된다.
+    - [x] 플레이어들의 이름 중 가장 긴 이름의 길이를 반환해준다.
+    - [x] 플레이어 만드는 기능
+    - [x] 참여한 플레이어의 숫자를 반환한다.
+    - [x] 첫번째 플레이어의 이름, 이름 길이를 반환한다.
+
+- Ladder(Height, Lines)
+    - Height, Line을 관리한다. (확장성)
+
+- Height(int height)
+    - 예외
+        - [x] 높이는 1 이상 10 이하이다.
+    - [x] 높이는 입력을 받은 만큼 생성된다.
+
+- Line (높이당 1개씩)
+    - [x] 발판 만드는 기능
+
+- LadderSymbol
+    - [x] 기호를 반복 횟수만큼 반환하는 기능 

src/main/java/Application.java

@@ -0,0 +1,9 @@
+import controller.LadderGameController;
+
+public class Application {
+
+    public static void main(String[] args) {
+        LadderGameController ladderGameController = new LadderGameController();
+        ladderGameController.run();
+    }
+}

src/main/java/controller/LadderGameController.java

@@ -0,0 +1,48 @@
+package controller;
+
+import domain.Height;
+import domain.Ladder;
+import domain.Lines;
+import domain.Players;
+import java.util.List;
+import view.InputView;
+import view.OutputView;
+
+public class LadderGameController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderGameController() {
+        this.inputView = new InputView();
+        this.outputView = new OutputView();
+    }
+
+    public void run() {
+        Players players = makePlayers();
+        Ladder ladder = makeLadder(players.findNumberOfPlayers());
+
+        outputView.printResult(players, ladder);
+    }
+
+    private Players makePlayers() {
+        try {
+            List<String> playerNames = inputView.readPlayerNames();
+            return new Players(playerNames);
+        } catch (IllegalArgumentException exception) {
+            System.out.println(exception.getMessage());
+            return makePlayers();
+        }
+    }
+
+    private Ladder makeLadder(int numberOfPlayers) {
+        try {
+            int ladderHeight = inputView.readHeight();
+            Ladder ladder = new Ladder(new Lines(numberOfPlayers, ladderHeight), new Height(ladderHeight));
+            return ladder;
+        } catch (IllegalArgumentException exception) {
+            System.out.println(exception.getMessage());
+            return makeLadder(numberOfPlayers);
+        }
+    }
+}

src/main/java/domain/Height.java

@@ -0,0 +1,28 @@
+package domain;
+
+public class Height {
+
+    private static final int MINIMUM_LENGTH_OF_HEIGHT = 1;
+    private static final int MAXIMUM_LENGTH_OF_HEIGHT = 10;
+
+    private final int height;
+
+    public Height(final int height) {
+        validateLengthOfHeight(height);
+        this.height = height;
+    }
+
+    private void validateLengthOfHeight(final int height) {
+        if (isNotPermittedLengthOfHeight(height)) {
+            throw new IllegalArgumentException("사다리의 높이는 최소 1이상 최대 10이하입니다.");
+        }
+    }
+
+    private boolean isNotPermittedLengthOfHeight(int height) {
+        return (height < MINIMUM_LENGTH_OF_HEIGHT) || (height > MAXIMUM_LENGTH_OF_HEIGHT);
+    }
+
+    public int getHeight() {
+        return height;
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,20 @@
+package domain;
+
+public class Ladder {
+
+    private final Lines lines;
+    private final Height height;
+
+    public Ladder(final Lines lines, final Height height) {
+        this.lines = lines;
+        this.height = height;
+    }
+
+    public int findLadderHeight() {
+        return this.height.getHeight();
+    }
+
+    public Lines getLines() {
+        return lines;
+    }
+}

src/main/java/domain/LadderSymbol.java

@@ -0,0 +1,27 @@
+package domain;
+
+import java.util.Arrays;
+
+public enum LadderSymbol {
+
+    BLANK(" "),
+    FOOTHOLD("-"),
+    BAR("|");
+
+    private final String symbol;
+
+    LadderSymbol(final String symbol) {
+        this.symbol = symbol;
+    }
+
+    public static String draw(final String symbol, final int repeatedNumber) {
+        return find(symbol).symbol.repeat(repeatedNumber);
+    }
+
+    private static LadderSymbol find(final String symbol) {
+        return Arrays.stream(values())
+                .filter(value -> value.symbol.equals(symbol))
+                .findAny()
+                .orElseThrow(IllegalArgumentException::new);
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,58 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import utils.FootholdGenerator;
+
+public class Line {
+
+    private final List<Boolean> footholds;
+
+    public Line(final int numberOfPlayer, final FootholdGenerator footholdGenerator) {
+        footholds = makeFootholds(numberOfPlayer, footholdGenerator);
+    }
+
+    private List<Boolean> makeFootholds(final int numberOfPlayer, final FootholdGenerator footholdGenerator) {
+        List<Boolean> footholds = new ArrayList<>();
+
+        generateFootholds(footholdGenerator, footholds, numberOfPlayer);
+
+        return footholds;
+    }
+
+    private void generateFootholds(final FootholdGenerator footholdGenerator, final List<Boolean> footholds,
+                                   final int numberOfPlayer) {
+        int numberOfPoint = numberOfPlayer - 1;
+
+        createFirstFoothold(footholds, footholdGenerator);
+        createOtherFootholds(footholdGenerator, footholds, numberOfPoint);
+    }
+
+    private void createFirstFoothold(final List<Boolean> points, final FootholdGenerator footholdGenerator) {
+        points.add(footholdGenerator.generate());
+    }
+
+    private void createOtherFootholds(final FootholdGenerator footholdGenerator, final List<Boolean> footholds,
+                                      final int numberOfPoint) {
+        for (int i = 1; i < numberOfPoint; i++) {
+            boolean isExistFoothold = footholdGenerator.generate();
+            createFootholdWithoutFirst(footholds, i, isExistFoothold);
+        }
+    }
+
+    private void createFootholdWithoutFirst(final List<Boolean> points, final int index, final boolean isExistFoothold) {
+        if (isConsecutiveExistingFoothold(points, index, isExistFoothold)) {
+            points.add(false);
+            return;
+        }
+        points.add(isExistFoothold);
+    }
+
+    private boolean isConsecutiveExistingFoothold(final List<Boolean> points, final int index, final boolean random) {
+        return points.get(index - 1) && random;
+    }
+
+    public List<Boolean> getFootholds() {
+        return footholds;
+    }
+}

src/main/java/domain/Lines.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import utils.RandomFootholdGenerator;
+
+public class Lines {
+
+    private final List<Line> lines;
+
+    public Lines(final int numberOfPlayer, final int height) {
+        this.lines = makeLines(numberOfPlayer, height);
+    }
+
+    public Lines(final List<Line> lines) {
+        this.lines = lines;
+    }
+
+    private List<Line> makeLines(final int numberOfPlayer, final int height) {
+        List<Line> lines = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            lines.add(new Line(numberOfPlayer, new RandomFootholdGenerator()));
+        }
+
+        return lines;
+    }
+
+    public List<Boolean> findSelectedLine(final int selectedPosition) {
+        return this.lines.get(selectedPosition).getFootholds();
+    }
+
+    public List<Line> getLines() {
+        return Collections.unmodifiableList(this.lines);
+    }
+}

src/main/java/domain/Player.java

@@ -0,0 +1,18 @@
+package domain;
+
+public class Player {
+
+    private final PlayerName playerName;
+
+    public Player(final String playerName) {
+        this.playerName = new PlayerName(playerName);
+    }
+
+    public String getName() {
+        return this.playerName.getName();
+    }
+
+    public int getLengthOfPlayerName() {
+        return this.playerName.getLengthOfName();
+    }
+}

src/main/java/domain/PlayerName.java

@@ -0,0 +1,32 @@
+package domain;
+
+public class PlayerName {
+
+    private static final int MINIMUM_LENGTH_OF_NAME = 1;
+    private static final int MAXIMUM_LENGTH_OF_NAME = 5;
+
+    private final String name;
+
+    public PlayerName(final String name) {
+        validateLengthOfName(name);
+        this.name = name;
+    }
+
+    private void validateLengthOfName(final String name) {
+        if (isNotPermittedLengthOfName(name)) {
+            throw new IllegalArgumentException("이름의 길이는 최소 1자 이상, 5자 이하입니다.");
+        }
+    }
+
+    private boolean isNotPermittedLengthOfName(final String name) {
+        return (name.length() < MINIMUM_LENGTH_OF_NAME) || (name.length() > MAXIMUM_LENGTH_OF_NAME);
+    }
+
+    public int getLengthOfName() {
+        return this.name.length();
+    }
+
+    public String getName() {
+        return this.name;
+    }
+}