[사다리 미션] 정상희 미션 제출합니다.

README.md

@@ -0,0 +1,24 @@
+# 기능 목록
+
+### 1. 플레이어 및 사다리 정보 입력 기능
++ 플레이어 이름과 결과 종류를 입력한다.
++ 사다리 넓이 : (플레이어 수 - 1)
++ 사다리 높이 : 사용자 입력
+### 2. 사다리 실행 기능
++ |-----|-----| 가로 라인이 겹치지 않게 사다리를 생성한다.
+=> 즉, 앞 라인이 true면 다음 라인은 무조건 false이다.
+### 3. 사다리 출력 기능
++ 플레이어 이름 입력 순으로 출력
++ 생성된 사다리 출력
++ 결과 종류 입력 순으로 출력
++ 보고 싶은 실행 결과 출력 ("all"일 때는 모두 출력)
+
+### <사다리 구현>
++ Boolean (다리)
+  + ture : 연결
+  + false : 연결 X  
++ List&lt;Boolean&gt (한 층의 다리 모음)
+  + 사다리의 넒이만큼
+  + 다리가 연결되어 있으면(=true) 수평 방향으로 이동이 가능하다.
++ List&lt;Line&gt (모든 층의 다리 모음)
+  + 사다리의 높이만큼

src/main/java/Application.java

