Sdrs6921

build.gradle

@@ -3,15 +3,15 @@ apply plugin: 'eclipse'
 
 group = 'camp.nextstep'
 version = '1.0.0'
-sourceCompatibility = '1.8'
+sourceCompatibility = '11'
 
 repositories {
 	mavenCentral()
 }
 
 dependencies {
-    testImplementation "org.junit.jupiter:junit-jupiter:5.7.2"
-    testImplementation "org.assertj:assertj-core:3.19.0"
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
+    testImplementation 'org.assertj:assertj-core:3.21.0'
 }
 
 test {

src/main/java/racing/RacingCarApplication.java

@@ -0,0 +1,23 @@
+package racing;
+
+import racing.controller.GameController;
+import racing.strategy.MovementStrategy;
+import racing.strategy.RandomMovementStrategyStrategy;
+import racing.view.InputConsoleView;
+import racing.view.InputView;
+import racing.view.OutputConsoleView;
+import racing.view.OutputView;
+
+import java.util.Scanner;
+
+public class RacingCarApplication {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        InputView inputView = new InputConsoleView(scanner);
+        OutputView outputView = new OutputConsoleView();
+        MovementStrategy movementStrategy = new RandomMovementStrategyStrategy();
+        GameController gameController = new GameController(inputView, outputView, movementStrategy);
+        gameController.run();
+        scanner.close();
+    }
+}

src/main/java/racing/controller/GameController.java

@@ -0,0 +1,62 @@
+package racing.controller;
+
+import racing.domain.Car;
+import racing.domain.Cars;
+import racing.domain.Names;
+import racing.domain.Round;
+import racing.domain.vo.NumberOfAttempt;
+import racing.dto.InputCarNameDto;
+import racing.dto.InputNumberOfAttemptDto;
+import racing.dto.OutputRoundResultDto;
+import racing.dto.OutputWinnerDto;
+import racing.strategy.MovementStrategy;
+import racing.view.InputView;
+import racing.view.OutputView;
+
+import java.util.List;
+
+public class GameController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final MovementStrategy movementStrategy;
+
+    public GameController(final InputView inputView, final OutputView outputView, final MovementStrategy movementStrategy) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        this.movementStrategy = movementStrategy;
+    }
+
+    public void run() {
+        Round round = initRound();
+        outputView.printRoundResultMessage();
+        round = race(round);
+        printWinner(round);
+    }
+
+    private Round race(final Round initialRound) {
+        Round round = initialRound;
+
+        while (round.isPlaying()) {
+            round = round.play(movementStrategy);
+            Cars nextRoundCars = round.cars();
+            OutputRoundResultDto outputRoundResultDto = new OutputRoundResultDto(nextRoundCars);
+            outputView.printRoundResult(outputRoundResultDto);
+        }
+
+        return round;
+    }
+
+    private Round initRound() {
+        InputCarNameDto inputCarNameDto = inputView.inputCarNames();
+        InputNumberOfAttemptDto inputNumberOfAttemptDto = inputView.inputNumberOfAttempt();
+        Names names = inputCarNameDto.toNames();
+        NumberOfAttempt numberOfAttempt = inputNumberOfAttemptDto.toNumberOfAttempt();
+        return new Round(names, numberOfAttempt);
+    }
+
+    private void printWinner(final Round round) {
+        List<Car> winners = round.winners();
+        OutputWinnerDto outputWinnerDto = new OutputWinnerDto(winners);
+        outputView.printWinner(outputWinnerDto);
+    }
+}

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

