[BE] 김예찬👆 업다운

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

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

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

@@ -0,0 +1,47 @@
+package leets.land.controller;
+
+import leets.land.domain.AlphabetUpDown;
+import leets.land.domain.UpDown;
+import leets.land.view.InputView;
+import leets.land.view.OutputView;
+
+public class AlphabetGame implements Game {
+    final InputView inputView = new InputView();
+    final OutputView outputView = new OutputView();
+
+    @Override
+    public void run() {
+        UpDown updown = new AlphabetUpDown();
+        play(updown);
+    }
+
+    @Override
+    public void play(UpDown updown) {
+        char answer = updown.getAnswerAsChar();
+
+        while (true) {
+            char alphabet = inputView.inputAlphabetInRange(updown.getStartAsChar(), updown.getEndAsChar());
+
+            try {
+                updown.validator(alphabet);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+                continue;
+            }
+
+            updown.increaseCount();
+
+            if (alphabet == answer) {
+                System.out.println("Correct!");
+                outputView.printCount(updown.getCount());
+                break;
+            } else if (alphabet < answer) {
+                System.out.println("UP");
+                updown.setStart(alphabet + 1);
+            } else {
+                System.out.println("DOWN");
+                updown.setEnd(alphabet - 1);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package leets.land.controller;
+
+import leets.land.domain.UpDown;
+
+public interface Game {
+    void run();
+    void play(UpDown upDown);
+}

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

@@ -0,0 +1,18 @@
+package leets.land.controller;
+
+import leets.land.domain.Version;
+import leets.land.view.InputView;
+
+public class GameLoader {
+    final InputView inputView = new InputView();
+
+    public void load() {
+        Version version = inputVersion();
+        version.run();
+    }
+
+    private Version inputVersion() {
+        int gameVersion = inputView.inputVersion();
+        return Version.versionValidator(gameVersion);
+    }
+}

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

@@ -0,0 +1,47 @@
+package leets.land.controller;
+
+import leets.land.domain.NumberUpDown;
+import leets.land.domain.UpDown;
+import leets.land.view.InputView;
+import leets.land.view.OutputView;
+
+public class NumberGame implements Game {
+    final InputView inputView = new InputView();
+    final OutputView outputView = new OutputView();
+
+    @Override
+    public void run() {
+        UpDown updown = new NumberUpDown();
+        play(updown);
+    }
+
+    @Override
+    public void play(UpDown updown) {
+        int answer = updown.getAnswerAsInt();
+
+        while (true) {
+            int number = inputView.inputNumberInRange(updown.getStartAsInt(), updown.getEndAsInt());
+
+            try {
+                updown.validator(number);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+                continue;
+            }
+
+            updown.increaseCount();
+
+            if (number == answer) {
+                System.out.println("Correct!");
+                outputView.printCount(updown.getCount());
+                break;
+            } else if (number < answer) {
+                System.out.println("UP");
+                updown.setStart(number + 1);
+            } else {
+                System.out.println("DOWN");
+                updown.setEnd(number - 1);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+package leets.land.domain;
+
+public class AlphabetUpDown implements UpDown {
+    private final char answerAlphabet = Answer.setAlphabet();
+    private char startAlphabet = 'A', endAlphabet = 'z';
+    private int count = 0;
+
+    @Override
+    public int getAnswerAsInt() {
+        return 0;
+    }
+
+    @Override
+    public char getAnswerAsChar() {
+        return answerAlphabet;
+    }
+
+    @Override
+    public int getStartAsInt() {
+        return 0;
+    }
+
+    @Override
+    public char getStartAsChar() {
+        return startAlphabet;
+    }
+
+    @Override
+    public int getEndAsInt() {
+        return 0;
+    }
+
+    @Override
+    public char getEndAsChar() {
+        return endAlphabet;
+    }
+
+    @Override
+    public int getCount() {
+        return count;
+    }
+
+    @Override
+    public void setStart(int start) {
+        if (start - 1 == 'Z') {
+            startAlphabet = 'a';
+        } else {
+            startAlphabet = (char) start;
+        }
+    }
+
+    @Override
+    public void setEnd(int end) {
+        if (end + 1 == 'a') {
+            endAlphabet = 'Z';
+        } else {
+            endAlphabet = (char) end;
+        }
+    }
+
+    @Override
+    public void increaseCount() {
+        count++;
+    }
+
+    @Override
+    public void validator(char alphabet) {
+        if (alphabet < startAlphabet || alphabet > endAlphabet) {
+            throw new IllegalArgumentException("[ERROR] 범위 내의 알파벳을 입력하세요.");
+        }
+    }
+
+    @Override
+    public void validator(int number) {
+
+    }
+}

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

@@ -0,0 +1,17 @@
+package leets.land.domain;
+
+public class Answer {
+    public static int setNumber() {
+        return (int) (Math.random() * 100) + 1;
+    }
+
+    public static char setAlphabet() {
+        char answer = (char) ((int) (Math.random() * ('z'-'A')) + 'A');
+
+        if (answer > 'Z' && answer < 'a') {
+            return setAlphabet();
+        }
+
+        return answer;
+    }
+}

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

@@ -0,0 +1,69 @@
+package leets.land.domain;
+
+public class NumberUpDown implements UpDown {
+    private final int answerNumber = Answer.setNumber();
+    private int startNumber = 1, endNumber = 100;
+    private int count = 0;
+
+    @Override
+    public int getAnswerAsInt() {
+        return answerNumber;
+    }
+
+    @Override
+    public char getAnswerAsChar() {
+        return 0;
+    }
+
+    @Override
+    public int getStartAsInt() {
+        return startNumber;
+    }
+
+    @Override
+    public char getStartAsChar() {
+        return 0;
+    }
+
+    @Override
+    public int getEndAsInt() {
+        return endNumber;
+    }
+
+    @Override
+    public char getEndAsChar() {
+        return 0;
+    }
+
+    @Override
+    public int getCount() {
+        return count;
+    }
+
+    @Override
+    public void setStart(int start) {
+        startNumber = start;
+    }
+
+    @Override
+    public void setEnd(int end) {
+        endNumber = end;
+    }
+
+    @Override
+    public void increaseCount() {
+        count++;
+    }
+
+    @Override
+    public void validator(char alphabet) {
+        return;
+    }
+
+    @Override
+    public void validator(int number) {
+        if (number < startNumber || number > endNumber) {
+            throw new IllegalArgumentException("[ERROR] 범위 내의 숫자를 입력하세요.");
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package leets.land.domain;
+
+public interface UpDown {
+    int getAnswerAsInt();
+
+    char getAnswerAsChar();
+
+    int getStartAsInt();
+
+    char getStartAsChar();
+
+    int getEndAsInt();
+
+    char getEndAsChar();
+
+    int getCount();
+
+    void setStart(int start);
+
+    void setEnd(int end);
+
+    void increaseCount();
+
+    void validator(char alphabet);
+
+    void validator(int number);
+}

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

@@ -0,0 +1,32 @@
+package leets.land.domain;
+
+import leets.land.controller.AlphabetGame;
+import leets.land.controller.Game;
+import leets.land.controller.NumberGame;
+
+public enum Version {
+
+    NUMBER(1, new NumberGame()),
+    ALPHABET(2, new AlphabetGame());
+
+    private final int version;
+    private final Game game;
+
+    Version(int version, Game game) {
+        this.version = version;
+        this.game = game;
+    }
+
+   public static Version versionValidator(int version) {
+        for (Version gameVersion : Version.values()) {
+            if (gameVersion.version == version) {
+                return gameVersion;
+            }
+        }
+        throw new IllegalArgumentException("[ERROR] 존재하지 않는 버전입니다.");
+    }
+
+    public void run() {
+        game.run();
+    }
+}