숫자 야구 게임 [sjiwon]

docs/README.md

@@ -0,0 +1,108 @@
+## Feature
+
+- [X] 컴퓨터는 1..9 범위에서 서로 다른 임의의 수 3개 선택
+- [X] 유저는 1..9 범위에서 서로 다른 숫자 3개를 입력한다
+    - [X] 숫자가 아닌 값을 입력한 경우 `IllegalArgumentException` 발생
+- [X] 심판은 `컴퓨터 <-> 유저의 3가지 숫자`를 토대로 숫자 야구 게임 결과를 도출한다
+    - 비교 후 `strikeCount & ballCount` 정보를 `Result`로 Wrapping한 후 결과를 발송한다
+- [X] 컴퓨터가 선택한 모든 숫자를 맞히면 게임은 클리어된다
+    - [X] 사용자는 재시작[1], 종료[2] 중 하나를 입력한다
+        - [X] 숫자가 아닌 값을 입력한 경우 `IllegalArgumentException` 발생
+
+<br>
+<hr>
+
+## Model
+
+### `Baseballs`
+
+- 입력한 3개의 숫자들을 추상화시킨 `Baseballs`
+    - Baseballs에 속한 `List<Integer>`은
+        - [X] 각 원소가 `1..9` 범위 사이여야 한다
+        - [X] 원소의 크기가 3이여야 한다
+        - [X] 중복된 원소가 없어야 한다
+
+<br>
+
+### `Computer: 컴퓨터`
+
+- 1..9 범위에서 서로 다른 임의의 수 3개 선택
+    - Computer는 중복 숫자를 선택하지 않도록 구현
+- User 선택을 통한 결과 산출의 기준
+
+<br>
+
+### `User: 사용자`
+
+- 숫자 3개 입력
+    - 숫자를 입력하지 않을 경우 (IllegalArgumentException)
+- 게임 재시작/종료와 관련된 커맨드 입력
+    - 숫자를 입력하지 않을 경우 (IllegalArgumentException)
+
+<br>
+
+### `Referee: 심판`
+
+- 플레이어 점수 채점
+    - 숫자 겹침 + 동일 위치 = 스트라이크
+    - 숫자 겹침 + 다른 위치 = 볼
+    - 숫자 안겹침 = 낫싱
+
+<br>
+
+### `Result: 채점 결과`
+
+- 스트라이크 & 볼에 대한 count field 보유
+
+<br>
+
+### `GameStatus: 게임 상태`
+
+- 진행중인 게임에 대한 상태
+    - `GAME_RUN` -> 게임 실행
+    - `GAME_TERMINATE` -> 게임 종료
+
+<br>
+
+### `GameProcessDecider: 재시작 or 종료 결정자`
+
+- 게임 클리어 후 종료 or 재시작에 대한 커맨더
+
+<br>
+<hr>
+
+## Utils
+
+### `ExceptionConstants`
+
+- 전역 예외 메시지 통합 컴포넌트
+
+### `BaseballConstants`
+
+- Baseball에 대한 상수 전용 컴포넌트
+    - 숫자 범위
+    - Baseball 개수
+
+<br>
+<hr>
+
+## View
+
+### `InputView`
+
+- 사용자 Input을 받기 위한 컴포넌트
+
+### `OutputView`
+
+- 게임 진행과 관련된 출력 컴포넌트
+
+<br>
+<hr>
+
+## Controller
+
+### `GameController`
+
+- 게임 진행과 관련된 컨트롤러
+
+<br>

src/main/java/baseball/Application.java

@@ -1,7 +1,9 @@
 package baseball;
 
+import baseball.controller.GameController;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        new GameController().run();
     }
 }

src/main/java/baseball/controller/GameController.java

