[jhlee] 숫자 야구게임 - mission2. 숫자 야구게임 구현

build.gradle

@@ -12,6 +12,7 @@ repositories {
 dependencies {
     testImplementation "org.junit.jupiter:junit-jupiter:5.7.2"
     testImplementation "org.assertj:assertj-core:3.19.0"
+    testImplementation "org.mockito:mockito-junit-jupiter:5.2.0"
 }
 
 test {

src/main/java/Main.java

@@ -0,0 +1,15 @@
+import app.BaseballApplication;
+import base.Application;
+import io.OutputHandler;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Application baseballApplication = new BaseballApplication();
+        try {
+            baseballApplication.startGame();
+        } catch (Exception e) {
+            OutputHandler.printDefaultExceptionMessage(e);
+        }
+    }
+}

src/main/java/app/BaseballApplication.java

@@ -0,0 +1,113 @@
+package app;
+
+import base.Application;
+import domain.Computer;
+import domain.Judgment;
+import domain.Score;
+import domain.User;
+import io.InputHandler;
+import io.OutputHandler;
+import java.util.ArrayList;
+import core.AppException;
+import util.RandomGenerator;
+
+import static core.SystemConstant.*;
+
+
+public class BaseballApplication implements Application {
+
+    private final Computer computer = new Computer(new RandomGenerator());
+    private final InputHandler inputHandler = new InputHandler();
+    private final OutputHandler outputHandler = new OutputHandler();
+
+
+    public void startGame() {
+        boolean isGameRunning = true;
+
+        while (isGameRunning) {
+            Judgment judgment = readyToGame();
+            outputHandler.gameStartCommentPrint();
+            run(judgment);
+
+            isGameRunning = pauseForUserGameRunOptionSelect();
+        }
+    }
+
+    private String userSelectGameRestartOrStop() {
+        outputHandler.gameEndCommentPrint();
+        return inputHandler.getUserInput();
+    }
+
+    private boolean isGameRestart(String gameFlag) {
+        return GAME_RESTART_FLAG.equals(gameFlag);
+    }
+
+    private boolean isGameStop(String gameFlag) {
+        return GAME_STOP_FLAG.equals(gameFlag);
+    }
+
+    private void run(Judgment judgment) {
+        try {
+            actionToGameStartByJudgement(judgment);
+
+        } catch (AppException e) {
+            outputHandler.printAppExceptionMessage(e);
+
+            run(judgment);
+        }
+    }
+
+    private boolean pauseForUserGameRunOptionSelect() {
+        try {
+            String gameFlag = userSelectGameRestartOrStop();
+
+            return isGameContinue(gameFlag);
+
+        } catch (AppException e) {
+            outputHandler.printAppExceptionMessage(e);
+            return pauseForUserGameRunOptionSelect();
+        }
+    }
+
+    private boolean isGameContinue(String gameFlag) {
+        if (isGameRestart(gameFlag)) {
+            return true;
+        }
+
+        if (isGameStop(gameFlag)) {
+            return false;
+        }
+
+        throw new AppException("게임 시작 명령어를 잘못 입력 하였습니다.");
+    }
+
+    private void actionToGameStartByJudgement(Judgment judgment) {
+        String userInputValue = userInput();
+        User user = new User(userInputValue);
+        ArrayList<String> getUserInputArrayStringNumbers = user.getUserInputNumbers();
+
+        Score score = judgment.judge(getUserInputArrayStringNumbers);
+
+        String scoreResultMessage = score.getScoreRecordResult();
+        outputHandler.printMessage(scoreResultMessage);
+
+        boolean isGameSet = score.isStrikeCountEqualToWinningStrikeCount();
+
+        if (stillGameRunning(isGameSet)) {
+            actionToGameStartByJudgement(judgment);
+        }
+    }
+
+    private boolean stillGameRunning(boolean isGameSet) {
+        return !isGameSet;
+    }
+
+    private String userInput() {
+        outputHandler.questionToUserAboutInputNumber();
+        return inputHandler.getUserInput();
+    }
+
+    private Judgment readyToGame() {
+        return new Judgment(computer.readyToGameStart());
+    }
+}

