[다리 건너기] 김연진 미션 제출합니다.

docs/README.md

@@ -0,0 +1,58 @@
+## 다리 건너기 기능 구현 목록
+
+**입력 & 출력**
+- [x] 게임 시작 안내 출력
+- [x] 다리 길이 입력 (3 ~ 20사이 숫자)
+- [x] 이동할 칸 입력 (U / D)
+- [x] 재시도 입력 (R / Q)
+
+**다리 생성**
+- 입력한 다리 길이만큼 다리 생성
+  - [x] 0(아래), 1(위)형식으로 다리 요소 랜덤 생성
+  - [x] 0➝D / 1➝U 변환
+
+**게임 진행**
+- [x] 생성된 다리와 사용자의 입력 비교
+  - [x] 이동 가능한 경우 계속 진행
+  - [x] 이동 불가능한 경우 재시작 / 종료
+- [x] 재시작하는 경우 시도 횟수 증가
+현
+**게임 진행 내용 저장**
+- [x] 사용자의 입력이 맞는지 저장한다
+  - 맞을 경우 O, 틀릴 경우 X 저장
+
+**결과 출력**
+- 다리 출력
+  - [x] `[`로 시작, `]`로 끝, 구분자는 `|`
+  - [x] 이동 가능한 경우 O / 불가능한 경우 X 출력
+- [x] 게임 성공 여부
+- [x] 총 시도 횟수
+
+**예외 처리**
+- 이동할 칸 입력
+  - [x] U/D 이외의 입력이 들어올 경우
+- 재시도 입력
+  - [x] R/Q 이외의 입력이 들어올 경우
+- 다리 길이 입력
+  - [x] 숫자가 아닌 입력이 들어온 경우
+  - [x] 범위 이외의 숫자가 들어온 경우
+
+### 테스트 목록
+
+**BridgeMaker**
+- [x] 다리 길이 입력시 길이에 맞는 다리를 생성하는가
+
+**InputValidator**
+- [x] 움직임 입력 시 U/D 이외의 문자를 입력하면 예외가 발생하는가
+- [x] 재시작 입력 시 R/Q 이외의 문자를 입력하면 예외가 발생하는가
+- [x] 다리 길이를 입력할 경우 문자를 입력하면 예외가 발생하는가
+- [x] 다리 길이를 입력할 경우 3~20 이외의 숫자를 입력하면 예외가 발생하는가
+
+**LocationConverter**
+- [x] 0 = D, 1 = U로 변환을 하는가
+
+**BridgeGame**
+- [x] 게임 진행 시 사용자가 입력한 내용과 다리의 내용이 일치하는지 확인
+- [x] 정답 계산 이후 사용자 위치 움직였는지 확인
+- [x] 게임 재시작 시 재시작 카운트 증가
+- [x] 게임 재시작 시 사용자 위치, 다리 건넌 기록 초기화

src/main/java/bridge/Application.java

@@ -1,8 +1,13 @@
 package bridge;
 
+import bridge.controller.BridgeController;
+import bridge.view.InputView;
+import bridge.view.OutputView;
+
 public class Application {
 
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        BridgeController bridgeController = new BridgeController(new OutputView(), new InputView());
+        bridgeController.start();
     }
 }

src/main/java/bridge/BridgeMaker.java

@@ -1,5 +1,8 @@
 package bridge;
 
+import bridge.model.BridgeConverter;
+
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -18,6 +21,10 @@ public BridgeMaker(BridgeNumberGenerator bridgeNumberGenerator) {
      * @return 입력받은 길이에 해당하는 다리 모양. 위 칸이면 "U", 아래 칸이면 "D"로 표현해야 한다.
      */
     public List<String> makeBridge(int size) {
-        return null;
+        List<String> bridge = new ArrayList<>();
+        while (bridge.size() != size) {
+            bridge.add(BridgeConverter.convert(bridgeNumberGenerator.generate()));
+        }
+        return bridge;
     }
 }

src/main/java/bridge/controller/BridgeController.java