@@ -0,0 +1,67 @@
+package baseball.controller;
+
+import baseball.model.*;
+import baseball.view.InputView;
+import baseball.view.OutputView;
+
+import java.util.List;
+
+import static baseball.model.GameProcessDecider.GAME_RESTART;
+import static baseball.model.GameStatus.GAME_RUNNING;
+import static baseball.model.GameStatus.GAME_TERMINATE;
+
+public class GameController {
+    private static GameStatus gameStatus;
+    private Computer computer;
+    private User user;
+
+    public GameController() {
+        computer = new Computer();
+        gameStatus = GAME_RUNNING;
+    }
+
+    public void run() {
+        // 게임 시작
+        OutputView.printGameStart();
+
+        while (gameStatus.isGameNotTerminated()) {
+            // User - Baseball 입력
+            readUserBaseballInput();
+
+            // 게임 결과 확인
+            Result result = judgeGameByReferee();
+            OutputView.printGameResult(result);
+
+            // 게임 클리어 확인
+            checkGameClear(result);
+        }
+    }
+
+    private void readUserBaseballInput() {
+        List<Integer> userBaseballs = InputView.readUserBaseballs();
+        user = new User(userBaseballs);
+    }
+
+    private Result judgeGameByReferee() {
+        return Referee.judge(computer.getBaseballs(), user.getBaseballs());
+    }
+
+    private void checkGameClear(final Result result) {
+        if (result.isGameClear()) {
+            OutputView.printGameClear();
+            determineGameRestartOrEnd();
+        }
+    }
+
+    private void determineGameRestartOrEnd() {
+        int userCommand = InputView.readUserRestartCommand();
+        GameProcessDecider decider = GameProcessDecider.getDecider(userCommand);
+
+        if (decider == GAME_RESTART) {
+            computer = new Computer();
+            gameStatus = GAME_RUNNING;
+        } else {
+            gameStatus = GAME_TERMINATE;
+        }
+    }
+}

src/main/java/baseball/model/Baseballs.java

@@ -0,0 +1,51 @@
+package baseball.model;
+
+import java.util.Collections;
+import java.util.List;
+
+import static baseball.utils.BaseballConstants.*;
+import static baseball.utils.ExceptionConstants.BaseballException.*;
+
+public class Baseballs {
+    private final List<Integer> baseballs;
+
+    public Baseballs(final List<Integer> baseballs) {
+        validateEachBaseballElementIsInRange(baseballs);
+        validateTotalBaseballSize(baseballs);
+        validateBaseballHasDuplicateNumber(baseballs);
+        this.baseballs = baseballs;
+    }
+
+    private void validateEachBaseballElementIsInRange(final List<Integer> baseballs) {
+        if (hasOutOfRange(baseballs)) {
+            throw new IllegalArgumentException(BASEBALL_IS_NOT_IN_RANGE.message);
+        }
+    }
+
+    private boolean hasOutOfRange(final List<Integer> baseballs) {
+        return baseballs.stream()
+                .anyMatch(baseball -> baseball < MIN_BASEBALL || baseball > MAX_BASEBALL);
+    }
+
+    private void validateTotalBaseballSize(final List<Integer> baseballs) {
+        if (baseballs.size() != BASEBALL_SIZE) {
+            throw new IllegalArgumentException(BASEBALL_SIZE_IS_NOT_FULFILL.message);
+        }
+    }
+
+    private void validateBaseballHasDuplicateNumber(final List<Integer> baseballs) {
+        if (hasDuplicateNumber(baseballs)) {
+            throw new IllegalArgumentException(BASEBALL_MUST_BE_UNIQUE.message);
+        }
+    }
+
+    private boolean hasDuplicateNumber(final List<Integer> baseballs) {
+        return baseballs.stream()
+                .distinct()
+                .count() != BASEBALL_SIZE;
+    }
+
+    public List<Integer> getBaseballs() {
+        return Collections.unmodifiableList(baseballs);
+    }
+}

src/main/java/baseball/model/Computer.java

