[경북대 BE_김영인] 미션 제출합니다.

README.md

@@ -1 +1,40 @@
-# java-racingcar-precourse
+# java-racingcar-precourse
+
+## 기능 요구 사항
+초간단 자동차 경주 게임을 구현한다.
+
+- 주어진 횟수 동안 n대의 자동차는 전진 또는 멈출 수 있다.
+- 각 자동차에 이름을 부여할 수 있다. 
+  - 전진하는 자동차를 출력할 때 자동차 이름을 같이 출력한다.
+- 자동차 이름은 쉼표(,)를 기준으로 구분하며 이름은 5자 이하만 가능하다.
+- 사용자는 몇 번의 이동을 할 것인지를 입력할 수 있어야 한다.
+- 전진하는 조건은 0에서 9 사이에서 무작위 값을 구한 후 무작위 값이 4 이상일 경우이다.
+- 자동차 경주 게임을 완료한 후 누가 우승했는지를 알려준다. 우승자는 한 명 이상일 수 있다.
+- 우승자가 여러 명일 경우 쉼표(,)를 이용하여 구분한다.
+- 사용자가 잘못된 값을 입력할 경우 `IllegalArgumentException`을 발생시킨 후 애플리케이션은 종료되어야 한다.
+
+## 자동차 경주 기능 목록
+- [ ] 게임을 시작하면, 경주할 자동차를 생성할 수 있어야 한다.
+  - [ ] 자동차는 쉼표(,)를 기준으로 구분하여 생성된다.
+    - [ ] 자동차 이름은 5자 이하만 가능하다.
+    - [ ] 자동차 이름은 중복으로 사용될 수 없다.
+    - [ ] 자동차경주를 하기위해서는, 자동차는 최소 2대 이상 생성해야한다.
+
+
+- [ ] 사용자는 몇 번의 이동을 할 것인지 입력할 수 있다.
+  - [ ] 이동할 횟수는 0이상의 '자연수'이어야 한다.
+
+
+- [ ] 자동차는 전진 또는 멈출 수 있다.
+  - [ ] 0에서 9사이에서 무작위한 값이 4이상인 경우 전진한다.
+  - [ ] 0에서 9사이의 무작위한 값이 3이하인 경우 멈춘다.
+
+
+- [ ] 자동차 경주를 확인할 수 있다.
+  - [ ] 경주하는 자동차 이름을 확인할 수 있다.
+  - [ ] 라운드마다 자동차가 전진했다면 `-`로 이동 거리를 출력한다.
+
+
+- [ ] 자동차 경주 게임의 우승자를 확인할 수 있다.
+  - [ ] 단독 우승자의 경우 우승한 자동차를 출력한다.
+  - [ ] 공동 우승자의 경우 우승한 자동차 이름을 `, `로 구분지어서 출력한다.

src/main/java/Application.java

@@ -0,0 +1,9 @@
+import controller.RacingGameController;
+
+public class Application {
+    public static void main(String[] args) {
+        RacingGameController racingGameController = new RacingGameController();
+        racingGameController.startGame();
+    }
+}
+

src/main/java/controller/RacingGameController.java

@@ -0,0 +1,43 @@
+package controller;
+
+import domain.RacingCars;
+import domain.TrialNum;
+import util.CreatingCar;
+import util.RandomGeneratingMove;
+import view.InputView;
+import view.OutputView;
+
+public class RacingGameController {
+    private InputView inputView = new InputView();
+    private OutputView outputView = new OutputView();
+    private final RandomGeneratingMove randomGeneratingMove = new RandomGeneratingMove();
+    public void startGame(){
+        RacingCars racingCars = createRacingCars();
+        TrialNum trialNum = getTryCount();
+
+        racing(racingCars, trialNum);
+    }
+
+    private RacingCars createRacingCars(){
+        outputView.printRequestCarNames();
+        String[] carNames = inputView.inputCarNames();
+        return CreatingCar.createCars(carNames);
+    }
+
+    private TrialNum getTryCount(){
+        outputView.printRequestTryCount();
+        String inputTryCount = inputView.inputTryCount();
+        return new TrialNum(inputTryCount);
+    }
+
+    private void racing(RacingCars cars, TrialNum trialNum) {
+        outputView.printExecutionResult();
+
+        for (int i = 0; i < trialNum.getTrialNum(); i++) {
+            cars.moveAll(randomGeneratingMove);
+            outputView.printRoundByExecutionResults(cars);
+        }
+        outputView.printRacingCarWinnerResult(cars);
+    }
+
+}

