Add roll dice usecase

build.gradle

@@ -1,12 +1,15 @@
 plugins {
     id 'java'
+    id 'org.springframework.boot' version '2.7.5'
+    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
 }
 
 java {
     toolchain {
         languageVersion = JavaLanguageVersion.of(17)
     }
 }
+
 group 'org.example'
 version '1.0-SNAPSHOT'
 
@@ -15,12 +18,23 @@ repositories {
 }
 
 dependencies {
-    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.7.5'
-    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '2.7.5'
-    testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.7.5'
-    //todo embedded test db
+    implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+
+    // embedded test MongoDB
+    implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
+    testImplementation 'de.flapdoodle.embed:de.flapdoodle.embed.mongo'
+
+
+    // Lombok
+    compileOnly 'org.projectlombok:lombok:1.18.26'
+    annotationProcessor 'org.projectlombok:lombok:1.18.26'
+    testCompileOnly 'org.projectlombok:lombok:1.18.26'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.26'
 }
 
 test {

docker-compose-mongo.yml

@@ -0,0 +1,7 @@
+version: '3.9'
+services:
+  mongodb:
+    image: mongo:4.4.1
+    container_name: my_mongodb
+    ports:
+      - "27017:27017"

src/main/java/app/output/GameRepository.java

@@ -0,0 +1,14 @@
+package app.output;
+
+import domain.Game;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface GameRepository {
+    Game save(Game game);
+
+    Optional<Game> findById(String id);
+
+    List<Game> findAll();
+}

src/main/java/app/usecase/RollDiceUseCase.java

@@ -0,0 +1,54 @@
+package app.usecase;
+
+import app.output.GameRepository;
+import domain.Game;
+import domain.events.DomainEvent;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class RollDiceUseCase {
+    private final GameRepository gameRepository;
+
+    public void execute(Request request, Presenter presenter) {
+
+        // 查
+        Game game = findGame(request);
+
+        // 改
+        var events = game.rollDice(request.playerId, request.diceCount);
+
+        // 存
+        gameRepository.save(game);
+
+        // 推
+        presenter.present(events);
+
+    }
+
+    private Game findGame(Request request) {
+        String gameId = request.getGameId();
+        return gameRepository.findById(gameId).orElseThrow();
+    }
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class Request {
+        private String gameId;
+        private String playerId;
+        private int diceCount;
+    }
+
+    public interface Presenter {
+        void present(List<DomainEvent> events);
+    }
+
+}
+

src/main/java/domain/Game.java

@@ -3,23 +3,33 @@
 import domain.card.establishment.Bakery;
 import domain.card.establishment.IndustryColor;
 import domain.card.establishment.WheatField;
+import domain.card.landmark.TrainStation;
+import domain.events.DomainEvent;
+import domain.events.RollDiceEvent;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
 
 import java.util.List;
 
+@Builder
+@Data
+@AllArgsConstructor
 public class Game {
+    private String id;
     private final Bank bank;
     private final List<Player> players;
-    private final List<Dice> dices;
+    private final List<Dice> dices = List.of(new Dice(), new Dice());
     private int currentDicePoint;
     private Player turnPlayer;
     private final Marketplace marketplace;
 
-    public Game(Bank bank, List<Player> players, List<Dice> dices, Marketplace marketplace) {
+    public Game(Bank bank, List<Player> players, Marketplace marketplace) {
         this.bank = bank;
         this.players = players;
-        this.dices = dices;
         this.marketplace = marketplace;
     }
+
     public int getCurrentDicePoint() {
         return currentDicePoint;
     }
@@ -51,6 +61,7 @@ public void setUp() {
             bank.payCoin(3);
             player.addCardToHandCard(new Bakery());
             player.addCardToHandCard(new WheatField());
+            marketplace.initial();
         }
     }
 
@@ -93,4 +104,23 @@ public List<Player> getPlayersExcludeTurnPlayer() {
         return players.stream().filter(player -> !player.equals(turnPlayer)).toList();
     }
 
+    public List<DomainEvent> rollDice(String playerId, int diceCount) {
+        if (!playerId.equals(turnPlayer.getId())) {
+            throw new IllegalArgumentException("Turn player id is incorrect");
+        }
+
+        if ((diceCount > 1 && !turnPlayer.hasLandmarkFlipped(new TrainStation())) || diceCount > 2 || diceCount < 1) {
+            throw new IllegalArgumentException("Invalid quantity of dice");
+        }
+
+        currentDicePoint = 0;
+        for (int i = 0; i < diceCount; i++) {
+            var dice = dices.get(i);
+            dice.throwDice();
+            currentDicePoint += dice.getPoint();
+        }
+
+        var event = RollDiceEvent.builder().dicePoint(currentDicePoint).build();
+        return List.of(event);
+    }
 }

src/main/java/domain/HandCard.java

@@ -2,16 +2,29 @@
 
 import domain.card.Card;
 import domain.card.establishment.Establishment;
-import domain.card.landmark.*;
+import domain.card.landmark.AmusementPark;
+import domain.card.landmark.Landmark;
+import domain.card.landmark.RadioTower;
+import domain.card.landmark.ShoppingMall;
+import domain.card.landmark.TrainStation;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 public class HandCard {
-    private Player player;
-    private final List<Establishment> establishments = new ArrayList<>();
-    private final List<Landmark> landmarks = Arrays.asList(new TrainStation(), new ShoppingMall(), new AmusementPark(), new RadioTower());
+
+    private List<Establishment> establishments = new ArrayList<>();
+    private List<Landmark> landmarks = Arrays.asList(new TrainStation(), new ShoppingMall(), new AmusementPark(), new RadioTower());
+
+    public HandCard() {
+    }
+
+    public HandCard(List<Establishment> establishments, List<Landmark> landmarks) {
+        this.establishments = establishments;
+        this.landmarks = landmarks;
+    }
 
     public void addCardToHandCard(Establishment establishment) {
         establishments.add(establishment);
@@ -21,19 +34,30 @@ public void removeEstablishment(int index) {
         establishments.remove(index);
     }
 
-    public Card getHandCard(int index){
+    public Card getHandCard(int index) {
         if (index < 0 || index >= getLandmarks().size()) {
             throw new IllegalArgumentException();
         }
         return establishments.get(index);
     }
+
     public List<Establishment> getEstablishments() {
         return establishments;
     }
+
     public List<Landmark> getLandmarks() {
         return landmarks;
     }
-    public void setPlayer(Player player) {
-        this.player = player;
+
+    public void flipLandMark(Landmark card) {
+        landmarks
+                .stream()
+                .filter(l -> l.equals(card) && l.isFlipped() == false)
+                .findFirst()
+                .map(targetlandmark -> {
+                    targetlandmark.setFlipped(true);
+                    return targetlandmark;
+                })
+                .orElseThrow(() -> new NoSuchElementException("This LandMark has been flipped"));
     }
 }

src/main/java/domain/Marketplace.java

@@ -1,42 +1,57 @@
 package domain;
 
-import domain.card.Card;
-import domain.card.establishment.*;
-import domain.card.landmark.*;
+import domain.card.establishment.AppleOrchard;
+import domain.card.establishment.Bakery;
+import domain.card.establishment.BusinessCenter;
+import domain.card.establishment.Cafe;
+import domain.card.establishment.CheeseFactory;
+import domain.card.establishment.ConvenienceStore;
+import domain.card.establishment.Establishment;
+import domain.card.establishment.FamilyRestaurant;
+import domain.card.establishment.Forest;
+import domain.card.establishment.FruitAndVegetableMarket;
+import domain.card.establishment.FurnitureFactory;
+import domain.card.establishment.Mine;
+import domain.card.establishment.Ranch;
+import domain.card.establishment.Stadium;
+import domain.card.establishment.TvStation;
+import domain.card.establishment.WheatField;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
 import org.apache.logging.log4j.util.Supplier;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
 public class Marketplace {
     private final int IMPORTANT_ESTABLISHMENT_QUANTITY = 4;
     private final int ESTABLISHMENT_QUANTITY = 6;
-    private List<Card> cards = new ArrayList<>();
+    @Builder.Default
+    private List<Establishment> establishments = new ArrayList<>();
 
-    public Marketplace() {
-        cards.addAll(generateCards(10, Bakery::new));
-        cards.addAll(generateCards(10, WheatField::new));
-        cards.addAll(generateCards(6, Cafe::new));
-        cards.addAll(generateCards(6, AppleOrchard::new));
-        cards.addAll(generateCards(6, CheeseFactory::new));
-        cards.addAll(generateCards(6, ConvenienceStore::new));
-        cards.addAll(generateCards(6, FamilyRestaurant::new));
-        cards.addAll(generateCards(6, Forest::new));
-        cards.addAll(generateCards(6, FruitAndVegetableMarket::new));
-        cards.addAll(generateCards(6, FurnitureFactory::new));
-        cards.addAll(generateCards(6, Mine::new));
-        cards.addAll(generateCards(6, Ranch::new));
+    public void initial() {
+        establishments.addAll(generateCards(10, Bakery::new));
+        establishments.addAll(generateCards(10, WheatField::new));
+        establishments.addAll(generateCards(6, Cafe::new));
+        establishments.addAll(generateCards(6, AppleOrchard::new));
+        establishments.addAll(generateCards(6, CheeseFactory::new));
+        establishments.addAll(generateCards(6, ConvenienceStore::new));
+        establishments.addAll(generateCards(6, FamilyRestaurant::new));
+        establishments.addAll(generateCards(6, Forest::new));
+        establishments.addAll(generateCards(6, FruitAndVegetableMarket::new));
+        establishments.addAll(generateCards(6, FurnitureFactory::new));
+        establishments.addAll(generateCards(6, Mine::new));
+        establishments.addAll(generateCards(6, Ranch::new));
 
-        cards.addAll(generateCards(4, Stadium::new));
-        cards.addAll(generateCards(4, TvStation::new));
-        cards.addAll(generateCards(4, BusinessCenter::new));
-
-        cards.addAll(generateCards(4, AmusementPark::new));
-        cards.addAll(generateCards(4, TrainStation::new));
-        cards.addAll(generateCards(4, RadioTower::new));
-        cards.addAll(generateCards(4, ShoppingMall::new));
+        establishments.addAll(generateCards(4, Stadium::new));
+        establishments.addAll(generateCards(4, TvStation::new));
+        establishments.addAll(generateCards(4, BusinessCenter::new));
     }
 
     private <T> List<T> generateCards(int amount, Supplier<T> cardSupplier) {
@@ -45,7 +60,7 @@ private <T> List<T> generateCards(int amount, Supplier<T> cardSupplier) {
                 .collect(Collectors.toList());
     }
 
-    public List<Card> getCards() {
-        return cards;
+    public List<Establishment> getEstablishments() {
+        return establishments;
     }
 }