src/main/java/base/Application.java

@@ -0,0 +1,6 @@
+package base;
+
+public interface Application {
+
+    void startGame();
+}

src/main/java/core/AppException.java

@@ -0,0 +1,8 @@
+package core;
+
+public class AppException extends RuntimeException {
+
+    public AppException(String message) {
+        super(message);
+    }
+}

src/main/java/core/SystemConstant.java

@@ -0,0 +1,9 @@
+package core;
+
+public class SystemConstant {
+    public static final int INPUT_LIMIT_LENGTH = 3;
+    public static final int WINNING_STRIKE_COUNT = 3;
+    public static final String GAME_STOP_FLAG = "2";
+    public static final String GAME_RESTART_FLAG = "1";
+
+}

src/main/java/domain/Computer.java

@@ -0,0 +1,41 @@
+package domain;
+
+import static core.SystemConstant.*;
+import java.util.ArrayList;
+import util.RandomGenerator;
+
+public class Computer {
+
+    public static final int BOUND = 9;
+    private final RandomGenerator randomGenerator;
+    private final ArrayList<String> randomNumbers = new ArrayList<>();
+
+    public Computer(RandomGenerator randomGenerator) {
+        this.randomGenerator = randomGenerator;
+    }
+
+    public ArrayList<String> readyToGameStart() {
+
+        if (isGenerateRandomNumberSizeEqualToLimit()) {
+            return randomNumbers;
+        }
+        String number = randomGenerator.getRandomNumberToString(BOUND);
+
+        if (doesNotDuplicate(number)) {
+            append(number);
+        }
+        return readyToGameStart();
+    }
+
+    private void append(String number) {
+        randomNumbers.add(number);
+    }
+
+    private boolean isGenerateRandomNumberSizeEqualToLimit() {
+        return randomNumbers.size() == INPUT_LIMIT_LENGTH;
+    }
+
+    private boolean doesNotDuplicate(String compareInteger) {
+        return !randomNumbers.contains(compareInteger);
+    }
+}

src/main/java/domain/Judgment.java

@@ -0,0 +1,46 @@
+package domain;
+
+import java.util.ArrayList;
+
+public class Judgment {
+
+    private final Score score = new Score();
+    private final ArrayList<String> computerRandomNumbers;
+
+
+    public Judgment(ArrayList<String> computerRandomNumbers) {
+        this.computerRandomNumbers = computerRandomNumbers;
+    }
+
+    public Score judge(ArrayList<String> userInputNumbers) {
+        newScore();
+
+        for (int seq = 0; seq < userInputNumbers.size(); seq++) {
+            scoreRecord(userInputNumbers, seq);
+        }
+        return score;
+    }
+
+    private void newScore() {
+        score.clean();
+    }
+
+    private void scoreRecord(ArrayList<String> userInputNumbers, int arrayInPosition) {
+        if (isStrike(userInputNumbers, arrayInPosition)) {
+            score.strikeIncrement();
+            return;
+        }
+
+        if (isBall(userInputNumbers, arrayInPosition)) {
+            score.ballIncrement();
+        }
+    }
+
+    private boolean isBall(ArrayList<String> userInputNumbers, int arrayInPosition) {
+        return computerRandomNumbers.contains(userInputNumbers.get(arrayInPosition));
+    }
+
+    private boolean isStrike(ArrayList<String> userInputNumbers, int arrayInPosition) {
+        return computerRandomNumbers.get(arrayInPosition).equals(userInputNumbers.get(arrayInPosition));
+    }
+}

src/main/java/domain/Score.java