src/main/java/domain/Distance.java

@@ -0,0 +1,9 @@
+package domain;
+
+public record Distance(int location) {
+    private static final int MOVE_VALUE = 1;
+
+    public Distance increase(){
+        return new Distance(location + MOVE_VALUE);
+    }
+}

src/main/java/domain/RacingCar.java

@@ -0,0 +1,36 @@
+package domain;
+
+public class RacingCar implements Comparable<RacingCar> {
+    private static final int MOVE_CONDITION = 4;
+
+    private RacingCarName racingCarName;
+    private Distance distance;
+
+    public RacingCar(final String name, final int distance) {
+        this.racingCarName = new RacingCarName(name);
+        this.distance = new Distance(distance);
+    }
+
+    public void move(final int num){
+        if(num >= MOVE_CONDITION){
+            this.distance = distance.increase();
+        }
+    }
+
+    public String getRacingCarName() {
+        return racingCarName.carName();
+    }
+
+    public Integer getDistance() {
+        return distance.location();
+    }
+
+    public boolean isSameDistance(RacingCar competeCar) {
+        return this.distance.location() == competeCar.distance.location();
+    }
+
+    @Override
+    public int compareTo(RacingCar competeCar) {
+        return this.distance.location() - competeCar.distance.location();
+    }
+}

src/main/java/domain/RacingCarName.java

@@ -0,0 +1,15 @@
+package domain;
+
+public record RacingCarName(String carName){
+    private static final int CAR_NAME_LENGTH_MAX = 5;
+
+    public RacingCarName {
+        isCarNameLengthValidate(carName);
+    }
+
+    private void isCarNameLengthValidate(final String carName){
+        if (carName.isEmpty() || carName.length() > CAR_NAME_LENGTH_MAX){
+            throw new IllegalArgumentException("자동차이름은 1자리이상 5자 이하만 가능합니다.");
+        }
+    }
+}

src/main/java/domain/RacingCars.java