@@ -0,0 +1,65 @@
+package bridge.controller;
+
+import bridge.BridgeMaker;
+import bridge.BridgeRandomNumberGenerator;
+import bridge.model.AnswerTable;
+import bridge.model.Bridge;
+import bridge.model.Constant;
+import bridge.model.GameStatus;
+import bridge.service.BridgeGame;
+import bridge.view.InputView;
+import bridge.view.OutputView;
+
+public class BridgeController {
+
+    private final OutputView outputView;
+    private final InputView inputView;
+    private final AnswerTable answerTable = new AnswerTable();
+    private final GameStatus gameStatus = new GameStatus();
+
+    public BridgeController(OutputView outputView, InputView inputView) {
+        this.outputView = outputView;
+        this.inputView = inputView;
+    }
+
+    public void start() {
+        try {
+            Bridge bridge = makeBridge();
+            progressGame(bridge);
+            printResult();
+        } catch (IllegalArgumentException exception) {
+            outputView.printExceptionMessage(exception.getMessage());
+        }
+    }
+
+    private Bridge makeBridge() {
+        outputView.printGameStart();
+        BridgeMaker bridgeMaker = new BridgeMaker(new BridgeRandomNumberGenerator());
+        return new Bridge(bridgeMaker.makeBridge(inputView.readBridgeSize()));
+    }
+
+    private void progressGame(Bridge bridge) {
+        BridgeGame bridgeGame = new BridgeGame(bridge, gameStatus, answerTable);
+        while (gameStatus.getPosition() < bridge.size()) {
+            boolean isCorrect = bridgeGame.move(inputView.readMoving());
+            outputView.printMap(answerTable);
+            if(!isCorrect && !retry(bridgeGame)) {
+                gameStatus.setGameResultFailed();
+                break;
+            }
+        }
+    }
+
+    private boolean retry(BridgeGame bridgeGame) {
+        String userInput = inputView.readGameCommand();
+        if (userInput.equals(Constant.RETRY.toString())) {
+            bridgeGame.retry();
+            return true;
+        }
+        return false;
+    }
+
+    private void printResult() {
+        outputView.printResult(answerTable, gameStatus);
+    }
+}

src/main/java/bridge/model/AnswerTable.java

@@ -0,0 +1,59 @@
+package bridge.model;
+
+import bridge.view.ExceptionMessage;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class AnswerTable {
+
+    private final List<String> upper;
+    private final List<String> lower;
+
+    public AnswerTable() {
+        this.upper = new ArrayList<>();
+        this.lower = new ArrayList<>();
+    }
+
+    public void setAnswerTable(String userInput, boolean success) {
+        setUpperCase(userInput, success);
+        setLowerCase(userInput, success);
+    }
+
+    private void setUpperCase(String userInput, boolean success) {
+        if(userInput.equals(Constant.UPPER_CHAR.toString())) {
+            MovingResult correctMessage = calculateMovingResult(success);
+            upper.add(correctMessage.getAnswer());
+            lower.add(Constant.BLANK.toString());
+        }
+    }
+
+    private void setLowerCase(String userInput, boolean success) {
+        if(userInput.equals(Constant.LOWER_CHAR.toString())) {
+            MovingResult correctMessage = calculateMovingResult(success);
+            lower.add(correctMessage.getAnswer());
+            upper.add(Constant.BLANK.toString());
+        }
+    }
+
+    private MovingResult calculateMovingResult(boolean success) {
+        return Arrays.stream(MovingResult.values())
+                .filter(movingResult -> movingResult.getSuccess() == success)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException(ExceptionMessage.MOVING_RESULT_NONE.toString()));
+    }
+
+    public List<String> getUpper() {
+        return upper;
+    }
+
+    public List<String> getLower() {
+        return lower;
+    }
+
+    public void clear() {
+        upper.clear();
+        lower.clear();
+    }
+}

src/main/java/bridge/model/Bridge.java

@@ -0,0 +1,20 @@
+package bridge.model;
+
+import java.util.List;
+
+public class Bridge {
+
+    private final List<String> bridge;
+
+    public Bridge(List<String> bridge) {
+        this.bridge = bridge;
+    }
+
+    public String getBridgeByPosition(int position) {
+        return bridge.get(position);
+    }
+
+    public int size() {
+        return bridge.size();
+    }
+}

src/main/java/bridge/model/BridgeComparison.java

@@ -0,0 +1,15 @@
+package bridge.model;
+
+public class BridgeComparison {
+
+    private final Bridge bridge;
+
+    public BridgeComparison(Bridge bridge) {
+        this.bridge = bridge;
+    }
+
+    public boolean checkMoving(String moving, int position) {
+        String correctMoving = bridge.getBridgeByPosition(position);
+        return correctMoving.equals(moving);
+    }
+}

src/main/java/bridge/model/BridgeConverter.java

@@ -0,0 +1,13 @@
+package bridge.model;
+
+public class BridgeConverter {
+
+    private static final int LOWER_CASE = 0;
+
+    public static String convert(int position) {
+        if (position == LOWER_CASE) {
+            return Constant.LOWER_CHAR.toString();
+        }
+        return Constant.UPPER_CHAR.toString();
+    }
+}

src/main/java/bridge/model/Constant.java

@@ -0,0 +1,21 @@
+package bridge.model;
+
+public enum Constant {
+
+    UPPER_CHAR("U"),
+    LOWER_CHAR("D"),
+    BLANK(" "),
+    RETRY("R"),
+    QUIT("Q");
+
+    private final String constant;
+
+    Constant(String constant) {
+        this.constant = constant;
+    }
+
+    @Override
+    public String toString() {
+        return this.constant;
+    }
+}