[자동차 경주 게임] 박진훈 리뷰 부탁드립니다!

build.gradle

@@ -14,7 +14,7 @@ dependencies {
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(8)
+        languageVersion = JavaLanguageVersion.of(11)
     }
 }
 

docs/README.md

@@ -0,0 +1,20 @@
+# 자동차 경주 게임
+
+## 기능 목록
+
+### 자동차 게임 기능
+- [x] 주어진 횟수를 입력받는 기능
+  - [x] 횟수가 숫자가 아닐시 예외 발생 기능
+  - [x] 횟수가 음수 또는 너무 큰 수 일시 예외 발생 기능
+- [x] 주어진 횟수 동안 n대의 자동차는 전진 또는 멈춤 기능
+  - [x] 움직인 결과 출력 기능
+- [x] 자동차 경주 게임을 완료한 후 누가 우승했는지 출력하는 기능
+  - [x] 우승자가 여러 명일 경우 쉼표(,)를 이용하여 구분하여 출력하는 기능
+
+### 자동차 기능
+- [x] 자동차에 이름을 입력받는 기능
+  - [x] 자동차 이름은 쉼표(,)를 기준으로 구분하는 기능
+    - [x] 쉼표(,) 여러개를 입력해도 인식 가능한 기능
+  - [x] 이름은 5자 초과시 예외 발생 기능
+- [x] 자동차는 전진 또는 멈춤 기능
+  - [x] 0에서 9 사이에서 무작위 값을 구한 후 무작위 값이 4 이상일 때 전진 기능

src/main/java/racingcar/Application.java

@@ -1,7 +1,11 @@
 package racingcar;
 
+import racingcar.controller.RacingCarController;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO 구현 진행
+        RacingCarController racingCarController = new RacingCarController();
+        racingCarController.runGame();
     }
 }

src/main/java/racingcar/controller/RacingCarController.java

@@ -0,0 +1,49 @@
+package racingcar.controller;
+
+import racingcar.domain.CarRandomMoveNumberGenerator;
+import racingcar.domain.Cars;
+import racingcar.domain.RacingCarGame;
+import racingcar.domain.TryCommand;
+import racingcar.view.InputView;
+import racingcar.view.OutputView;
+
+public class RacingCarController {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private RacingCarGame racingCarGame;
+
+    public void runGame() {
+        makeRacingCarGame();
+        playGame();
+        endGame();
+    }
+
+    private void endGame() {
+        outputView.printWinner(racingCarGame.findWinner());
+    }
+
+    private void playGame() {
+        TryCommand tryCommand = askTryCommand();
+        while(tryCommand.tryMove()){
+            racingCarGame.move();
+            outputView.printResult(racingCarGame.getCars());
+        }
+    }
+
+    private void makeRacingCarGame() {
+        racingCarGame = new RacingCarGame(askCar());
+        outputView.printBlank();
+    }
+
+    private TryCommand askTryCommand() {
+        outputView.printInputTry();
+        return new ReEnterProcessor<>(inputView::readTryCommand, outputView::printExceptionMessage).process();
+    }
+
+
+    private Cars askCar() {
+        outputView.printInputCarName();
+        return new ReEnterProcessor<>(inputView::readCarName, outputView::printExceptionMessage).process();
+    }
+}

src/main/java/racingcar/controller/ReEnterProcessor.java

@@ -0,0 +1,24 @@
+package racingcar.controller;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class ReEnterProcessor<T> {
+    private final Supplier<T> processor;
+    private final Consumer<IllegalArgumentException> consumer;
+
+    public ReEnterProcessor(Supplier<T> processor, Consumer<IllegalArgumentException> consumer) {
+        this.processor = processor;
+        this.consumer = consumer;
+    }
+
+    public T process() {
+        while(true){
+            try {
+                return processor.get();
+            }catch (IllegalArgumentException exception){
+                consumer.accept(exception);
+            }
+        }
+    }
+}

src/main/java/racingcar/domain/Car.java

