[스프링 화요일 1팀] (이우식) 미션 제출합니다.

src/main/java/RacingGameApplication.java

@@ -0,0 +1,38 @@
+
+import java.util.Scanner;
+import controller.RacingGameController;
+import view.InputParser;
+import view.InputValidator;
+import view.InputView;
+import view.OutputView;
+
+public class RacingGameApplication {
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static void main(String[] args) {
+        RacingGameController racingGameController = new RacingGameController(inputView(), outputView());
+        racingGameController.run();
+        clean();
+    }
+
+    private static InputView inputView() {
+        return new InputView(inputValidator(), inputParser(), scanner);
+    }
+
+    private static InputValidator inputValidator() {
+        return new InputValidator();
+    }
+
+    private static InputParser inputParser() {
+        return new InputParser();
+    }
+
+    private static OutputView outputView() {
+        return new OutputView();
+    }
+
+    private static void clean() {
+        scanner.close();
+    }
+}

src/main/java/controller/RacingGameController.java

@@ -0,0 +1,55 @@
+package controller;
+
+import java.util.List;
+import java.util.function.Supplier;
+import domain.Car;
+import domain.RacingGame;
+import domain.RandomNumberGenerator;
+import view.InputView;
+import view.OutputView;
+
+public class RacingGameController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public RacingGameController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public <T> T retry(final Supplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (IllegalArgumentException e) {
+            outputView.printErrorMessage(e.getMessage());
+            return retry(supplier);
+        }
+    }
+
+    public void run() {
+        RacingGame racingGame = initialize();
+        play(racingGame);
+        findWinners(racingGame);
+    }
+
+    private RacingGame initialize() {
+        List<String> carNames = retry(inputView::readCarNames);
+        int count = retry(inputView::readCount);
+        return new RacingGame(new RandomNumberGenerator(), carNames, count);
+    }
+
+    private void play(final RacingGame racingGame) {
+        outputView.printResultMessage();
+        while (racingGame.isPlayable()) {
+            racingGame.play();
+            List<Car> cars = racingGame.findCurrentCarPositions();
+            outputView.printCurrentCarPositions(cars);
+        }
+    }
+
+    private void findWinners(final RacingGame racingGame) {
+        List<String> winners = racingGame.findWinners();
+        outputView.printWinnersMessage(winners);
+    }
+}

src/main/java/domain/Car.java

@@ -0,0 +1,35 @@
+package domain;
+
+public class Car implements Comparable<Car> {
+
+    private static final int MOVE_MIN_BOUND = 4;
+
+    private final Name name;
+    private final Position position;
+
+
+
+    public Car(final String name) {
+        this.name = new Name(name);
+        this.position = new Position();
+    }
+    public void move(final int value){
+        if (MOVE_MIN_BOUND <= value){
+            position.increase();
+        }
+    }
+    public boolean isSamePos(final Car car){
+        return this.position.equals(car.position);
+    }
+    @Override
+    public int compareTo(final Car opponent){
+        return this.position.compareTo(opponent.position);
+    }
+    public String getName(){
+        return name.getValue();
+    }
+    public int getPosition(){
+        return position.getValue();
+    }
+
+}

src/main/java/domain/Cars.java

@@ -0,0 +1,63 @@
+package domain;
+
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toUnmodifiableList;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Cars {
+
+    private static final String INVALID_WINNER_MESSAGE = "우승자가 존재하지 않습니다.";
+    private static final String DUPLICATED_NAMES_MESSAGE = "중복된 차 이름이 없어야 합니다.";
+
+    private final List<Car> cars;
+
+    public Cars(final List<String> names) {
+        validate(names);
+        this.cars = toCars(names);
+    }
+
+    private void validate(final List<String> names) {
+        Set<String> nonDuplicateNames = new HashSet<>(names);
+        if (names.size() != nonDuplicateNames.size()) {
+            throw new IllegalArgumentException(DUPLICATED_NAMES_MESSAGE);
+        }
+    }
+
+    private List<Car> toCars(final List<String> names) {
+        return names.stream()
+                .map(Car::new)
+                .collect(toList());
+    }
+
+    public void race(final NumberGenerator strategy) {
+        for (Car car : cars) {
+            car.move(strategy.generate());
+        }
+    }
+
+    public List<String> findWinners() {
+        Car winner = findWinner();
+        return findWinners(winner);
+    }
+
+    private Car findWinner() {
+        return cars.stream()
+                .max(Car::compareTo)
+                .orElseThrow(() -> new IllegalArgumentException(INVALID_WINNER_MESSAGE));
+    }
+
+    private List<String> findWinners(final Car winner) {
+        return cars.stream()
+                .filter(car -> car.isSamePos(winner))
+                .map(Car::getName)
+                .collect(toUnmodifiableList());
+    }
+
+    public List<Car> getCars() {
+        return Collections.unmodifiableList(cars);
+    }
+}

