Projekte/mdga/model/src/main/java/pp/mdga/game/Board.java

@@ -2,6 +2,7 @@
 
 import com.jme3.network.serializing.Serializable;
 
+import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -9,7 +10,7 @@
  */
 @Serializable
 public class Board {
-    private Map<Color, PlayerData> playerData;
+    private Map<Color, PlayerData> playerData = new HashMap<>();
     private final Node[] infield;
 
     /**

Projekte/mdga/model/src/main/java/pp/mdga/game/PlayerData.java

@@ -34,6 +34,7 @@ public class PlayerData {
      */
     public PlayerData(Color color) {
         homeNodes = new HomeNode[4];
+        pieces = new Piece[4];
         waitingArea = new Piece[4];
         for (int i = 0; i < 4; i++) {
             homeNodes[i] = new HomeNode();

Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/GameState.java

@@ -25,9 +25,9 @@ public class GameState extends ServerState {
      * Create GameState states.
      */
     private GameAutomatonState currentState;
-    private final GameAutomatonState determineStartPlayerState;
+    private final DetermineStartPlayerState determineStartPlayerState;
-    private final GameAutomatonState animationState;
+    private final AnimationState animationState;
-    private final GameAutomatonState turnState;
+    private final TurnState turnState;
 
     /**
      * Constructor.
@@ -122,27 +122,27 @@ public GameAutomatonState getCurrentState() {
     /**
      * This method will be used to return determineStartPlayerState attribute of GameState class.
      *
-     * @return determineStartPlayerState as a GameAutomatonState object.
+     * @return determineStartPlayerState as a DetermineStartPlayerState object.
      */
-    public GameAutomatonState getDetermineStartPlayerState() {
+    public DetermineStartPlayerState getDetermineStartPlayerState() {
         return this.determineStartPlayerState;
     }
 
     /**
      * This method will be used to return animationState attribute of GameState class.
      *
-     * @return animationState as a GameAutomatonState object.
+     * @return animationState as a AnimationState object.
      */
-    public GameAutomatonState getAnimationState() {
+    public AnimationState getAnimationState() {
         return this.animationState;
     }
 
     /**
      * This method will be used to return turnState attribute of GameState class.
      *
-     * @return turnState as a GameAutomatonState object.
+     * @return turnState as a TurnState object.
      */
-    public GameAutomatonState getTurnState() {
+    public TurnState getTurnState() {
         return this.turnState;
     }
 

Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/DetermineStartPlayerState.java

@@ -2,12 +2,14 @@
 
 import pp.mdga.game.Player;
 import pp.mdga.message.client.RequestDieMessage;
+import pp.mdga.message.server.ActivePlayerMessage;
 import pp.mdga.message.server.DieMessage;
 import pp.mdga.server.ServerGameLogic;
 import pp.mdga.server.automaton.GameState;
-import pp.mdga.server.automaton.game.turn.RollDiceState;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -21,7 +23,8 @@ public class DetermineStartPlayerState extends GameAutomatonState {
     /**
      * Create DetermineStartPlayerState attributes.
      */
-    private Map<Player, Integer> diceResults = new HashMap<>();
+    private Map<Integer, Integer> diceResults = new HashMap<>();
+    private List<Integer> playersHaveToRoll = new ArrayList<>();
 
     /**
      * Constructs a server state of the specified game logic.
@@ -36,6 +39,9 @@ public DetermineStartPlayerState(GameState gameAutomaton, ServerGameLogic logic)
     @Override
     public void enter() {
         LOGGER.log(System.Logger.Level.DEBUG, "Entered DetermineStartPlayerState state.");
+        for (Map.Entry<Integer, Player> entry: this.logic.getGame().getPlayers().entrySet()) {
+            this.playersHaveToRoll.add(entry.getKey());
+        }
     }
 
     @Override
@@ -53,23 +59,26 @@ public void exit() {
     @Override
     public void received(RequestDieMessage msg, int from) {
         int roll = this.logic.getGame().getDie().shuffle();
-        this.diceResults.put(this.logic.getGame().getPlayerById(from), roll);
+        this.diceResults.put(from, roll);
+        int maximumRoll = 0;
         if (this.diceResults.size() == this.logic.getGame().getPlayers().size()) {
-            Map<Integer, Long> frequencyMap = diceResults.values().stream()
+            for (Map.Entry<Integer, Integer> entry: this.diceResults.entrySet()) {
-                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+                if (maximumRoll == 0) {
-            Map.Entry<Integer, Long> result = frequencyMap.entrySet().stream()
+                    maximumRoll = this.diceResults.get(entry.getKey());
-                .max(Map.Entry.comparingByKey())
+                } else if (maximumRoll < entry.getValue()) {
-                .orElseThrow(() -> new IllegalStateException("Die Map ist leer"));
+                    maximumRoll = entry.getValue();
+                } else {
+                    this.playersHaveToRoll.remove(entry.getKey());
                 }
-        this.logic.getServerSender().send(from, new DieMessage(roll));
             }
 
-    /**
+            if (this.playersHaveToRoll.size() == 1) {
-     * This method will be used to return diceResults attribute of DetermineStartPlayerState class.
+                this.logic.getServerSender().broadcast(new ActivePlayerMessage(this.logic.getGame().getPlayerById(this.playersHaveToRoll.get(0)).getColor()));
-     *
+            } else {
-     * @return diceResults as a Map combing Player objects and Integers.
+                for (Integer id: this.playersHaveToRoll) {
-     */
+                    this.logic.getServerSender().send(id, new DieMessage(roll));
-    public Map<Player, Integer> getDiceResults() {
+                }
-        return this.diceResults;
+            }
+        }
     }
 }