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

README.md

@@ -0,0 +1,33 @@
+# 기능 구현
+
+사다리의 연결은 Boolean을 통해 표현
++ true면 "-----" 연결되었다는 뜻
++ false면 연결되지 않았다는 뜻
+
+## **controller**
++ LadderController
+
+## **domain**
++ Ladder
+  * List<Line> 사다리 전체를 표현하는 객체
++ LadderGame
+  * 사다리 게임 실행과 관련된 메서드를 담은 클래스
++ LadderGenerator
+  * 사다리 생성과 관련된 메서드를 담은 클래스
++ Line
+  * List<Boolean> 사다리 한 줄을 표현하는 객체
++ PlayerName
+  * 플레이어 이름을 원시값 포장한 객체
++ Player
+  * 플레이어 객체
++ Players
+  * 플레이어 리스트 일급 컬렉션
++ Positon
+  * 플레이어 위치를 원시값 포장한 객체
++ ResultTypes
+  * 결과 리스트 일급 컬렉션
+
+## **View**
++ InputException
++ InputView
++ OutputView

src/main/java/Application.java

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

src/main/java/controller/LadderController.java

@@ -0,0 +1,43 @@
+package controller;
+
+import domain.Ladder;
+import domain.LadderGame;
+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() {
+        // 게임 로직 시작
+        LadderGame ladderGame = new LadderGame();
+
+        // 플레이어 생성
+        List<String> playerNames = InputView.splitString(InputView.inputNames());
+        Players players = new Players(playerNames);
+
+        // 결과 생성
+        List<String> kindOfResults = InputView.splitString(InputView.inputLadderResults());
+        ResultTypes resultTypes = new ResultTypes(kindOfResults, players.getPlayersSize());
+
+        // 사다리 생성
+        int width = players.getPlayersSize();
+        int height = InputView.inputHeight();
+
+        LadderGenerator ladderGenerator = new LadderGenerator();
+        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,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/LadderGame.java

@@ -0,0 +1,23 @@
+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 lineIndex) {
+        if (lineIndex != 0 && line.get(lineIndex - 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/Player.java

@@ -0,0 +1,28 @@
+package domain;
+
+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 moveLeft() {
+        position.movePositionLeft();
+    }
+
+    public void moveRight() {
+        position.movePositionRight();
+    }
+
+    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("이름은 5자를 초과할 수 없습니다.");
+        }
+    }
+
+    private void validateNotEqualAll(String name) {
+        if (name.equals(INVALID_NAME)) {
+            throw new IllegalArgumentException("이름은 all일 수 없습니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

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 PlayerName(playerNames.get(i)), new Position(i)));
+        }
+
+        return players;
+    }
+
+    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/Position.java

@@ -0,0 +1,22 @@
+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("이름은 공백일 수 없습니다.");
+        }
+    }
+}