[사다리] 김의천 미션 제출합니다.

src/main/java/LadderApplication.java

@@ -0,0 +1,11 @@
+import controller.LadderGameController;
+
+public class LadderApplication {
+    public static void main(String[] args) {
+        final LadderGameController ladderGameController = new LadderGameController();
+
+        ladderGameController.inputGameInfos();
+        ladderGameController.showGameStatus();
+        ladderGameController.showGameResult();
+    }
+}

src/main/java/controller/LadderGameController.java

@@ -0,0 +1,91 @@
+package controller;
+
+import model.*;
+import view.InputView;
+import view.OutputView;
+
+import java.util.InputMismatchException;
+
+public class LadderGameController {
+    private LadderGame ladderGame;
+    private final LadderGenerator ladderGenerator = new LadderGenerator(new LadderConnectionGenerator());
+
+    public void inputGameInfos() {
+        PlayerNames playerNames = inputPlayerNames();
+        PrizeNames prizeNames = inputPrizeNames(playerNames.size());
+        int ladderHeight = inputLadderHeight();
+
+        ladderGame = new LadderGame(ladderGenerator, playerNames, prizeNames, ladderHeight);
+    }
+
+    public void showGameStatus() {
+        OutputView.printGameStatus(ladderGame.getGameStatus());
+    }
+
+    public void showGameResult() {
+        while (true) {
+            PlayerName playerNameForResult = InputView.inputPlayerNameForResult();
+
+            if (playerNameForResult.getName().equals("all")) {
+                OutputView.printAllPlayersResult(ladderGame.getAllPlayersResult());
+                continue;
+            }
+
+            if (playerNameForResult.getName().equals("exit")) {
+                OutputView.printExitMessage();
+                break;
+            }
+
+            OutputView.printPlayerResult(ladderGame.getPlayerPrize(playerNameForResult));
+        }
+    }
+
+
+    private PlayerNames inputPlayerNames() {
+        while (true) {
+            try {
+                return InputView.inputPlayerNames();
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private PrizeNames inputPrizeNames(int prizeCount) {
+        while (true) {
+            try {
+                return InputView.inputPrizeNames();
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private int inputLadderHeight() {
+        while (true) {
+            try {
+                int ladderHeight = InputView.inputLadderHeight();
+
+                if (ladderHeight <= 0) {
+                    throw new IllegalArgumentException("사다리 높이를 양수로 입력해주세요.");
+                }
+
+                return ladderHeight;
+            } catch (NumberFormatException e) {
+                OutputView.printErrorMessage("사다리 높이를 정수로 입력해주세요!");
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private PlayerName inputPlayerNameForResult() {
+        while (true) {
+            try {
+                return inputPlayerNameForResult();
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}

src/main/java/model/BooleanValueGenerator.java

@@ -0,0 +1,5 @@
+package model;
+
+public interface BooleanValueGenerator {
+    boolean generate();
+}

src/main/java/model/Ladder.java

@@ -0,0 +1,58 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Ladder {
+    private final List<LadderRow> ladder;
+    private final int rowCount;
+    private final int columnCount;
+
+    public Ladder(List<LadderRow> ladder) {
+        validateLadder(ladder);
+        this.ladder = new ArrayList<>(ladder);
+        this.rowCount = ladder.size();
+        this.columnCount = ladder.get(0).size() + 1;
+    }
+
+    private void validateLadder(List<LadderRow> ladder) {
+        boolean isAllLadderRowSizeSame = ladder.stream()
+                .map(LadderRow::size)
+                .distinct()
+                .count() == 1;
+
+        if (!isAllLadderRowSizeSame) {
+            throw new IllegalArgumentException("사다리를 이루는 행의 크기는 모두 같아야 합니다.");
+        }
+    }
+
+    private int getBottomIndex(int topIndex) {
+        int column = topIndex;
+
+        for (int row = 0; row < rowCount; row += 1) {
+            if (column > 0 && ladder.get(row).get(column - 1)) {
+                column -= 1;
+                continue;
+            }
+
+            if (column < columnCount - 1 && ladder.get(row).get(column)) {
+                column += 1;
+            }
+        }
+
+        return column;
+    }
+
+    public List<Integer> getConnections() {
+        return IntStream.range(0, columnCount)
+                .mapToObj((topIndex) -> getBottomIndex(topIndex))
+                .collect(Collectors.toList());
+    }
+
+    public List<LadderRow> getLadder() {
+        return Collections.unmodifiableList(ladder);
+    }
+}

src/main/java/model/LadderConnectionGenerator.java

@@ -0,0 +1,12 @@
+package model;
+
+import java.util.Random;
+
+public class LadderConnectionGenerator implements BooleanValueGenerator {
+    private final Random random = new Random();
+
+    @Override
+    public boolean generate() {
+        return random.nextBoolean();
+    }
+}

src/main/java/model/LadderGame.java

@@ -0,0 +1,45 @@
+package model;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LadderGame {
+    private final Ladder ladder;
+    private final PlayerNames playerNames;
+    private final PrizeNames prizeNames;
+    private final List<Integer> ladderConnections;
+
+    public LadderGame(LadderGenerator ladderGenerator, PlayerNames playerNames, PrizeNames prizeNames,
+                      int ladderHeight) {
+        this.ladder = ladderGenerator.generateLadder(ladderHeight, playerNames.size());
+        this.playerNames = playerNames;
+        this.prizeNames = prizeNames;
+        this.ladderConnections = ladder.getConnections();
+    }
+
+    public LadderGameStatus getGameStatus() {
+        return new LadderGameStatus(ladder, playerNames, prizeNames);
+    }
+
+    public String getPlayerPrize(PlayerName playerName) {
+        int playerIndex = playerNames.getNames().indexOf(playerName.getName());
+
+        if (playerIndex == -1) {
+            return null;
+        }
+
+        return prizeNames.get(ladderConnections.get(playerIndex));
+    }
+
+    public List<LadderGamePlayerResult> getAllPlayersResult() {
+        return playerNames
+                .getNames()
+                .stream()
+                .map(playerName -> {
+                    String prizeName = getPlayerPrize(new PlayerName(playerName));
+                    return new LadderGamePlayerResult(new PlayerName(playerName), new PrizeName(prizeName));
+                })
+                .collect(Collectors.toList());
+    }
+}

src/main/java/model/LadderGamePlayerResult.java

@@ -0,0 +1,19 @@
+package model;
+
+public class LadderGamePlayerResult {
+    private final PlayerName playerName;
+    private final PrizeName prizeName;
+
+    public LadderGamePlayerResult(PlayerName playerName, PrizeName prizeName) {
+        this.playerName = playerName;
+        this.prizeName = prizeName;
+    }
+
+    public String getPlayerName() {
+        return this.playerName.getName();
+    }
+
+    public String getPrizeName() {
+        return this.prizeName.getName();
+    }
+}

src/main/java/model/LadderGameStatus.java

@@ -0,0 +1,27 @@
+package model;
+
+import java.util.List;
+
+public class LadderGameStatus {
+    private final Ladder ladder;
+    private final PlayerNames playerNames;
+    private final PrizeNames prizeNames;
+
+    public LadderGameStatus(Ladder ladder, PlayerNames playerNames, PrizeNames prizeNames) {
+        this.ladder = ladder;
+        this.playerNames = playerNames;
+        this.prizeNames = prizeNames;
+    }
+
+    public List<LadderRow> getLadder() {
+        return ladder.getLadder();
+    }
+
+    public List<String> getPlayerNames() {
+        return playerNames.getNames();
+    }
+
+    public List<String> getPrizeNames() {
+        return prizeNames.getNames();
+    }
+}

src/main/java/model/LadderGenerator.java

@@ -0,0 +1,37 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LadderGenerator {
+    private final BooleanValueGenerator booleanValueGenerator;
+
+    public LadderGenerator(BooleanValueGenerator booleanValueGenerator) {
+        this.booleanValueGenerator = booleanValueGenerator;
+    }
+
+    public Ladder generateLadder(int rowCount, int columnCount) {
+        List<LadderRow> ladder = IntStream.range(0, rowCount)
+                .mapToObj((index) -> generateRow(columnCount - 1))
+                .collect(Collectors.toList());
+
+        return new Ladder(ladder);
+    }
+
+    private LadderRow generateRow(int ladderRowSize) {
+        List<Boolean> ladderRow = new ArrayList<>();
+
+        while (ladderRow.size() < ladderRowSize) {
+            if (ladderRow.size() == 0 || !ladderRow.get(ladderRow.size() - 1)) {
+                ladderRow.add(booleanValueGenerator.generate());
+                continue;
+            }
+
+            ladderRow.add(false);
+        }
+
+        return new LadderRow(ladderRow);
+    }
+}

src/main/java/model/LadderRow.java

@@ -0,0 +1,38 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LadderRow {
+    private final List<Boolean> ladderRow;
+
+    public LadderRow(List<Boolean> ladderRow) {
+        validateLadderLine(ladderRow);
+        this.ladderRow = new ArrayList<>(ladderRow);
+    }
+
+    private void validateLadderLine(List<Boolean> ladderRow) {
+        if (ladderRow.isEmpty()) {
+            throw new IllegalArgumentException("사다리를 이루는 행은 비어서는 안 됩니다.");
+        }
+
+        for (int i = 0; i < ladderRow.size() - 1; i++) {
+            if (ladderRow.get(i) && ladderRow.get(i + 1)) {
+                throw new IllegalArgumentException("사다리를 이루는 행의 연결선은 겹칠 수 없습니다.");
+            }
+        }
+    }
+
+    public List<Boolean> getRow() {
+        return Collections.unmodifiableList(ladderRow);
+    }
+
+    public boolean get(int index) {
+        return ladderRow.get(index);
+    }
+
+    public int size() {
+        return ladderRow.size();
+    }
+}

src/main/java/model/PlayerName.java

@@ -0,0 +1,27 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PlayerName {
+    private final String playerName;
+
+    private static final int MIN_PLAYER_NAME_LENGTH = 1;
+    private static final int MAX_PLAYER_NAME_LENGTH = 5;
+
+    public PlayerName(String playerName) {
+        validatePlayerName(playerName);
+        this.playerName = playerName;
+    }
+
+    private void validatePlayerName(String playerName) {
+        if (playerName.length() < MIN_PLAYER_NAME_LENGTH || playerName.length() > MAX_PLAYER_NAME_LENGTH) {
+            throw new IllegalArgumentException("참가자의 이름은 " + MIN_PLAYER_NAME_LENGTH + "글자 이상 " +
+                    MAX_PLAYER_NAME_LENGTH + "이하여야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return playerName;
+    }
+}