@@ -0,0 +1,48 @@
+package baseball.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static baseball.utils.BaseballConstants.*;
+
+public class Computer {
+    private final Baseballs baseballs;
+
+    public Computer() {
+        this.baseballs = generateRandomBaseballs();
+    }
+
+    private Baseballs generateRandomBaseballs() {
+        List<Integer> baseballs = new ArrayList<>();
+
+        while (isNotReachedLimitSize(baseballs)) {
+            int randomNumber = getRandomNumberInRange();
+            if (isRandomNumberAbsentInBaseballs(baseballs, randomNumber)) {
+                baseballs.add(randomNumber);
+            }
+        }
+
+        return new Baseballs(baseballs);
+    }
+
+    private boolean isNotReachedLimitSize(final List<Integer> baseballs) {
+        return baseballs.size() < BASEBALL_SIZE;
+    }
+
+    private int getRandomNumberInRange() {
+        return Randoms.pickNumberInRange(MIN_BASEBALL, MAX_BASEBALL);
+    }
+
+    private boolean isRandomNumberAbsentInBaseballs(
+            final List<Integer> baseballs,
+            final int randomNumber
+    ) {
+        return !baseballs.contains(randomNumber);
+    }
+
+    public List<Integer> getBaseballs() {
+        return baseballs.getBaseballs();
+    }
+}

src/main/java/baseball/model/GameProcessDecider.java

@@ -0,0 +1,24 @@
+package baseball.model;
+
+import java.util.Arrays;
+
+import static baseball.utils.ExceptionConstants.GameProcessCommandException.INVALID_COMMAND;
+
+public enum GameProcessDecider {
+    GAME_RESTART(1),
+    GAME_END(2),
+    ;
+
+    private final int command;
+
+    GameProcessDecider(final int command) {
+        this.command = command;
+    }
+
+    public static GameProcessDecider getDecider(final int userCommand) {
+        return Arrays.stream(values())
+                .filter(restartDecider -> restartDecider.command == userCommand)
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(INVALID_COMMAND.message));
+    }
+}

src/main/java/baseball/model/GameStatus.java

@@ -0,0 +1,11 @@
+package baseball.model;
+
+public enum GameStatus {
+    GAME_RUNNING,
+    GAME_TERMINATE,
+    ;
+
+    public boolean isGameNotTerminated() {
+        return this != GAME_TERMINATE;
+    }
+}

src/main/java/baseball/model/Referee.java

@@ -0,0 +1,55 @@
+package baseball.model;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static baseball.utils.BaseballConstants.BASEBALL_SIZE;
+
+public class Referee {
+    private Referee() {
+    }
+
+    public static Result judge(
+            final List<Integer> computerBaseballs,
+            final List<Integer> userBaseballs
+    ) {
+        final int strikeCount = calculateStrikeCount(computerBaseballs, userBaseballs);
+        final int ballCount = calculateBallCount(computerBaseballs, userBaseballs);
+
+        return new Result(strikeCount, ballCount);
+    }
+
+    private static int calculateStrikeCount(
+            final List<Integer> computerBaseballs,
+            final List<Integer> userBaseballs
+    ) {
+        return (int) IntStream.range(0, BASEBALL_SIZE)
+                .filter(index -> isExactlyMatchAtIndex(computerBaseballs, userBaseballs, index))
+                .count();
+    }
+
+    private static boolean isExactlyMatchAtIndex(
+            final List<Integer> computerBaseballs,
+            final List<Integer> userBaseballs,
+            final int index
+    ) {
+        return computerBaseballs.get(index).equals(userBaseballs.get(index));
+    }
+
+    private static int calculateBallCount(
+            final List<Integer> computerBaseballs,
+            final List<Integer> userBaseballs
+    ) {
+        return getContainedElementsCount(computerBaseballs, userBaseballs)
+                - calculateStrikeCount(computerBaseballs, userBaseballs);
+    }
+
+    private static int getContainedElementsCount(
+            final List<Integer> computerBaseballs,
+            final List<Integer> userBaseballs
+    ) {
+        return (int) userBaseballs.stream()
+                .filter(computerBaseballs::contains)
+                .count();
+    }
+}