[사다리 미션] 신혜빈 미션 제출합니다.

README.md

@@ -0,0 +1,43 @@
+# java-ladder
+
+# < controller >
+## 1) Controller
+* createPlayers() //참여자 생성기능
+* createResults() //참여결과 생성기능
+* createLadder() //사다리 생성기능
+* createLadderResult() //사다리 결과 생성기능
+* playLadderGame() //사다리 게임 실행기능
+
+---
+# < model >
+## 1) DecideResult
+* moveColumn() // 열부분 움직이는 기능
+* moveRow() //행부분 움직이는 기능
+* decidePlayerResult() //참여자 결과 결정기능
+## 2) Ladder
+## 3) LadderRow
+* LadderRow() //사다리 열부분 생성기능
+* chooseTrueOrFalse() //사다리 point 정하는 기능
+## 4) Player
+* Player() //참여자 생성, 참가자이름이 5글자 초과 시 에러발생 기능
+* getCertainPlayerResult //특정 사용자의 결과를 반환하는 기능
+## 5) Players
+## 6) Results
+## 7) Splitter
+* split() //문자열 자르는 기능
+
+---
+# < view >
+## 1) InputView
+* inputPlayers() //참여할 사람이름 입력기능
+* inputResults() //결과 입력기능
+* inputLadderHeight() //최대 사다리 높이 입력기능
+* inputPlayerToWantResult() //결과를 보고싶은 사람 입력기능
+## 2) OutputView
+* outputPlayer() //참여자 출력기능
+* outputLadderRow() //사다리행 출력기능
+* outputLadder() //사다리 출력기능
+* outputResults() //결과 출력기능
+* outputAllPlayersResult //모든 참여자 결과 출력기능
+* outputCertainPlayerResult //특정 참여자 결과 출력기능
+* outputPlayerResult //참여자 결과 출력기능

src/main/java/Main.java

@@ -0,0 +1,8 @@
+import controller.Controller;
+
+public class Main {
+    public static void main(String[] args) {
+        Controller controller = new Controller();
+        controller.playLadderGame();
+    }
+}

src/main/java/controller/Controller.java

@@ -0,0 +1,80 @@
+package controller;
+
+import model.ladder.Ladder;
+import model.ladder.LadderRow;
+import model.player.Player;
+import model.player.PlayerResults;
+import model.player.Players;
+import model.tool.Splitter;
+import view.InputView;
+import view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+
+public class Controller {
+    InputView inputView = new InputView();
+    Splitter splitter = new Splitter();
+    OutputView outputView = new OutputView();
+
+    private Players createPlayers() {
+        String playerNamesBeforeSplit = inputView.inputPlayers();
+        String[] playerNames = splitter.split(playerNamesBeforeSplit);
+        List<Player> playersInventory = new ArrayList<>();
+        for (int i = 0; i < playerNames.length; i++) {
+            Player player = new Player(i, playerNames[i]);
+            playersInventory.add(player);
+        }
+        Players players = new Players(playersInventory);
+        return players;
+    }
+
+    private List<String> createLadderResults() {
+        String trialResultsBeforeSplit = inputView.inputResults();
+        String[] trialResults = splitter.split(trialResultsBeforeSplit);
+        List<String> ladderResults = Arrays.asList(trialResults);
+        return ladderResults;
+    }
+
+    private Ladder createLadder(int columnSize) {
+        List<String> ladderResults = createLadderResults();
+        int rowSize = inputView.inputLadderHeight();
+        List<LadderRow> ladderRows = new ArrayList<>();
+        for (int i = 0; i < rowSize; i++) {
+            LadderRow ladderRow = new LadderRow(columnSize);
+            ladderRows.add(ladderRow);
+        }
+        Ladder ladder = new Ladder(ladderRows, ladderResults);
+        return ladder;
+    }
+
+    private PlayerResults createPlayerResults(Players players, Ladder ladder) {
+        List<Player> playerInventory = players.getPlayerInventory();
+        Map<String, String> playerResultsInventory = ladder.decidePlayerResults(playerInventory);
+        PlayerResults playerResults = new PlayerResults(playerResultsInventory);
+        return playerResults;
+    }
+
+    private void printLadder(Players players, Ladder ladder) {
+        List<LadderRow> ladderRows = ladder.getLadderRows();
+        List<String> ladderResults = ladder.getLadderResults();
+        List<Player> playerInventory = players.getPlayerInventory();
+        OutputView outputView = new OutputView();
+        outputView.outputLadder(playerInventory, ladderRows, ladderResults);
+    }
+
+    public void playLadderGame() {
+        Players players = createPlayers();
+        Ladder ladder = createLadder(players.getPlayerInventory().size() - 1);
+        PlayerResults playerResults = createPlayerResults(players, ladder);
+        printLadder(players, ladder);
+        String playerName;
+        do {
+            playerName = inputView.inputPlayerToWantResult();
+            outputView.outputPlayerResult(playerResults, playerName);
+        } while (!playerName.equals("all"));
+    }
+}

src/main/java/model/ladder/Ladder.java

