[BE] 나아연 👆업다운

docs/README.md

@@ -0,0 +1,27 @@
+## 기능 요구 사항
+
+**버전**
+
+- [ ] 숫자 버전은 1번이다.
+- [ ] 영어 버전은 2번이다.
+
+**난수**
+
+- [x] 숫자 버전은 1 ~ 100 사이의 정답을 가진다.
+- [ ] 영어 버전은 A ~ z 사이의 정답을 가진다.
+
+**정답**
+
+- [x] 추측값과 정답을 비교한다.
+- [x] 게임 상태를 반환한다.
+
+**게임 상태**
+
+- [x] 추측값이 정답보다 작은 경우 UP 상태이다.
+- [x] 추측값이 정답보다 큰 경우 DOWN 상태이다.
+- [x] 추측값이 정답과 일치하는 경우 CORRECT 상태이다.
+
+**시도 횟수**
+
+- [ ] 사용자가 정답을 맞출 때까지 시도한 횟수를 출력한다
+    - 잘못된 값 입력 역시 시도한 횟수에 포함 되어야 한다.

src/main/java/leets/land/UpdownApplication.java

@@ -1,8 +1,11 @@
 package leets.land;
 
+import leets.land.controller.GameLoader;
+
 public class UpdownApplication {
 
-	public static void main(String[] args) {
-		System.out.print("hihi :D");
-	}
+    public static void main(String[] args) {
+        GameLoader gameLoader = new GameLoader();
+        gameLoader.load();
+    }
 }

src/main/java/leets/land/controller/AlphabetGameMachine.java

@@ -0,0 +1,41 @@
+package leets.land.controller;
+
+import leets.land.domain.guess.GuessAlphabet;
+import leets.land.domain.guess.GuessRange;
+import leets.land.domain.status.GuessStatus;
+import leets.land.domain.updowngame.AlphabetUpDownGame;
+import leets.land.domain.updowngame.UpDownGame;
+import leets.land.view.InputView;
+import leets.land.view.OutputView;
+
+public class AlphabetGameMachine implements GameMachine {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    @Override
+    public void run() {
+        UpDownGame upDownGame = new AlphabetUpDownGame();
+        play(upDownGame);
+    }
+
+    private void play(UpDownGame upDownGame) {
+        GuessAlphabet guessAlphabet = readGuessAlphabetInRange(upDownGame.guessRange());
+        GuessStatus guessStatus = upDownGame.play(guessAlphabet);
+        outputView.printGuessStatus(guessStatus);
+        if (guessStatus.isContinue()) {
+            play(upDownGame);
+        }
+    }
+
+    private GuessAlphabet readGuessAlphabetInRange(GuessRange guessRange) {
+        try {
+            int guessValue = inputView.readGuessAlphabetInRange(guessRange.min(), guessRange.max());
+            guessRange.checkRange(guessValue);
+            return new GuessAlphabet(guessValue);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readGuessAlphabetInRange(guessRange);
+        }
+    }
+}

src/main/java/leets/land/controller/GameLoader.java

@@ -0,0 +1,19 @@
+package leets.land.controller;
+
+import leets.land.domain.GameVersion;
+import leets.land.view.InputView;
+
+public class GameLoader {
+
+    private final InputView inputView = new InputView();
+
+    public void load() {
+        GameVersion gameVersion = readGameVersion();
+        gameVersion.start();
+    }
+
+    private GameVersion readGameVersion() {
+        int gameVersion = inputView.readGameVersion();
+        return GameVersion.match(gameVersion);
+    }
+}

src/main/java/leets/land/controller/GameMachine.java

@@ -0,0 +1,6 @@
+package leets.land.controller;
+
+public interface GameMachine {
+
+    void run();
+}

src/main/java/leets/land/controller/NumberGameMachine.java

@@ -0,0 +1,41 @@
+package leets.land.controller;
+
+import leets.land.domain.guess.GuessNumber;
+import leets.land.domain.guess.GuessRange;
+import leets.land.domain.status.GuessStatus;
+import leets.land.domain.updowngame.NumberUpDownGame;
+import leets.land.domain.updowngame.UpDownGame;
+import leets.land.view.InputView;
+import leets.land.view.OutputView;
+
+public class NumberGameMachine implements GameMachine {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    @Override
+    public void run() {
+        UpDownGame upDownGame = new NumberUpDownGame();
+        play(upDownGame);
+    }
+
+    private void play(UpDownGame upDownGame) {
+        GuessNumber guessNumber = readGuessNumberInRange(upDownGame.guessRange());
+        GuessStatus guessStatus = upDownGame.play(guessNumber);
+        outputView.printGuessStatus(guessStatus);
+        if (guessStatus.isContinue()) {
+            play(upDownGame);
+        }
+    }
+
+    private GuessNumber readGuessNumberInRange(GuessRange guessRange) {
+        try {
+            int guessNumber = inputView.readGuessNumberInRange(guessRange.min(), guessRange.max());
+            guessRange.checkRange(guessNumber);
+            return new GuessNumber(guessNumber);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readGuessNumberInRange(guessRange);
+        }
+    }
+}