@@ -0,0 +1,22 @@
+import controller.LadderController;
+import domain.Ladder;
+import domain.Players;
+import domain.ResultTypes;
+
+public class Application {
+    public static void main(String[] args) {
+        runLadderGame();
+    }
+
+    private static void runLadderGame() {
+        LadderController ladderController = new LadderController();
+
+        Players players = ladderController.initializePlayers();
+        ResultTypes resultTypes = ladderController.initializeResults(players.getPlayersSize());
+        Ladder ladder = ladderController.initializeLadder(players.getPlayersSize());
+
+        ladderController.playGame(players, ladder);
+
+        ladderController.displayAllOutput(players, resultTypes, ladder);
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,49 @@
+package controller;
+
+import domain.Ladder;
+import domain.Players;
+import domain.ResultTypes;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+
+public class LadderController {
+
+    public Players initializePlayers() {
+        List<String> playerNames = InputView.splitString(InputView.inputNames());
+
+        return new Players(playerNames);
+    }
+
+    public ResultTypes initializeResults(int resultsSize) {
+        List<String> kindOfResults = InputView.splitString(InputView.inputLadderResults());
+
+        return new ResultTypes(kindOfResults, resultsSize);
+    }
+
+    public Ladder initializeLadder(int width) {
+        int height = InputView.inputHeight();
+
+        return new Ladder(width, height);
+    }
+
+    public void playGame(Players players, Ladder ladder) {
+        ladder.determineLadderResults(players);
+    }
+
+    public void displayAllOutput(Players players, ResultTypes resultTypes, Ladder ladder) {
+        displayLadder(players, resultTypes, ladder);
+        displayResults(resultTypes, players);
+    }
+
+    private void displayLadder(Players players, ResultTypes resultTypes, Ladder ladder) {
+        OutputView.printPlayers(players);
+        OutputView.drawLadder(ladder);
+        OutputView.printResultTypes(resultTypes.getResultTypes());
+    }
+
+    private void displayResults(ResultTypes resultTypes, Players players) {
+        OutputView.printResult(players, resultTypes.getResultTypes());
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,29 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    public Ladder(int width, int height) {
+        this.lines = new ArrayList<>();
+        createLadder(width, height);
+    }
+
+    public void createLadder(int width, int height) {
+        for (int i = 0; i < height; i++) {
+            lines.add(new Line(width));
+        }
+    }
+
+    public void determineLadderResults(Players players) {
+        players.getPlayers().forEach(player -> player.moveAlongLadder(lines));
+    }
+
+    public List<Line> getLadder() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/domain/LadderStep.java

@@ -0,0 +1,43 @@
+package domain;
+
+import java.util.function.Function;
+
+public enum LadderStep {
+    CONNECTED {
+        @Override
+        public boolean canMove() {
+            return true;
+        }
+
+        @Override
+        public LadderStep nextStep() {
+            return NOT_CONNECTED;
+        }
+    },
+    NOT_CONNECTED {
+        @Override
+        public boolean canMove() {
+            return false;
+        }
+
+        @Override
+        public LadderStep nextStep() {
+            return FROM_BOOLEAN.apply(randomTrueOrFalse());
+        }
+    };
+
+    public abstract boolean canMove();
+
+    public abstract LadderStep nextStep();
+
+    public static final Function<Boolean, LadderStep> FROM_BOOLEAN = value -> {
+        if (value) {
+            return CONNECTED;
+        }
+        return NOT_CONNECTED;
+    };
+
+    public static boolean randomTrueOrFalse() {
+        return Math.random() < 0.5;
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,49 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static domain.LadderStep.randomTrueOrFalse;
+
+public class Line {
+    private final List<LadderStep> ladderSteps;
+
+    public Line(int width) {
+        this.ladderSteps = new ArrayList<>();
+        createLine(width);
+    }
+
+    public void createLine(int width) {
+        ladderSteps.add(LadderStep.FROM_BOOLEAN.apply(randomTrueOrFalse()));
+
+        for (int i = 1; i < width - 1; i++) {
+            ladderSteps.add(ladderSteps.get(i - 1).nextStep());
+        }
+    }
+
+    public void decideWhereToGo(Position position) {
+        int ladderOrder = position.getPosition();
+
+        if (canMoveRight(ladderOrder)) {
+            position.moveRight(ladderSteps.size());
+            return;
+        }
+
+        if (canMoveLeft(ladderOrder)) {
+            position.moveLeft();
+        }
+    }
+
+    private boolean canMoveRight(int ladderOrder) {
+        return ladderOrder < ladderSteps.size() && ladderSteps.get(ladderOrder).canMove();
+    }
+
+    private boolean canMoveLeft(int ladderOrder) {
+        return ladderOrder != 0 && ladderSteps.get(ladderOrder - 1).canMove();
+    }
+
+    public List<LadderStep> getLine() {
+        return Collections.unmodifiableList(ladderSteps);
+    }
+}

src/main/java/domain/Player.java

@@ -0,0 +1,26 @@
+package domain;
+
+import java.util.List;
+
+public class Player {
+
+    private final PlayerName playerName;
+    private final Position position;
+
+    public Player(PlayerName name, Position position) {
+        this.playerName = name;
+        this.position = position;
+    }
+
+    public void moveAlongLadder(List<Line> ladder) {
+        ladder.forEach(line -> line.decideWhereToGo(this.position));
+    }
+
+    public PlayerName getPlayerName() {
+        return playerName.getName();
+    }
+
+    public int getPosition() {
+        return position.getPosition();
+    }
+}

src/main/java/domain/PlayerName.java

@@ -0,0 +1,59 @@
+package domain;
+
+public class PlayerName {
+
+    private final String name;
+    private final static int MAX_LENGTH = 5;
+    private final static String INVALID_NAME = "all";
+
+    public PlayerName(String name) {
+        validateName(name);
+        this.name = name;
+    }
+
+    private void validateName(String name) {
+        validateNotBlank(name);
+        validateMaxLength(name);
+        validateNotEqualAll(name);
+    }
+
+    private void validateNotBlank(String name) {
+        if (name.isBlank()) {
+            throw new IllegalArgumentException("이름은 공백일 수 없습니다.");
+        }
+    }
+
+    private void validateMaxLength(String name) {
+        if (name.length() > MAX_LENGTH) {
+            throw new IllegalArgumentException("이름은 " + MAX_LENGTH + "자를 초과할 수 없습니다.");
+        }
+    }
+
+    private void validateNotEqualAll(String name) {
+        if (name.equals(INVALID_NAME)) {
+            throw new IllegalArgumentException("이름은 " + INVALID_NAME + "일 수 없습니다.");
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true; // 메모리 주소 비교
+        if (o == null || getClass() != o.getClass()) return false;
+        PlayerName that = (PlayerName) o;
+        return name.equals(that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    public PlayerName getName() {
+        return this;
+    }
+}

src/main/java/domain/Players.java

@@ -0,0 +1,60 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+public class Players {
+
+    private final List<Player> players;
+    private final static int MIN_PLAYER_SIZE = 2;
+
+    public Players(List<String> playerNames) {
+        validateSize(playerNames);
+        validateDuplicateName(playerNames);
+        this.players = createPlayer(playerNames);
+    }
+
+    private void validateSize(List<String> playerNames) {
+        if (playerNames.size() < MIN_PLAYER_SIZE) {
+            throw new IllegalArgumentException("플레이어 수는 2명 이상이어야 합니다.");
+        }
+    }
+
+    private void validateDuplicateName(List<String> playerNames) {
+        Set<String> playerNamesSet = new HashSet<>(playerNames);
+
+        if (playerNames.size() != playerNamesSet.size()) {
+            throw new IllegalArgumentException("동명이인인 플레이어가 존재합니다.");
+        }
+    }
+
+    private List<Player> createPlayer(List<String> playerNames) {
+        List<Player> players = new ArrayList<>();
+        for (int i = 0; i < playerNames.size(); i++) {
+            players.add(new Player(new PlayerName(playerNames.get(i)), new Position(i)));
+        }
+
+        return players;
+    }
+
+    public Player findByName(String viewerName) {
+        PlayerName playerName = new PlayerName(viewerName);
+
+        return players.stream()
+                .filter(player -> player.getPlayerName().equals(playerName))
+                .findFirst()
+                .orElseThrow(() -> new NoSuchElementException("플레이어 이름 '" + viewerName + "' 이 존재하지 않습니다."));
+    }
+
+    public List<Player> getPlayers() {
+        return Collections.unmodifiableList(players);
+    }
+
+    public int getPlayersSize() {
+        return players.size();
+    }
+}

src/main/java/domain/Position.java

@@ -0,0 +1,28 @@
+package domain;
+
+public class Position {
+
+    private int position;
+
+    public Position(int position) {
+        this.position = position;
+    }
+
+    public void moveLeft() {
+        if (position == 0) {
+            throw new IllegalStateException("가장 왼쪽 사다리이므로 왼쪽으로 이동이 불가합니다.");
+        }
+        position--;
+    }
+
+    public void moveRight(int maxPosition) {
+        if (position == maxPosition) {
+            throw new IllegalStateException("가장 오른쪽 사다리이므로 오른쪽으로 이동이 불가합니다.");
+        }
+        position++;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+}