src/main/java/domain/Count.java

@@ -0,0 +1,20 @@
+package domain;
+
+public class Count {
+
+    private static final int PLAYABLE_MIN_COUNT = 1;
+
+    private int value;
+
+    Count(final int value) {
+        this.value = value;
+    }
+
+    public void decrease() {
+        value--;
+    }
+
+    public boolean isPlayable() {
+        return PLAYABLE_MIN_COUNT <= value;
+    }
+}

src/main/java/domain/Name.java

@@ -0,0 +1,30 @@
+package domain;
+
+public class Name {
+
+    private static final int NAME_MIN_BOUND = 1;
+    private static final int NAME_MAX_BOUND = 5;
+    private static final String INVALID_NAME_LENGTH_MESSAGE =
+            "차의 이름은 " + NAME_MIN_BOUND + "자 이상, " + NAME_MAX_BOUND + "자 이하여야 합니다. 입력된 차 이름 : ";
+
+    private final String value;
+
+    Name(final String name) {
+        validate(name);
+        this.value = name;
+    }
+
+    private void validate(final String name) {
+        if (isInvalidNameLength(name)) {
+            throw new IllegalArgumentException(INVALID_NAME_LENGTH_MESSAGE + name);
+        }
+    }
+
+    private boolean isInvalidNameLength(final String name) {
+        return name.length() < NAME_MIN_BOUND || NAME_MAX_BOUND < name.length();
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/domain/NumberGenerator.java

@@ -0,0 +1,6 @@
+package domain;
+
+@FunctionalInterface
+public interface NumberGenerator {
+    int generate();
+}

src/main/java/domain/Position.java

@@ -0,0 +1,44 @@
+package domain;
+
+import java.util.Objects;
+
+public class Position implements Comparable<Position> {
+
+    private static final int INITIAL_VALUE = 0;
+
+    private int value;
+
+    Position() {
+        this.value = INITIAL_VALUE;
+    }
+
+    public void increase() {
+        value++;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Position position = (Position) o;
+        return getValue() == position.getValue();
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getValue());
+    }
+
+    @Override
+    public int compareTo(final Position other) {
+        return this.value - other.value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

src/main/java/domain/RacingGame.java

@@ -0,0 +1,33 @@
+package domain;
+
+import java.util.List;
+
+public class RacingGame {
+
+    private final NumberGenerator numberGenerator;
+    private final Cars cars;
+    private final Count count;
+
+    public RacingGame(final NumberGenerator numberGenerator, final List<String> names, final int count) {
+        this.numberGenerator = numberGenerator;
+        this.cars = new Cars(names);
+        this.count = new Count(count);
+    }
+
+    public boolean isPlayable() {
+        return count.isPlayable();
+    }
+
+    public void play() {
+        cars.race(numberGenerator);
+        count.decrease();
+    }
+
+    public List<Car> findCurrentCarPositions() {
+        return cars.getCars();
+    }
+
+    public List<String> findWinners() {
+        return cars.findWinners();
+    }
+}

src/main/java/domain/RandomNumberGenerator.java

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

src/main/java/readme.txt

@@ -0,0 +1,14 @@
+
+1. 자동차
+   1. ,를 기준으로 입력 받음
+   2. 이름
+      1. 5자 이하
+   3. 전진 기능
+      1. 무작위로 0~9값을 구한 후 값이 4이상일 경우 전진
+      2. 전진할 때 자동차 위치와 이름을 같이 출력
+
+2. 경주
+   1. 경주 횟수
+      1. 정수여야함
+   2. 우승자 출력
+      1. 여러명이면 ,로 구분해서 출력