@@ -0,0 +1,42 @@
+package racingcar.domain;
+
+import racingcar.exception.CarNameLengthException;
+
+public class Car {
+
+    private static final int CAR_NAME_LENGTH = 5;
+    private static final int MOVABLE_MIN_NUMBER = 4;
+    private final String name;
+    private int position = 0;
+
+    public Car(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        validateLength(name);
+    }
+
+    private void validateLength(String name) {
+        if (name.length() > CAR_NAME_LENGTH) {
+            throw new CarNameLengthException();
+        }
+    }
+
+    public void move(CarMoveNumberGenerator carMoveNumberGenerator) {
+        final int number = carMoveNumberGenerator.generate();
+
+        if (number >= MOVABLE_MIN_NUMBER) {
+            position++;
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+}

src/main/java/racingcar/domain/CarMoveNumberGenerator.java

@@ -0,0 +1,6 @@
+package racingcar.domain;
+
+public interface CarMoveNumberGenerator {
+
+    int generate();
+}

src/main/java/racingcar/domain/CarRandomMoveNumberGenerator.java

@@ -0,0 +1,14 @@
+package racingcar.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+public class CarRandomMoveNumberGenerator implements CarMoveNumberGenerator {
+
+    private static final int RANDOM_LOWER_INCLUSIVE = 0;
+    private static final int RANDOM_UPPER_INCLUSIVE = 9;
+
+    @Override
+    public int generate() {
+        return Randoms.pickNumberInRange(RANDOM_LOWER_INCLUSIVE, RANDOM_UPPER_INCLUSIVE);
+    }
+}

src/main/java/racingcar/domain/Cars.java

@@ -0,0 +1,71 @@
+package racingcar.domain;
+
+import racingcar.exception.CarsDuplicatedNameException;
+import racingcar.exception.CarsMaxScoreBlankException;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Cars {
+
+    private static final String DELIMITER = ",";
+    private static final String DUPLICATED_DELIMITER_REGEX = ",+";
+    private final List<Car> cars;
+
+    private Cars(List<Car> cars) {
+        this.cars = Collections.unmodifiableList(cars);
+    }
+
+    public static Cars createCarNameByWord(String input) {
+        List<Car> cars = new ArrayList<>();
+        String[] words = divideWord(input);
+        validate(words);
+
+        for (String carName : words) {
+            cars.add(new Car(carName));
+        }
+        return new Cars(cars);
+    }
+
+    private static void validate(String[] words) {
+        validateDuplicatedWord(words);
+    }
+
+    private static void validateDuplicatedWord(String[] words) {
+        Set<String> uniqueWord = new HashSet<>();
+        for (String word : words) {
+            if (!uniqueWord.add(word)) {
+                throw new CarsDuplicatedNameException();
+            }
+        }
+    }
+
+    private static String[] divideWord(String word) {
+        return word.replaceAll(DUPLICATED_DELIMITER_REGEX, DELIMITER).split(DELIMITER);
+    }
+
+    public void move(CarMoveNumberGenerator carMoveNumberGenerator) {
+        for (Car car : cars) {
+            car.move(carMoveNumberGenerator);
+        }
+    }
+
+    public Winner findWinner() {
+        int maxScore = findMaxScore();
+        return new Winner(cars.stream()
+                .filter(car -> (car.getPosition() == maxScore))
+                .map(Car::getName)
+                .collect(Collectors.toList()));
+    }
+
+    private int findMaxScore() {
+        return cars.stream()
+                .max(Comparator.comparingInt(Car::getPosition))
+                .map(Car::getPosition)
+                .orElseThrow(CarsMaxScoreBlankException::new);
+    }
+
+    public List<Car> getCars() {
+        return cars;
+    }
+}

src/main/java/racingcar/domain/RacingCarGame.java

@@ -0,0 +1,22 @@
+package racingcar.domain;
+
+public class RacingCarGame {
+
+    private final Cars cars;
+
+    public RacingCarGame(Cars cars) {
+        this.cars = cars;
+    }
+
+    public void move() {
+        cars.move(new CarRandomMoveNumberGenerator());
+    }
+
+    public Winner findWinner() {
+        return cars.findWinner();
+    }
+
+    public Cars getCars() {
+        return cars;
+    }
+}

src/main/java/racingcar/domain/TryCommand.java

@@ -0,0 +1,47 @@
+package racingcar.domain;
+
+import racingcar.exception.TryCommandNumberException;
+import racingcar.exception.TryCommandRangeException;
+
+public class TryCommand {
+
+    private static final int MIN_TRY = 1;
+    private static final int MAX_TRY = 100000;
+    private int tryCount;
+
+    private TryCommand(int tryCount) {
+        this.tryCount = tryCount;
+    }
+
+    public static TryCommand createTryCommandByString(String input) {
+        int number = convertInt(input);
+        validate(number);
+        return new TryCommand(number);
+    }
+
+    private static void validate(int number) {
+        validateRange(number);
+    }
+
+    private static void validateRange(int number) {
+        if(number < MIN_TRY || number > MAX_TRY) {
+            throw new TryCommandRangeException(MIN_TRY, MAX_TRY);
+        }
+    }
+
+    private static int convertInt(String input) {
+        try{
+            return Integer.parseInt(input);
+        }catch (NumberFormatException exception) {
+            throw new TryCommandNumberException();
+        }
+    }
+
+    public boolean tryMove() {
+        if(tryCount > 0) {
+            tryCount--;
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/racingcar/domain/Winner.java

@@ -0,0 +1,16 @@
+package racingcar.domain;
+
+import java.util.List;
+
+public class Winner {
+
+    private final List<String> winner;
+
+    public Winner(List<String> winner) {
+        this.winner = winner;
+    }
+
+    public List<String> getWinner() {
+        return winner;
+    }
+}

src/main/java/racingcar/exception/CarNameLengthException.java

@@ -0,0 +1,10 @@
+package racingcar.exception;
+
+public class CarNameLengthException extends IllegalArgumentException{
+
+    private static final String EXCEPTION_MESSAGE_CAR_NAME_LENGTH = "[ERROR] 자동차이름은 5글자 이하입니다";
+
+    public CarNameLengthException() {
+        super(EXCEPTION_MESSAGE_CAR_NAME_LENGTH);
+    }
+}

src/main/java/racingcar/exception/CarsDuplicatedNameException.java

@@ -0,0 +1,10 @@
+package racingcar.exception;
+
+public class CarsDuplicatedNameException extends IllegalArgumentException {
+
+    private static final String EXCEPTION_MESSAGE_CARS_DUPLICATED_NAME = "[ERROR] 자동차 이름은 중복될 수 없습니다";
+
+    public CarsDuplicatedNameException() {
+        super(EXCEPTION_MESSAGE_CARS_DUPLICATED_NAME);
+    }
+}

src/main/java/racingcar/exception/CarsMaxScoreBlankException.java

@@ -0,0 +1,10 @@
+package racingcar.exception;
+
+public class CarsMaxScoreBlankException extends IllegalArgumentException{
+
+    private static final String EXCEPTION_MESSAGE_CARS_MAX_SCORE_BLANK = "[ERROR] 우승자를 찾을 수 없습니다.";
+
+    public CarsMaxScoreBlankException() {
+        super(EXCEPTION_MESSAGE_CARS_MAX_SCORE_BLANK);
+    }
+}