[자동차 경주 게임] 김승진 미션 제출합니다.

docs/README.md

@@ -0,0 +1,77 @@
+## 기능 목록
+- [x] 자동차 이름 요청 메시지 출력
+- [x] 자동차 이름 입력 받기
+  - [x] 쉼표로 구분 됐는지 입력값 검증
+    - [x] 잘못된 입력의 경우 에러 문구 출력 및 재시도
+  - [x] 이름의 길이가 5자 이하인지 검증
+    - [x] 5자 초과의 경우 에러 문구 출력 및 재시도
+  - [x] 중복되는 이름이 있는지 검증
+    - [x] 중복시 에러 문구 출력 및 재시도
+- [x] 시도 회수 요청 메시지 출력
+- [x] 시도 회수 입력 받기
+  - [x] 입력값 숫자인지 검증
+- [x] 자동차 이동
+  - [x] 차수별 이동
+  - [x] 차수별 현황 출력
+- [x] 최종 우승자 선정
+  - [x] 최종 우승자 안내 문구 출력
+    - [x] 공동 우승자의 경우 ", " 로 구분하여 출력
+
+## 구현 클래스 목록
+- CarController
+  - play()
+
+- InputView
+  - readCars()
+  - readTryCount()
+
+- InputManager
+  - readCars()
+  - readTryCount()
+
+- InputValidator
+  - validateCars()
+  - validateTryCount()
+
+- Car
+  - move()
+  - getPosition()
+  - getName()
+  - hasMaxPosition()
+  - getCurrentStatus()
+
+- Cars
+  - getNumberOfCars()
+  - moveAll()
+  - findWinners()
+  - getCurrentDirection()
+
+- OutputView
+  - printCarRequest()
+  - printTryCountRequest()
+  - printCurrentDirection()
+  - printWinnerCars()
+
+- CarService
+  - saveCars()
+  - saveTryCount()
+  - findTryCount()
+  - move()
+  - findWinnerCars()
+
+- CarRepository
+  - saveCars()
+  - saveTryCount()
+  - findCars()
+  - findTryCount()
+
+- TryCount
+  - hasNext()
+
+- RandomMoveGenerator
+  - generate
+
+## 열거형 목록
+- ErrorMessage
+- GameMessage
+- MoveStatus

src/main/java/racingcar/Application.java

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

src/main/java/racingcar/constant/ErrorMessage.java

@@ -0,0 +1,21 @@
+package racingcar.constant;
+
+public enum ErrorMessage {
+    INVALID_CAR_INPUT("자동차 이름을 입력할 시 쉼표로 구분해야 합니다."),
+    INVALID_CARS_NUM("자동차 이름에 중복이 있습니다."),
+    INVALID_CAR_NAME_LENGTH("자동차 이름의 길이가 잘못됐습니다."),
+    INVALID_TRY_COUNT_INPUT("시도 회수의 입력값은 숫자만 가능합니다."),
+    HAS_NO_MOVE_STATUS("다음 MoveStatus가 존재하지 않습니다."),
+    INVALID_MOVE_STATUS_SIZE("MoveStatus의 개수가 잘못되었습니다.");
+
+    private static final String ERROR_PREFIX = "[ERROR] ";
+    private final String message;
+
+    ErrorMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return ERROR_PREFIX + this.message;
+    }
+}

src/main/java/racingcar/constant/GameMessage.java

@@ -0,0 +1,17 @@
+package racingcar.constant;
+
+public enum GameMessage {
+    CAR_INPUT_REQUEST("경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)"),
+    TRY_COUNT_REQUEST("시도할 회수는 몇회인가요?"),
+    WINNER_CARS("최종 우승자 : %s");
+
+    private final String message;
+
+    GameMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return this.message;
+    }
+}

src/main/java/racingcar/constant/MoveStatus.java

@@ -0,0 +1,18 @@
+package racingcar.constant;
+
+public enum MoveStatus {
+    MOVE, STOP;
+
+    private static final Integer moveDivider = 4;
+
+    public static MoveStatus getMoveStatus(final int randomNumber) {
+        if (moveDivider <= randomNumber) {
+            return MOVE;
+        }
+        return STOP;
+    }
+
+    public boolean isMove() {
+        return this == MOVE;
+    }
+}

src/main/java/racingcar/controller/CarController.java

@@ -0,0 +1,47 @@
+package racingcar.controller;
+
+import racingcar.domain.Cars;
+import racingcar.domain.TryCount;
+import racingcar.io.InputManager;
+import racingcar.io.OutputView;
+import racingcar.service.CarService;
+
+public class CarController {
+
+    private final InputManager inputManager = new InputManager();
+    private final OutputView outputView = new OutputView();
+    private final CarService carService = new CarService();
+
+    public void play() {
+        createCars();
+        createTryCount();
+        moveCars();
+        findWinnerCars();
+    }
+
+    private void moveCars() {
+        final TryCount tryCount = carService.findTryCount();
+
+        while(tryCount.hasNext()) {
+            final String currentDirection = carService.move();
+            outputView.printCurrentDirection(currentDirection);
+        }
+    }
+
+    private void findWinnerCars() {
+        final String winnerCars = carService.findWinnerCars();
+        outputView.printWinnerCars(winnerCars);
+    }
+
+    private void createTryCount() {
+        outputView.printTryCountRequest();
+        final TryCount tryCount = inputManager.readTryCount();
+        carService.saveTryCount(tryCount);
+    }
+
+    private void createCars() {
+        outputView.printCarRequest();
+        final Cars cars = inputManager.readCars();
+        carService.saveCars(cars);
+    }
+}

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

