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

src/main/java/Main.java

@@ -0,0 +1,43 @@
+import domain.Ladder;
+import domain.LadderGame;
+import domain.LadderGenerator;
+import domain.Players;
+import domain.ResultTypes;
+import view.OutputView;
+import view.InputView;
+
+import java.util.List;
+
+
+public class Main {
+    public static void main(String[] args) {
+        // 사다리 게임 시작
+        final LadderGame ladderGame = new LadderGame();
+
+        // 플레이어 생성
+        final List<String> playerNames = InputView.splitString(InputView.inputNames());
+        final Players players = new Players(playerNames);
+
+        // 실행결과 생성
+        final List<String> kindOfResults = InputView.splitString(InputView.inputLadderResults());
+        final ResultTypes resultTypes = new ResultTypes(kindOfResults, players.getPlayersSize());
+
+        // 사다리 생성
+        final int width = players.getPlayersSize();
+        final int height = InputView.inputHeight();
+
+        final LadderGenerator ladderGenerator = new LadderGenerator();
+        final Ladder ladder = ladderGenerator.createLadder(width, height);
+
+        // 사다리 그리기
+        OutputView.printPlayers(playerNames);
+        OutputView.drawLadder(ladder);
+        OutputView.printResultTypes(resultTypes.getResultTypes());
+
+        // 사다리 게임 시작
+        ladderGame.runGame(ladder, players);
+
+        // 결과 출력
+        OutputView.printResult(players, resultTypes.getResultTypes());
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,16 @@
+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/LadderGame.java

@@ -0,0 +1,24 @@
+package domain;
+
+public class LadderGame {
+
+    public void movePlayer(Line line, Player player) {
+        if (line.canMoveRight(player.getPosition())) {
+            player.moveRight();
+            return;
+        }
+
+        if (line.canMoveLeft(player.getPosition())) {
+            player.moveLeft();
+        }
+    }
+
+    public void moveEachPlayer(Ladder ladder, Player player) {
+        ladder.getLadder().forEach(line -> movePlayer(line, player));
+    }
+
+    public void runGame(Ladder ladder, Players players) {
+        players.getPlayers().forEach(player -> moveEachPlayer(ladder, player));
+    }
+
+}

src/main/java/domain/LadderGenerator.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.lang.Boolean.TRUE;
+
+public class LadderGenerator {
+
+    public boolean randomTrueOrFalse() {
+        return Math.random() < 0.5;         // 0.0(포함) - 1.0(미포함) 사이의 랜덤한 실수 반환
+    }
+
+    public boolean createValue(List<Boolean> line, int index) {
+        if (index != 0 && line.get(index - 1) == TRUE)    // 이전 값이 true 면 false 반환
+            return false;
+
+        return randomTrueOrFalse();
+    }
+
+    public Line createLine(int width) {
+        List<Boolean> 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,26 @@
+package domain;
+
+import java.util.Collections;
+import java.util.List;
+
+import static java.lang.Boolean.TRUE;
+
+public class Line {
+    private final List<Boolean> points;
+
+    public Line(List<Boolean> points) {
+        this.points = points;
+    }
+
+    public boolean canMoveRight(int ladderOrder) {
+        return (ladderOrder < points.size()) && (points.get(ladderOrder) == TRUE);
+    }
+
+    public boolean canMoveLeft(int ladderOrder) {
+        return (ladderOrder != 0) && (points.get(ladderOrder - 1) == TRUE);
+    }
+
+    public List<Boolean> getLine() {
+        return Collections.unmodifiableList(points);
+    }
+}

src/main/java/domain/Name.java

@@ -0,0 +1,41 @@
+package domain;
+
+public class Name {
+
+    private final String name;
+    private final static int MAX_LENGTH = 5;
+    private final static String INVALID_NAME = "all";
+
+    public Name(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("이름은 5자를 초과할 수 없습니다.");
+        }
+    }
+
+    private void validateNotEqualAll(String name) {
+        if (name.equals(INVALID_NAME)) {
+            throw new IllegalArgumentException("이름은 all일 수 없습니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/domain/Player.java

@@ -0,0 +1,28 @@
+package domain;
+
+public class Player {
+
+    private final Name name;
+    private final Position position;
+
+    public Player(Name name, Position position) {
+        this.name = name;
+        this.position = position;
+    }
+
+    public void moveLeft() {
+        position.movePositionLeft();
+    }
+
+    public void moveRight() {
+        position.movePositionRight();
+    }
+
+    public String getName() {
+        return name.getName();
+    }
+
+    public int getPosition() {
+        return position.getPosition();
+    }
+}

src/main/java/domain/Players.java

@@ -0,0 +1,47 @@
+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 Name(playerNames.get(i)), new Position(i)));
+        }
+
+        return players;
+    }
+
+    public Player findByName(String viewerName) {
+        return players.stream()
+                .filter(player -> player.getName().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/Position.java

@@ -0,0 +1,23 @@
+package domain;
+
+public class Position {
+
+    private int position;
+
+    public Position(int position) {
+        this.position = position;
+    }
+
+    public void movePositionLeft() {
+        position--;
+    }
+
+    public void movePositionRight() {
+        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;
+    }
+}

src/main/java/view/InputException.java

@@ -0,0 +1,16 @@
+package view;
+
+public class InputException {
+
+    public static void validateHeightSize(int height) {
+        if (height < 1) {
+            throw new IllegalArgumentException("사다리 높이는 1 이상이어야 합니다.");
+        }
+    }
+
+    public static void validateViewerNameNotBlank(String viewerName) {
+        if (viewerName.isBlank()) {
+            throw new IllegalArgumentException("이름은 공백일 수 없습니다.");
+        }
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,38 @@
+package view;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner input = new Scanner(System.in);
+
+    public static List<String> splitString(String string) {
+        return Arrays.asList(string.split(","));
+    }
+
+    public static String inputNames() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        return input.nextLine();
+    }
+
+    public static String inputLadderResults() {
+        System.out.println("실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+        return input.nextLine();
+    }
+
+    public static int inputHeight() {
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        int height = input.nextInt();
+        InputException.validateHeightSize(height);
+        input.nextLine();
+        return height;
+    }
+
+    public static String inputViewerName() {
+        System.out.println("\n결과를 보고 싶은 사람은?");
+        String viewerName = input.nextLine();
+        InputException.validateViewerNameNotBlank(viewerName);
+        return viewerName;
+    }
+}