자동차 경주 게임!

src/main/java/racing/RacingGame.java

@@ -0,0 +1,28 @@
+package racing;
+
+import racing.domain.*;
+import racing.util.RandomNumberGenerator;
+import racing.view.InputView;
+import racing.view.ResultView;
+
+import java.util.List;
+import java.util.Scanner;
+
+public class RacingGame {
+    private final InputView inputView = new InputView(new Scanner(System.in));
+
+    public void run() {
+        List<String> carNames = inputView.inputCarNames();
+        int tryCount = inputView.inputTryCount();
+
+        Cars cars = new Cars(CarFactory.createCars(carNames));
+
+        EachRoundResult eachRoundResult = new EachRoundResult();
+        cars.operate(tryCount, new RandomNumberGenerator(), eachRoundResult);
+
+        Winners winners = new Winners(eachRoundResult.getWinners());
+
+        ResultView resultView = new ResultView();
+        resultView.printResult(eachRoundResult, winners);
+    }
+}

src/main/java/racing/RacingGameApplication.java

@@ -0,0 +1,8 @@
+package racing;
+
+public class RacingGameApplication {
+    public static void main(String[] args) {
+        RacingGame racingGame = new RacingGame();
+        racingGame.run();
+    }
+}

src/main/java/racing/domain/Car.java