@@ -0,0 +1,66 @@
+package racingcar.domain;
+
+import racingcar.constant.ErrorMessage;
+import racingcar.constant.MoveStatus;
+
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Car {
+
+    private static final Integer MAX_SIZE = 5;
+    private static final Integer START_INDEX = 0;
+    private static final String DIRECTION_TAG = "-";
+    private static final String NAME_DELIMITER = " : ";
+    private final String name;
+    private int position = 0;
+
+    public Car(final String name) {
+        validateName(name);
+        this.name = name;
+    }
+
+    private void validateName(final String name) {
+        if (name.length() > MAX_SIZE) {
+            throw new IllegalArgumentException(ErrorMessage.INVALID_CAR_NAME_LENGTH.getMessage());
+        }
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final Car car = (Car) o;
+        return position == car.position && Objects.equals(name, car.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, position);
+    }
+
+    public void move(final MoveStatus moveStatus) {
+        if (moveStatus.isMove()) {
+            this.position++;
+        }
+    }
+
+    public Integer getPosition() {
+        return this.position;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public boolean hasMaxPosition(final int maxPosition) {
+        return this.position == maxPosition;
+    }
+
+    public String getCurrentStatus() {
+        return this.name + NAME_DELIMITER +  IntStream.range(START_INDEX, position)
+                .mapToObj(i -> DIRECTION_TAG)
+                .collect(Collectors.joining());
+    }
+}

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

@@ -0,0 +1,68 @@
+package racingcar.domain;
+
+import racingcar.constant.ErrorMessage;
+import racingcar.constant.MoveStatus;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cars {
+
+    private static final Integer MIN_POSITION = 0;
+    private static final String WINNER_DELIMITER = ", ";
+    private static final String NEW_LINE_DELIMITER = "\n";
+    private final List<Car> cars;
+
+    public Cars(final List<Car> cars) {
+        validateUnique(cars);
+        this.cars = Collections.unmodifiableList(cars);
+    }
+
+    private void validateUnique(final List<Car> cars) {
+        if (new HashSet<>(cars).size() != cars.size()) {
+            throw new IllegalArgumentException(ErrorMessage.INVALID_CARS_NUM.getMessage());
+        }
+    }
+
+    public Integer getNumberOfCars() {
+        return cars.size();
+    }
+
+    public void moveAll(final MoveStatuses moveStatuses) {
+        validateMoveStatusSize(moveStatuses);
+        cars.forEach(car -> move(car, moveStatuses.getNext()));
+    }
+
+    private void validateMoveStatusSize(final MoveStatuses moveStatuses) {
+        if (cars.size() != moveStatuses.getSize()) {
+            throw new IllegalArgumentException(ErrorMessage.INVALID_MOVE_STATUS_SIZE.getMessage());
+        }
+    }
+
+    private void move(final Car car, final MoveStatus moveStatus) {
+        car.move(moveStatus);
+    }
+
+    public String findWinners() {
+        final int maxPosition = getMaxPosition();
+        return cars.stream()
+                .filter(car -> car.hasMaxPosition(maxPosition))
+                .map(Car::getName)
+                .collect(Collectors.joining(WINNER_DELIMITER));
+    }
+
+    private int getMaxPosition() {
+        return cars.stream()
+                .mapToInt(Car::getPosition)
+                .max()
+                .orElse(MIN_POSITION);
+    }
+
+    public String getCurrentDirection() {
+        return cars.stream()
+                .map(Car::getCurrentStatus)
+                .collect(Collectors.joining(NEW_LINE_DELIMITER)) + NEW_LINE_DELIMITER;
+    }
+}

src/main/java/racingcar/domain/MoveStatuses.java

@@ -0,0 +1,31 @@
+package racingcar.domain;
+
+import racingcar.constant.ErrorMessage;
+import racingcar.constant.MoveStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MoveStatuses {
+    private static final int REMOVE_INDEX = 0;
+    private final List<MoveStatus> moveStatuses;
+
+    public MoveStatuses(final List<MoveStatus> moveStatuses) {
+        this.moveStatuses = new ArrayList<>(moveStatuses);
+    }
+
+    public MoveStatus getNext() {
+        validateHasNext();
+        return moveStatuses.remove(REMOVE_INDEX);
+    }
+
+    public int getSize() {
+        return this.moveStatuses.size();
+    }
+
+    private void validateHasNext() {
+        if (moveStatuses.isEmpty()) {
+            throw new IllegalStateException(ErrorMessage.HAS_NO_MOVE_STATUS.getMessage());
+        }
+    }
+}

src/main/java/racingcar/domain/TryCount.java

@@ -0,0 +1,14 @@
+package racingcar.domain;
+
+public class TryCount {
+
+    private Integer tryCount;
+
+    public TryCount(final Integer tryCount) {
+        this.tryCount = tryCount;
+    }
+
+    public boolean hasNext() {
+        return this.tryCount-- > 0;
+    }
+}