src/main/java/leets/land/domain/AnswerNumber.java

@@ -0,0 +1,18 @@
+package leets.land.domain;
+
+import leets.land.domain.guess.GuessValue;
+import leets.land.domain.status.GuessStatus;
+
+public class AnswerNumber {
+
+    private final int value;
+
+    public AnswerNumber(int value) {
+        this.value = value;
+    }
+
+    public GuessStatus compare(GuessValue guessValue) {
+        int compared = guessValue.compare(value);
+        return GuessStatus.match(compared);
+    }
+}

src/main/java/leets/land/domain/GameVersion.java

@@ -0,0 +1,32 @@
+package leets.land.domain;
+
+import leets.land.controller.AlphabetGameMachine;
+import leets.land.controller.GameMachine;
+import leets.land.controller.NumberGameMachine;
+
+import java.util.Arrays;
+
+public enum GameVersion {
+
+    NUMBER(1, new NumberGameMachine()),
+    ALPHABET(2, new AlphabetGameMachine());
+
+    private final int version;
+    private final GameMachine gameMachine;
+
+    GameVersion(int version, GameMachine gameMachine) {
+        this.version = version;
+        this.gameMachine = gameMachine;
+    }
+
+    public static GameVersion match(int version) {
+        return Arrays.stream(values())
+                .filter(gameVersion -> gameVersion.version == version)
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 존재하지 않는 버전입니다."));
+    }
+
+    public void start() {
+        gameMachine.run();
+    }
+}

src/main/java/leets/land/domain/guess/GuessAlphabet.java

@@ -0,0 +1,44 @@
+package leets.land.domain.guess;
+
+import java.util.Objects;
+
+public class GuessAlphabet implements GuessValue {
+
+    private static final int MIN_RANGE = 'A';
+    private static final int MAX_RANGE = 'z';
+    private static final String ERROR_FORMAT = "[ERROR] %s";
+
+    private final int value;
+
+    public GuessAlphabet(int value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(int value) {
+        if (value < MIN_RANGE || value > MAX_RANGE) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, "추측값의 범위는 A 이상 z 이하입니다"));
+        }
+    }
+
+    public int compare(int other) {
+        return other - value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GuessAlphabet that = (GuessAlphabet) o;
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/leets/land/domain/guess/GuessNumber.java

@@ -0,0 +1,44 @@
+package leets.land.domain.guess;
+
+import java.util.Objects;
+
+public class GuessNumber implements GuessValue {
+
+    private static final int MIN_RANGE = 1;
+    private static final int MAX_RANGE = 100;
+    private static final String ERROR_FORMAT = "[ERROR] %s";
+
+    private final int value;
+
+    public GuessNumber(int value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(int value) {
+        if (value < MIN_RANGE || value > MAX_RANGE) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, "추측값의 범위는 1 이상 100 이하입니다"));
+        }
+    }
+
+    public int compare(int other) {
+        return other - value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GuessNumber that = (GuessNumber) o;
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/leets/land/domain/guess/GuessRange.java

@@ -0,0 +1,51 @@
+package leets.land.domain.guess;
+
+import java.util.Objects;
+
+public class GuessRange {
+
+    private static final String ERROR_FORMAT = "[ERROR] %s";
+
+    private final GuessValue min;
+    private final GuessValue max;
+
+    public GuessRange(GuessValue min, GuessValue max) {
+        this.min = min;
+        this.max = max;
+    }
+
+    public GuessRange downMax(GuessValue max) {
+        return new GuessRange(min, max);
+    }
+
+    public GuessRange upMin(GuessValue min) {
+        return new GuessRange(min, max);
+    }
+
+    public void checkRange(int guessValue) {
+        if (guessValue < min() || guessValue > max()) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, "범위를 벗어납니다."));
+        }
+    }
+
+    public int min() {
+        return min.value();
+    }
+
+    public int max() {
+        return max.value();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GuessRange that = (GuessRange) o;
+        return Objects.equals(min, that.min) && Objects.equals(max, that.max);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(min, max);
+    }
+}

src/main/java/leets/land/domain/guess/GuessValue.java

@@ -0,0 +1,8 @@
+package leets.land.domain.guess;
+
+public interface GuessValue {
+
+    int compare(int other);
+
+    int value();
+}

src/main/java/leets/land/domain/status/Correct.java

@@ -0,0 +1,23 @@
+package leets.land.domain.status;
+
+import leets.land.domain.guess.GuessRange;
+import leets.land.domain.guess.GuessValue;
+
+public class Correct implements Status {
+
+    @Override
+    public GuessRange narrowRange(GuessRange guessRange, GuessValue guessValue) {
+        GuessRange downMaxed = guessRange.downMax(guessValue);
+        return downMaxed.upMin(guessValue);
+    }
+
+    @Override
+    public boolean isValid(int gap) {
+        return gap == 0;
+    }
+
+    @Override
+    public boolean isContinue() {
+        return false;
+    }
+}