@@ -0,0 +1,68 @@
+package domain;
+
+import static core.SystemConstant.*;
+
+import core.AppException;
+
+public class Score {
+
+    private int strikeCount;
+    private int ballCount;
+
+    private static final String BALL_MESSAGE = "볼";
+    private static final String STRIKE_MESSAGE = "스트라이크";
+    private static final String UN_HANDLE_MESSAGE = "낫싱";
+
+    void clean() {
+        this.strikeCount = 0;
+        this.ballCount = 0;
+    }
+
+    public void strikeIncrement() {
+        if (strikeCount + 1 > WINNING_STRIKE_COUNT) {
+            throw new AppException("스트라이크 카운트는 최대 " + WINNING_STRIKE_COUNT + "까지 증가할 수 있습니다.");
+        }
+        this.strikeCount += 1;
+    }
+
+    public void ballIncrement() {
+        if (ballCount + 1 > WINNING_STRIKE_COUNT) {
+            throw new AppException("볼 카운트는 최대 " + WINNING_STRIKE_COUNT + "까지 증가할 수 있습니다.");
+        }
+
+        this.ballCount += 1;
+    }
+
+    public String getScoreRecordResult() {
+        if (isBallAndStrike()) {
+            return ballCount + BALL_MESSAGE +  " " + strikeCount + STRIKE_MESSAGE;
+        }
+
+        if (isOnlyBall()) {
+            return ballCount + BALL_MESSAGE;
+        }
+
+        if (isOnlyStrike()) {
+            return strikeCount + STRIKE_MESSAGE;
+        }
+
+        return UN_HANDLE_MESSAGE;
+    }
+
+    private boolean isOnlyStrike() {
+        return strikeCount > 0;
+    }
+
+    private boolean isOnlyBall() {
+        return ballCount > 0;
+    }
+
+    private boolean isBallAndStrike() {
+        return ballCount > 0 && strikeCount > 0;
+    }
+
+    public boolean isStrikeCountEqualToWinningStrikeCount() {
+        return strikeCount == WINNING_STRIKE_COUNT;
+    }
+
+}

src/main/java/domain/User.java

@@ -0,0 +1,56 @@
+package domain;
+
+
+import static core.SystemConstant.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import core.AppException;
+
+public class User {
+
+    private final static int NUMBER_LIMIT_LENGTH = INPUT_LIMIT_LENGTH;
+    private final ArrayList<String> userInputNumbers;
+
+    public User(String userInputNumber) {
+        if (invalidLengthUserInputNumber(userInputNumber)) {
+            throw new AppException("입력한 숫자의 길이가 올바르지 않습니다.");
+        }
+
+        if (doesNotNumeric(userInputNumber)) {
+            throw new AppException("지정 되지 않은 타입의 입력입니다.");
+        }
+
+        this.userInputNumbers = convertStringToArrayList(userInputNumber);
+
+        if (hasZeroNumber()) {
+            throw new AppException("0은 입력 할 수 없습니다.");
+        }
+
+    }
+
+    public ArrayList<String> getUserInputNumbers() {
+        return userInputNumbers;
+    }
+
+    private static ArrayList<String> convertStringToArrayList(String userInput) {
+        return new ArrayList<>(Arrays.asList(userInput.split("")));
+    }
+
+    private boolean hasZeroNumber() {
+        return this.userInputNumbers.contains("0");
+    }
+
+    private boolean doesNotNumeric(String userInput) {
+        try {
+            Integer.valueOf(userInput);
+            return false;
+        } catch (Exception e) {
+            return true;
+        }
+    }
+
+    private boolean invalidLengthUserInputNumber(String userInput) {
+        return !(userInput.length() == NUMBER_LIMIT_LENGTH);
+    }
+}

src/main/java/io/InputHandler.java

@@ -0,0 +1,12 @@
+package io;
+
+import java.util.Scanner;
+
+public class InputHandler {
+
+    private static final Scanner SCANNER = new Scanner(System.in);
+
+    public String getUserInput() {
+        return SCANNER.nextLine();
+    }
+}