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

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,8 @@
+import controller.LadderController;
+
+public class Application {
+    public static void main(String[] args) {
+        LadderController ladderController = new LadderController();
+        ladderController.run();
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,50 @@
+package controller;
+
+import domain.Ladder;
+import domain.LadderGenerator;
+import domain.Players;
+import domain.ResultTypes;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+
+public class LadderController {
+
+    public void run() {
+        List<String> playerNames = InputView.splitString(InputView.inputNames());
+        List<String> kindOfResults = InputView.splitString(InputView.inputLadderResults());
+
+        // 플레이어 생성
+        Players players = new Players(playerNames);
+        // 결과 종류 생성
+        ResultTypes resultTypes = new ResultTypes(kindOfResults, players.getPlayersSize());
+        // 사다리 초기화
+        Ladder ladder = initializeLadder(players);
+
+        // 사다리 및 결과 출력
+        displayLadder(resultTypes, playerNames, ladder);
+        playGameAndDisplayResults(resultTypes, players, ladder);
+    }
+
+    private Ladder initializeLadder(Players players) {
+        int width = players.getPlayersSize();
+        int height = InputView.inputHeight();
+
+        LadderGenerator ladderGenerator = new LadderGenerator();
+        Ladder ladder = ladderGenerator.createLadder(width, height);
+
+        return ladder;
+    }
+
+    private void displayLadder(ResultTypes resultTypes, List<String> playerNames, Ladder ladder) {
+        OutputView.printPlayers(playerNames);
+        OutputView.drawLadder(ladder);
+        OutputView.printResultTypes(resultTypes.getResultTypes());
+    }
+
+    private void playGameAndDisplayResults(ResultTypes resultTypes, Players players, Ladder ladder) {
+        players.moveAllPlayers(ladder);
+        OutputView.printResult(players, resultTypes.getResultTypes());
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,17 @@
+package domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    public Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public List<Line> getLadder() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/domain/LadderGenerator.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LadderGenerator {
+
+    private boolean randomTrueOrFalse() {
+        return Math.random() < 0.5;         // 0.0(포함) - 1.0(미포함) 사이의 랜덤한 실수 반환
+    }
+
+    private Point createValue(List<Point> line, int lineIndex) {
+        if (lineIndex != 0 && line.get(lineIndex - 1).isEnabled()) {    // 이전 값이 true 면 false 반환
+            return Point.DISABLED;
+        }
+
+        return Point.FROM_BOOLEAN.apply(randomTrueOrFalse());
+    }
+
+    public Line createLine(int width) {
+        List<Point> points = new ArrayList<>();
+        for (int i = 0; i < width - 1; i++) {
+            points.add(createValue(points, i));
+        }
+
+        return new Line(points);
+    }
+
+    public Ladder createLadder(int width, int height) {
+        List<Line> lines = new ArrayList<>();
+        for (int i = 0; i < height; i++) {
+            lines.add(createLine(width));
+        }
+
+        return new Ladder(lines);
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,28 @@
+package domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Line {
+    private final List<Point> points;
+
+    public Line(List<Point> points) {
+        this.points = points;
+    }
+
+    public boolean canMoveRight(int ladderOrder) {
+        return (ladderOrder < points.size()) && (points.get(ladderOrder).isEnabled());
+    }
+
+    public boolean canMoveLeft(int ladderOrder) {
+        return (ladderOrder != 0) && (points.get(ladderOrder - 1).isEnabled());
+    }
+
+    public List<Point> getLine() {
+        return Collections.unmodifiableList(points);
+    }
+
+    public int getSize() {
+        return points.size();
+    }
+}

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(this.position::decideWhereToGo);
+    }
+
+    public String getPlayerName() {
+        return playerName.getName();
+    }
+
+    public int getPosition() {
+        return position.getPosition();
+    }
+}

src/main/java/domain/PlayerName.java

@@ -0,0 +1,41 @@
+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) {
+        validateMaxLength(name);
+        validateNotBlank(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 + "일 수 없습니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/domain/Players.java

@@ -0,0 +1,51 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+public class Players {
+
+    private final List<Player> players;
+    private final static int MIN_PLAYER_SIZE = 2;
+
+    public Players(List<String> playerNames) {
+        validateSize(playerNames);
+        this.players = createPlayer(playerNames);
+    }
+
+    private void validateSize(List<String> playerNames) {
+        if (playerNames.size() < MIN_PLAYER_SIZE) {
+            throw new IllegalArgumentException("플레이어 수는 2명 이상이어야 합니다.");
+        }
+    }
+
+    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 void moveAllPlayers(Ladder ladder) {
+        players.forEach(player -> player.moveAlongLadder(ladder.getLadder()));
+    }
+
+    public Player findByName(String viewerName) {
+        return players.stream()
+                .filter(player -> player.getPlayerName().equals(viewerName))
+                .findFirst()
+                .orElseThrow(() -> new NoSuchElementException("플레이어 이름 '" + viewerName + "' 이 존재하지 않습니다."));
+    }
+
+    public List<Player> getPlayers() {
+        return Collections.unmodifiableList(players);
+    }
+
+    public int getPlayersSize() {
+        return players.size();
+    }
+}

src/main/java/domain/Point.java

@@ -0,0 +1,26 @@
+package domain;
+
+import java.util.function.Function;
+
+public enum Point {
+    ENABLED(true),
+    DISABLED(false);
+
+    private final boolean enabled;
+
+    // 생성자를 통해 상태를 설정
+    Point(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public static final Function<Boolean, Point> FROM_BOOLEAN = value -> {
+        if (value) {
+            return ENABLED;
+        }
+        return DISABLED;
+    };
+}

src/main/java/domain/Position.java

@@ -0,0 +1,37 @@
+package domain;
+
+public class Position {
+
+    private int position;
+
+    public Position(int position) {
+        this.position = position;
+    }
+
+    public void decideWhereToGo(Line line) {
+        if (line.canMoveRight(position)) {
+            moveRight(line.getSize());
+            return;
+        }
+
+        if (line.canMoveLeft(position)) {
+            moveLeft();
+        }
+    }
+
+    public void moveLeft() {
+        if (position != 0) {
+            position--;
+        }
+    }
+
+    public void moveRight(int maxPosition) {
+        if (position != maxPosition) {
+            position++;
+        }
+    }
+
+    public int getPosition() {
+        return position;
+    }
+}

src/main/java/domain/ResultTypes.java

@@ -0,0 +1,34 @@
+package domain;
+
+import java.util.List;
+
+public class ResultTypes {
+
+    private final List<String> resultTypes;
+
+    public ResultTypes(List<String> resultTypes, int width) {
+        validate(resultTypes, width);
+        this.resultTypes = resultTypes;
+    }
+
+    private void validate(List<String> resultTypes, int width) {
+        resultTypes.forEach(this::validateNotBlank);
+        validateSize(resultTypes, width);
+    }
+
+    private void validateNotBlank(String resultType) {
+        if (resultType.isBlank()) {
+            throw new IllegalArgumentException("실행 결과는 공백일 수 없습니다.");
+        }
+    }
+
+    private void validateSize(List<String> resultTypes, int width) {
+        if (resultTypes.size() != width) {
+            throw new IllegalArgumentException("실행 결과는 사다리의 개수와 일치해야 합니다.");
+        }
+    }
+
+    public List<String> getResultTypes() {
+        return resultTypes;
+    }
+}