@@ -0,0 +1,62 @@
+package racing.domain;
+
+import racing.domain.vo.Name;
+import racing.domain.vo.Position;
+import racing.strategy.MovementStrategy;
+
+import java.util.Objects;
+
+public class Car {
+
+    private static final int INITIAL_LOCATION = 0;
+    private static final int DISTANCE_MOVED_AT_ONCE = 1;
+
+    private final Name name;
+    private final Position position;
+
+    public Car(final Name name, final Position position) {
+        this.name = name;
+        this.position = position;
+    }
+
+    public Car(final String name, final int position) {
+        this(new Name(name), new Position(position));
+    }
+
+    public Car(final String name) {
+        this(name, INITIAL_LOCATION);
+    }
+
+    public Car(final Name name) {
+        this(name, new Position(INITIAL_LOCATION));
+    }
+
+    public String name() {
+        return name.value();
+    }
+
+    public int position() {
+        return position.value();
+    }
+
+    public Car move(MovementStrategy movementStrategy) {
+        if (movementStrategy.canMove()) {
+            return new Car(name, position.increaseBy(DISTANCE_MOVED_AT_ONCE));
+        }
+
+        return this;
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) return true;
+        if (!(other instanceof Car)) return false;
+        final Car car = (Car) other;
+        return name.equals(car.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}

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

@@ -0,0 +1,52 @@
+package racing.domain;
+
+import racing.strategy.MovementStrategy;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cars {
+
+    private final List<Car> elements;
+
+    public Cars(final List<Car> elements) {
+        this.elements = elements;
+    }
+
+    public Cars(final Names carNames) {
+        this(convertFrom(carNames));
+    }
+
+    private static List<Car> convertFrom(final Names carNames) {
+        return carNames.elements()
+                .stream()
+                .map(Car::new)
+                .collect(Collectors.toUnmodifiableList());
+
+    }
+
+    public List<Car> elements() {
+        return elements;
+    }
+
+    public Cars driveAll(final MovementStrategy movementStrategy) {
+        List<Car> droveCar = elements.stream()
+                .map(car -> car.move(movementStrategy))
+                .collect(Collectors.toUnmodifiableList());
+        return new Cars(droveCar);
+    }
+
+    public List<Car> findMaxPositionCars() {
+        int max = findMaxPosition();
+        return elements.stream()
+                .filter(car -> car.position() == max)
+                .collect(Collectors.toUnmodifiableList());
+    }
+
+    private int findMaxPosition() {
+        return elements.stream()
+                .map(Car::position)
+                .max(Integer::compareTo)
+                .orElseThrow(() -> new IllegalArgumentException("최대값을 찾을 수 없습니다"));
+    }
+}

src/main/java/racing/domain/Names.java

@@ -0,0 +1,18 @@
+package racing.domain;
+
+import racing.domain.vo.Name;
+
+import java.util.List;
+
+public class Names {
+
+    private final List<Name> elements;
+
+    public Names(final List<Name> elements) {
+        this.elements = elements;
+    }
+
+    public List<Name> elements() {
+        return elements;
+    }
+}

src/main/java/racing/domain/Round.java

@@ -0,0 +1,39 @@
+package racing.domain;
+
+import racing.domain.vo.NumberOfAttempt;
+import racing.strategy.MovementStrategy;
+
+import java.util.List;
+
+public class Round {
+
+    private final Cars cars;
+    private final NumberOfAttempt numberOfAttempt;
+
+    public Round(final Cars cars, final NumberOfAttempt numberOfAttempt) {
+        this.cars = cars;
+        this.numberOfAttempt = numberOfAttempt;
+    }
+
+    public Round(final Names names, final NumberOfAttempt numberOfAttempt) {
+        this(new Cars(names), numberOfAttempt);
+    }
+
+    public Round play(final MovementStrategy movementStrategy) {
+        NumberOfAttempt numberOfAttemptAfterTrying = numberOfAttempt.decrease();
+        Cars carsAfterDriveAll = this.cars.driveAll(movementStrategy);
+        return new Round(carsAfterDriveAll, numberOfAttemptAfterTrying);
+    }
+
+    public Cars cars() {
+        return cars;
+    }
+
+    public List<Car> winners() {
+        return cars.findMaxPositionCars();
+    }
+
+    public boolean isPlaying() {
+        return !numberOfAttempt.isOver();
+    }
+}

src/main/java/racing/domain/vo/Name.java

@@ -0,0 +1,39 @@
+package racing.domain.vo;
+
+import java.util.Objects;
+
+public class Name {
+
+    private static final int MIN_NAME_LENGTH = 1;
+    private static final int MAX_NAME_LENGTH = 5;
+
+    private final String value;
+
+    public Name(final String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(final String value) {
+        if (value.length() < MIN_NAME_LENGTH || value.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("이름이 길이는 1이상 5이하여야 합니다");
+        }
+    }
+
+    public String value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) return true;
+        if (!(other instanceof Name)) return false;
+        final Name name = (Name) other;
+        return value.equals(name.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/racing/domain/vo/NumberOfAttempt.java

@@ -0,0 +1,44 @@
+package racing.domain.vo;
+
+import java.util.Objects;
+
+public class NumberOfAttempt {
+
+    private static final int ZERO = 0;
+    private static final int SUBTRACTED_VALUE = 1;
+
+    private final int value;
+
+    public NumberOfAttempt(final int value) {
+        if (value < ZERO) {
+            throw new IllegalArgumentException("시도 횟수는 0 이상의 수 입니다");
+        }
+
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public NumberOfAttempt decrease() {
+        return new NumberOfAttempt(value - SUBTRACTED_VALUE);
+    }
+
+    public boolean isOver() {
+        return value == ZERO;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (!(o instanceof NumberOfAttempt)) return false;
+        final NumberOfAttempt that = (NumberOfAttempt) o;
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/racing/domain/vo/Position.java

@@ -0,0 +1,33 @@
+package racing.domain.vo;
+
+import java.util.Objects;
+
+public class Position {
+
+    private final int value;
+
+    public Position(final int value) {
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public Position increaseBy(final int distanceMovedAtOnce) {
+        return new Position(value + distanceMovedAtOnce);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Position)) return false;
+        final Position position = (Position) o;
+        return value == position.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}