@@ -0,0 +1,66 @@
+package domain;
+
+import util.RandomGeneratingMove;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class RacingCars {
+    private static final int MINIMUM_CAR_COUNT = 2;
+    private final List<RacingCar> cars;
+
+    public RacingCars(List<RacingCar> cars) {
+        isDifferentCarName(cars);
+        minimumNumofCars(cars.size());
+        this.cars = cars;
+    }
+
+    public void moveAll(final RandomGeneratingMove randomGeneratingMove) {
+        for (final RacingCar car : cars) {
+            int engine = randomGeneratingMove.generateRandomInt();
+            car.move(engine);
+        }
+    }
+
+    private void isDifferentCarName(List<RacingCar> cars) {
+        List<String> carName = cars.stream()
+                .map(idx -> idx.getRacingCarName())
+                .collect(Collectors.toList());
+
+        HashSet<String> carNameDuplicateSet = new HashSet<>(carName);
+
+        if (carNameDuplicateSet.size() != carName.size()) {
+            throw new IllegalArgumentException("자동차 이름을 중복으로 사용할 수 없습니다.");
+        }
+    }
+
+    private void minimumNumofCars(int size) {
+        if (size < MINIMUM_CAR_COUNT) {
+            throw new IllegalArgumentException("자동차 경주를 위해서는 최소 2대 이상의 자동차를 만들어야 합니다.");
+        }
+    }
+
+    public List<RacingCar> getCars() {
+        return cars;
+    }
+
+    public List<String> findWinners(){
+        RacingCar maxDistanceCar = findMaxDistanceCar();
+        List<String> winnerCarNameList = findSameDistanceList(maxDistanceCar);
+        return winnerCarNameList;
+    }
+
+    private RacingCar findMaxDistanceCar() {
+        return cars.stream()
+                .max(RacingCar::compareTo)
+                .orElseThrow(() -> new IllegalArgumentException("차량 리스트가 비었습니다."));
+    }
+
+    private List<String> findSameDistanceList(RacingCar maxDistanceCar) {
+        return cars.stream()
+                .filter(maxDistanceCar::isSameDistance)
+                .map(RacingCar::getRacingCarName)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/domain/TrialNum.java

@@ -0,0 +1,25 @@
+package domain;
+
+public class TrialNum {
+
+    private final int trialNum;
+
+    public TrialNum(final String trialNum) {
+        isNaturalNumberValidate(trialNum);
+        this.trialNum = convertStringToInt(trialNum);
+    }
+
+    private void isNaturalNumberValidate(String trialNum) {
+        if (!trialNum.matches("^[1-9]\\d*$")){
+            throw new IllegalArgumentException("이동할 횟수는 자연수여야 한다.");
+        }
+    }
+
+    private int convertStringToInt(String input) {
+        return Integer.parseInt(input);
+    }
+
+    public int getTrialNum() {
+        return trialNum;
+    }
+}

src/main/java/util/CreatingCar.java

@@ -0,0 +1,26 @@
+package util;
+
+import domain.RacingCar;
+import domain.RacingCars;
+import java.util.stream.Collectors;
+import java.util.Arrays;
+import java.util.List;
+
+public class CreatingCar {
+    private static final int START_LOCATION = 0;
+
+    public static RacingCars createCars(final String[] carNames) {
+        List<RacingCar> cars = makeCars(carNames);
+        return new RacingCars(cars);
+    }
+
+    private static List<RacingCar> makeCars(final String[] carNames) {
+        return Arrays.stream(carNames)
+                .map(CreatingCar::makeCar)
+                .collect(Collectors.toList());
+    }
+
+    private static RacingCar makeCar(final String carName) {
+        return new RacingCar(carName, START_LOCATION);
+    }
+}

src/main/java/util/RandomGeneratingMove.java

@@ -0,0 +1,20 @@
+package util;
+
+import java.util.Random;
+
+public class RandomGeneratingMove implements RandomGenerator {
+
+    private static final int MIN_RANDOM_NUMBER = 0;
+    private static final int MAX_RANDOM_NUMBER = 9;
+    private Random random;
+
+    public RandomGeneratingMove() {
+        this.random = new Random();
+    }
+
+    @Override
+    public int generateRandomInt() {
+        return random.nextInt((MAX_RANDOM_NUMBER - MIN_RANDOM_NUMBER + 1)) + MIN_RANDOM_NUMBER;
+    }
+}
+

src/main/java/util/RandomGenerator.java

@@ -0,0 +1,5 @@
+package util;
+
+public interface RandomGenerator {
+    int generateRandomInt();
+}

src/main/java/util/SplitingCarName.java

@@ -0,0 +1,9 @@
+package util;
+
+public class SplitingCarName {
+    private static final String STRING_SPLITTER = ",";
+
+    public static String[] splitCarName(String carNames) {
+        return carNames.split(STRING_SPLITTER);
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,22 @@
+package view;
+
+import util.SplitingCarName;
+
+import java.util.Scanner;
+
+public class InputView {
+    private Scanner scanner;
+
+    public InputView() {
+        this.scanner = new Scanner(System.in);
+    }
+
+    public String[] inputCarNames(){
+        String carNames = scanner.nextLine();
+        return SplitingCarName.splitCarName(carNames);
+    }
+
+    public String inputTryCount(){
+        return scanner.nextLine();
+    }
+}