@@ -0,0 +1,23 @@
+package racing.domain;
+
+public class Car {
+    private String name;
+    private int distance;
+
+    public Car(String name, int distance) {
+        this.name = name;
+        this.distance = distance;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getDistance() {
+        return distance;
+    }
+
+    public void move(int moveDistance) {
+        this.distance += moveDistance;
+    }
+}

src/main/java/racing/domain/CarFactory.java

@@ -0,0 +1,14 @@
+package racing.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CarFactory {
+    public static List<Car> createCars(List<String> carNames) {
+        List<Car> cars = new ArrayList<>();
+        for (String carName : carNames) {
+            cars.add(new Car(carName, 0));
+        }
+        return cars;
+    }
+}

src/main/java/racing/domain/Cars.java

@@ -0,0 +1,31 @@
+package racing.domain;
+
+import racing.util.NumberGenerator;
+import racing.util.RandomDistanceUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Cars {
+    private final List<Car> cars;
+
+    public Cars(List<Car> cars) {
+        this.cars = cars;
+    }
+
+    public void operate(int tryCount, NumberGenerator numberGenerator, EachRoundResult eachRoundResult) {
+        for (int roundIdx = 1; roundIdx <= tryCount; roundIdx++) {
+            List<ResultCarInfo> roundResult = new ArrayList<>();
+            moveCars(roundResult, numberGenerator);
+            eachRoundResult.addRoundResult(roundIdx, roundResult);
+        }
+    }
+
+    private void moveCars(List<ResultCarInfo> roundResult, NumberGenerator numberGenerator) {
+        for (int carIdx = 0; carIdx < cars.size(); carIdx++) {
+            Car car = cars.get(carIdx);
+            car.move(RandomDistanceUtil.getRandomDistance(numberGenerator));
+            roundResult.add(new ResultCarInfo(car.getName(), car.getDistance()));
+        }
+    }
+}

src/main/java/racing/domain/EachRoundResult.java

@@ -0,0 +1,41 @@
+package racing.domain;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class EachRoundResult {
+    private final Map<Integer, List<ResultCarInfo>> eachRoundResult = new HashMap<>();
+
+    public void addRoundResult(int roundIdx, List<ResultCarInfo> resultCarInfos) {
+        eachRoundResult.put(roundIdx, resultCarInfos);
+    }
+
+    public List<ResultCarInfo> getRoundResult(int roundIdx) {
+        return eachRoundResult.get(roundIdx);
+    }
+
+    public List<String> getWinners() {
+        List<ResultCarInfo> lastRound = getLastRound();
+        int maxDistance = getMaxDistance(lastRound);
+        return lastRound.stream()
+                .filter(carDataInfo -> carDataInfo.getDistance() == maxDistance)
+                .map(ResultCarInfo::getName)
+                .collect(Collectors.toList());
+    }
+
+    private List<ResultCarInfo> getLastRound() {
+        return eachRoundResult.get(eachRoundResult.size());
+    }
+
+    private int getMaxDistance(List<ResultCarInfo> lastRound) {
+        ResultCarInfo maxByDistance = lastRound.stream()
+                .max(Comparator.comparing(ResultCarInfo::getDistance))
+                .orElseThrow((NoSuchElementException::new));
+
+        return maxByDistance.getDistance();
+    }
+
+    public int size() {
+        return eachRoundResult.size();
+    }
+}

src/main/java/racing/domain/ResultCarInfo.java

@@ -0,0 +1,19 @@
+package racing.domain;
+
+public final class ResultCarInfo {
+    private final String name;
+    private final int distance;
+
+    public ResultCarInfo(String name, int distance) {
+        this.name = name;
+        this.distance = distance;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getDistance() {
+        return distance;
+    }
+}

src/main/java/racing/domain/Winners.java

@@ -0,0 +1,19 @@
+package racing.domain;
+
+import java.util.List;
+
+public class Winners {
+    private final List<String> names;
+
+    public Winners(List<String> names) {
+        this.names = names;
+    }
+
+    public String getName(int idx) {
+        return names.get(idx);
+    }
+
+    public int size() {
+        return names.size();
+    }
+}

src/main/java/racing/util/NumberGenerator.java

@@ -0,0 +1,5 @@
+package racing.util;
+
+public interface NumberGenerator {
+    int generateNumber();
+}

src/main/java/racing/util/RandomDistanceUtil.java

@@ -0,0 +1,13 @@
+package racing.util;
+
+public class RandomDistanceUtil {
+    private static final int MOVE = 1;
+    private static final int STOP = 0;
+
+    public static int getRandomDistance(NumberGenerator numberGenerator) {
+        if (numberGenerator.generateNumber() >= 4) {
+            return MOVE;
+        }
+        return STOP;
+    }
+}

src/main/java/racing/util/RandomNumberGenerator.java

@@ -0,0 +1,12 @@
+package racing.util;
+
+import java.util.Random;
+
+public class RandomNumberGenerator implements NumberGenerator {
+    private static final int MAX = 10;
+
+    @Override
+    public int generateNumber() {
+        return new Random().nextInt(MAX);
+    }
+}

src/main/java/racing/util/SplitUtil.java

@@ -0,0 +1,41 @@
+package racing.util;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class SplitUtil {
+    public static List<String> split(String carNames) {
+        checkEmpty(carNames);
+        List<String> splitValue = Arrays.asList(carNames.split(","));
+
+        checkCount(splitValue.size());
+        checkDuplicate(splitValue);
+
+        return splitValue;
+    }
+
+    private static void checkEmpty(String carNames) {
+        if (carNames.isEmpty()) {
+            throw new NullPointerException("경주할 자동차 이름을 입력하지 않았습니다.");
+        }
+    }
+
+    private static void checkCount(int carCount) {
+        if (carCount < 1) {
+            throw new IllegalArgumentException("게임을 진행하려면 한대 이상의 자동차가 필요합니다.");
+        }
+    }
+
+    private static void checkDuplicate(List<String> splitValue) {
+        if (isDuplicate(splitValue)) {
+            throw new IllegalArgumentException("자동차의 이름은 모두 달라야 합니다.");
+        }
+    }
+
+    private static boolean isDuplicate(List<String> splitValue) {
+        return splitValue
+                .stream()
+                .distinct()
+                .count() != splitValue.size();
+    }
+}

src/main/java/racing/view/InputView.java

@@ -0,0 +1,35 @@
+package racing.view;
+
+import racing.util.SplitUtil;
+
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+    private static final String FIRST_QUESTION = "경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).";
+    private static final String SECOND_QUESTION = "시도할 횟수는 몇 회 인가요?";
+
+    private final Scanner sc;
+
+    public InputView(Scanner sc) {
+        this.sc = sc;
+    }
+
+    public List<String> inputCarNames() {
+        System.out.println(FIRST_QUESTION);
+        return SplitUtil.split(sc.nextLine());
+    }
+
+    public int inputTryCount() {
+        System.out.println(SECOND_QUESTION);
+        int tryCount = sc.nextInt();
+        checkPositiveNumber(tryCount);
+        return tryCount;
+    }
+
+    private void checkPositiveNumber(int tryCount) {
+        if (tryCount <= 0) {
+            throw new IllegalArgumentException("최소 한번 이상의 게임을 진행해야 합니다.");
+        }
+    }
+}