@@ -0,0 +1,60 @@
+package model.ladder;
+
+import model.player.Player;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Ladder {
+    private List<LadderRow> ladderRows;
+    private List<String> ladderResults;
+
+    public Ladder(List<LadderRow> ladderRows, List<String> ladderResults) {
+        this.ladderRows = ladderRows;
+        this.ladderResults = ladderResults;
+    }
+
+    private LadderMove changePosition(List<Boolean> points, int columnPosition) {
+        if (columnPosition > 0 && points.get(columnPosition - 1)) {
+            return LadderMove.LEFT;
+        }
+        if (columnPosition < points.size() && points.get(columnPosition)) {
+            return LadderMove.RIGHT;
+        }
+        return LadderMove.DOWN;
+    }
+
+    private int moveColumn(List<Boolean> points, int columnPosition) {
+        LadderMove moveDirection = changePosition(points, columnPosition);
+        return columnPosition + moveDirection.getOffset();
+    }
+
+    private int moveRow(List<LadderRow> ladderRows, int columnPosition) {
+        for (LadderRow ladderRow : ladderRows) {
+            List<Boolean> points = ladderRow.getPoints();
+            columnPosition = moveColumn(points, columnPosition);
+        }
+        return columnPosition;
+    }
+
+    public Map<String, String> decidePlayerResults(List<Player> playerInventory) {
+        Map<String, String> playerResultsInventory = new HashMap<>();
+        for (Player player : playerInventory) {
+            int playerPosition = player.getPosition();
+            int columnPosition = moveRow(ladderRows, playerPosition);
+            String playerName = player.getName();
+            String playerResult = ladderResults.get(columnPosition);
+            playerResultsInventory.put(playerName, playerResult);
+        }
+        return playerResultsInventory;
+    }
+
+    public List<LadderRow> getLadderRows() {
+        return ladderRows;
+    }
+
+    public List<String> getLadderResults() {
+        return ladderResults;
+    }
+}

src/main/java/model/ladder/LadderMove.java

@@ -0,0 +1,17 @@
+package model.ladder;
+
+public enum LadderMove {
+    RIGHT(1),
+    LEFT(-1),
+    DOWN(0);
+
+    private final int offset;
+
+    LadderMove(int offset) {
+        this.offset = offset;
+    }
+
+    public int getOffset() {
+        return offset;
+    }
+}

src/main/java/model/ladder/LadderPoint.java

@@ -0,0 +1,16 @@
+package model.ladder;
+
+public enum LadderPoint {
+    CONNECTED(true),
+    DISCONNECTED(false);
+
+    private final Boolean isConnected;
+
+    LadderPoint(Boolean isConnected) {
+        this.isConnected = isConnected;
+    }
+
+    public Boolean getConnected() {
+        return isConnected;
+    }
+}

src/main/java/model/ladder/LadderRow.java

@@ -0,0 +1,31 @@
+package model.ladder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LadderRow {
+    private List<Boolean> points = new ArrayList<>();
+
+    public LadderRow(int columnSize) {
+        for (int columnPosition = 0; columnPosition < columnSize; columnPosition++) {
+            boolean randomBoolean = chooseLadderPoint(columnPosition);
+            this.points.add(columnPosition, randomBoolean);
+        }
+    }
+
+    private LadderPoint randomTrueOrFalse() {
+        if (Math.random() < 0.5) return LadderPoint.CONNECTED;
+        return LadderPoint.DISCONNECTED;
+    }
+
+    public boolean chooseLadderPoint(int columnPosition) {
+        if (columnPosition > 0 && points.get(columnPosition - 1))
+            return LadderPoint.DISCONNECTED.getConnected();
+        return randomTrueOrFalse().getConnected();
+
+    }
+
+    public List<Boolean> getPoints() {
+        return points;
+    }
+}

src/main/java/model/player/Player.java

@@ -0,0 +1,23 @@
+package model.player;
+
+public class Player {
+    private static final int NAME_LENGTH_LIMIT = 5;
+    private int position;
+    private String name;
+
+    public Player(int position, String name) {
+        if (name.length() > NAME_LENGTH_LIMIT) {
+            throw new IllegalArgumentException("참가자 이름이 " + NAME_LENGTH_LIMIT + "자 초과입니다.");
+        }
+        this.position = position;
+        this.name = name;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/model/player/PlayerResults.java

@@ -0,0 +1,19 @@
+package model.player;
+
+import java.util.Map;
+
+public class PlayerResults {
+    private Map<String, String> PlayerResultsInventory;
+
+    public PlayerResults(Map<String, String> playerResultsInventory) {
+        PlayerResultsInventory = playerResultsInventory;
+    }
+
+    public String getPlayerResult(String playerName) {
+        return PlayerResultsInventory.get(playerName);
+    }
+
+    public Map<String, String> getPlayerResultsInventory() {
+        return PlayerResultsInventory;
+    }
+}

src/main/java/model/player/Players.java

@@ -0,0 +1,15 @@
+package model.player;
+
+import java.util.List;
+
+public class Players {
+    private List<Player> playerInventory;
+
+    public Players(List<Player> playerInventory) {
+        this.playerInventory = playerInventory;
+    }
+
+    public List<Player> getPlayerInventory() {
+        return playerInventory;
+    }
+}

src/main/java/model/tool/Splitter.java

@@ -0,0 +1,13 @@
+package model.tool;
+
+public class Splitter {
+    final static private String SPLIT_SIGN = ",";
+
+    public String[] split(String beforeSplit) {
+        String[] afterSplit = beforeSplit.split(SPLIT_SIGN);
+        for (int i = 0; i < afterSplit.length; i++) {
+            afterSplit[i] = afterSplit[i].trim();
+        }
+        return afterSplit;
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,26 @@
+package view;
+
+import java.util.Scanner;
+
+public class InputView {
+    Scanner scanner = new Scanner(System.in);
+    public String inputPlayers(){
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        return scanner.nextLine();
+    }
+
+    public String inputResults(){
+        System.out.println("\n"+"실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+        return scanner.nextLine();
+    }
+
+    public Integer inputLadderHeight(){
+        System.out.println("\n"+"최대 사다리 높이는 몇 개인가요?");
+        return Integer.parseInt(scanner.nextLine());
+    }
+
+    public String inputPlayerToWantResult(){
+        System.out.println("\n"+"결과를 보고 싶은 사람은?");
+        return scanner.nextLine();
+    }
+}