minor changes to the server state automaton

Projekte/mdga/client/src/main/java/pp/mdga/client/server/MdgaServer.java

@@ -1,14 +1,11 @@
 package pp.mdga.client.server;
 
-import com.jme3.network.ConnectionListener;
+import com.jme3.network.*;
-import com.jme3.network.HostedConnection;
-import com.jme3.network.Message;
-import com.jme3.network.MessageListener;
-import com.jme3.network.Network;
-import com.jme3.network.Server;
 import com.jme3.network.serializing.Serializer;
 import pp.mdga.game.Game;
 import pp.mdga.game.Player;
+import pp.mdga.message.client.*;
+import pp.mdga.message.server.ServerMessage;
 import pp.mdga.server.ServerGameLogic;
 import pp.mdga.server.ServerSender;
 
@@ -16,6 +13,7 @@
 import java.io.IOException;
 import java.lang.System.Logger;
 import java.lang.System.Logger.Level;
+import java.util.Map;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.logging.LogManager;
@@ -53,7 +51,7 @@ public static void main(String[] args) {
      */
     public MdgaServer() {
         LOGGER.log(Level.INFO, "Creating MdgaServer"); //NON-NLS
-        logic = new ServerGameLogic(new Game(), this);
+        logic = new ServerGameLogic(this, new Game());
     }
 
     public void run() {
@@ -92,14 +90,14 @@ private void initializeSerializables() {
         Serializer.registerClass(ClientStartGame.class);
         Serializer.registerClass(DeselectTSK.class);
         Serializer.registerClass(ForceContinueGame.class);
-        Serializer.registerClass(ForceStartGame.class);
+        Serializer.registerClass(StartGame.class);
         Serializer.registerClass(JoinServer.class);
         Serializer.registerClass(LeaveGame.class);
         Serializer.registerClass(LobbyNotReady.class);
         Serializer.registerClass(LobbyReady.class);
         Serializer.registerClass(NoPowerCard.class);
         Serializer.registerClass(RequestBriefing.class);
-        Serializer.registerClass(RequestDice.class);
+        Serializer.registerClass(RequestDie.class);
         Serializer.registerClass(RequestMove.class);
         Serializer.registerClass(RequestPlayCard.class);
         Serializer.registerClass(SelectCard.class);
@@ -147,7 +145,7 @@ private void registerListeners() {
         myServer.addMessageListener(this, LobbyReady.class);
         myServer.addMessageListener(this, NoPowerCard.class);
         myServer.addMessageListener(this, RequestBriefing.class);
-        myServer.addMessageListener(this, RequestDice.class);
+        myServer.addMessageListener(this, RequestDie.class);
         myServer.addMessageListener(this, RequestMove.class);
         myServer.addMessageListener(this, RequestPlayCard.class);
         myServer.addMessageListener(this, SelectCard.class);
@@ -156,32 +154,42 @@ private void registerListeners() {
         myServer.addConnectionListener(this);
     }
 
-    @Override
+
-    public void messageReceived(HostedConnection source, Message message) {
+    public void messageReceived(HostedConnection source, ClientMessage message) {
         LOGGER.log(Level.INFO, "message received from {0}: {1}", source.getId(), message); //NON-NLS
-        if (message instanceof ClientMessage clientMessage)
+        pendingMessages.add(new ReceivedMessage(message, source.getId()));
-            pendingMessages.add(new ReceivedMessage(clientMessage, source.getId()));
     }
 
     @Override
     public void connectionAdded(Server server, HostedConnection hostedConnection) {
         LOGGER.log(Level.INFO, "new connection {0}", hostedConnection); //NON-NLS
-        logic.addPlayer(hostedConnection.getId());
+        // ToDo: Synchronize data between server and client.
+        logic.getGame().addPlayer(hostedConnection.getId(), new Player());
     }
 
     @Override
     public void connectionRemoved(Server server, HostedConnection hostedConnection) {
         LOGGER.log(Level.INFO, "connection closed: {0}", hostedConnection); //NON-NLS
-        final Player player = logic.getPlayerById(hostedConnection.getId());
+        final Player player = logic.getGame().getPlayerById(hostedConnection.getId());
         if (player == null)
             LOGGER.log(Level.INFO, "closed connection does not belong to an active player"); //NON-NLS
         else { //NON-NLS
             LOGGER.log(Level.INFO, "closed connection belongs to {0}", player); //NON-NLS
-            exit(0);
+            // exit(0);
+            this.handleDisconnect(hostedConnection.getId());
         }
     }
 
-    private void exit(int exitValue) { //NON-NLS
+    /**
+     * This method will be used to handle unintentional disconnections from players.
+     *
+     * @param id as the id of the disconnected player.
+     */
+    public void handleDisconnect(int id) {
+        this.logic.received(new Disconnected(), id);
+    }
+
+    public void exit(int exitValue) { //NON-NLS
         LOGGER.log(Level.INFO, "close request"); //NON-NLS
         if (myServer != null)
             for (HostedConnection client : myServer.getConnections()) //NON-NLS
@@ -206,4 +214,16 @@ public void send(int id, ServerMessage message) {
         else
             LOGGER.log(Level.ERROR, "there is no connection with id={0}", id); //NON-NLS
     }
+
+    /**
+     * This method will be used to send the given message parameter to all connected players which are saved inside the
+     * players attribute of Game class.
+     *
+     * @param message as the message which will be sent to all players as a ServerMessage.
+     */
+    public void broadcast(ServerMessage message) {
+        for (Map.Entry<Integer, Player> entry: this.logic.getGame().getPlayers().entrySet()) {
+            this.send(entry.getValue().getId(), message);
+        }
+    }
 }

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

@@ -11,7 +11,6 @@ public class Game {
     /**
      * Constants.
      */
-    public static final int MAX_PLAYERS = 4;
     public static final int AMOUNT_OF_TURBO_CARDS = 16;
     public static final int AMOUNT_OF_SHIELD_AND_SWAP_CARDS = 12;
 
@@ -27,7 +26,6 @@ public class Game {
     private Board board;
     private Color activeColor;
     private final ArrayList<Observer> observers = new ArrayList<>();
-    private Player currentPlayer;
     private boolean allRanked = false;
     private boolean movablePieces = false;
     private boolean allReady = false;
@@ -104,7 +102,13 @@ public Player getPlayerById(int id) {
         return this.players.get(id);
     }
 
-    public Player getCurrentPlayer(Color color) {
+    /**
+     * This method will be used to the get the player depending on the given color parameter.
+     *
+     * @param color as the color of the player as a Color enumeration.
+     * @return the player with the given color as a Player object.
+     */
+    public Player getPlayerByColor(Color color) {
         for (Map.Entry<Integer, Player> entry : this.players.entrySet()) {
             if (entry.getValue().getColor() == color) {
                 return entry.getValue();

Projekte/mdga/model/src/main/java/pp/mdga/message/client/ClientInterpreter.java

@@ -20,7 +20,6 @@ public interface ClientInterpreter {
      */
     void received(DeselectTSK msg, int from);
 
-
     /**
      * Processes a received ForceStartGame message.
      *
@@ -61,6 +60,14 @@ public interface ClientInterpreter {
      */
     void received(LobbyReady msg, int from);
 
+    /**
+     * Processes a received Disconnected message.
+     *
+     * @param msg  the Disconnected message to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(Disconnected msg, int from);
+
     /**
      * Processes a received RequestBriefing message.
      *
@@ -70,12 +77,12 @@ public interface ClientInterpreter {
     void received(RequestBriefing msg, int from);
 
     /**
-     * Processes a received RequestDice message.
+     * Processes a received RequestDie message.
      *
-     * @param msg  the RequestDice message to be processed
+     * @param msg  the RequestDie message to be processed
      * @param from the connection ID from which the message was received
      */
-    void received(RequestDice msg, int from);
+    void received(RequestDie msg, int from);
 
     /**
      * Processes a received RequestMove message.
@@ -140,12 +147,4 @@ public interface ClientInterpreter {
      * @param from the connection ID from which the message was received
      */
     void received(SelectedPieces msg, int from);
-
-    /**
-     * Processes a received disconnect message.
-     *
-     * @param msg the disconnect message to be processed
-     * @param from the connection ID from which the message was received
-     */
-    void received(Disconnected msg, int from);
 }

Projekte/mdga/model/src/main/java/pp/mdga/message/client/RequestDie.java

@@ -6,11 +6,11 @@
  * A message sent by a client to request a die roll.
  */
 @Serializable
-public class RequestDice extends ClientMessage {
+public class RequestDie extends ClientMessage {
     /**
-     * Constructs a new RequestDice instance.
+     * Constructs a new RequestDie instance.
      */
-    public RequestDice() {
+    public RequestDie() {
         super();
     }
 
@@ -21,7 +21,7 @@ public RequestDice() {
      */
     @Override
     public String toString() {
-        return "RequestDice{}";
+        return "RequestDie{}";
     }
 
     /**

Projekte/mdga/model/src/main/java/pp/mdga/message/server/ServerInterpreter.java

@@ -193,4 +193,11 @@ public interface ServerInterpreter {
      * @param msg the WaitPiece message received
      */
     void received(WaitPiece msg);
+
+    /**
+     * Handles a Spectator message received from the server.
+     *
+     * @param msg the Spectator message received.
+     */
+    void received(Spectator msg);
 }

Projekte/mdga/model/src/main/java/pp/mdga/message/server/Spectator.java

@@ -0,0 +1,32 @@
+package pp.mdga.message.server;
+
+/**
+ *
+ */
+public class Spectator extends ServerMessage {
+    /**
+     * Construc
+     */
+    public Spectator() {
+        super();
+    }
+
+    /**
+     *
+     * @param interpreter the visitor to process this message
+     */
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String getInfoTextKey() {
+        return "";
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/Ceremony.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class Ceremony extends ServerState {
-    public Ceremony(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/ChoosePiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class ChoosePiece extends Turn {
-    public ChoosePiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/ChoosePieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class ChoosePieceState extends TurnState {
+    public ChoosePieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/DetermineStartPlayer.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class DetermineStartPlayer extends Game {
-    public DetermineStartPlayer(ServerGameLogic logic) {
-        super(logic);
-    }
-}

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

@@ -0,0 +1,9 @@
+package pp.mdga.server;
+
+import pp.mdga.server.automaton.GameState;
+
+public class DetermineStartPlayerState extends GameState {
+    public DetermineStartPlayerState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/FirstRoll.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class FirstRoll extends RollDice {
-    public FirstRoll(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/FirstRollStateState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class FirstRollStateState extends RollDiceState {
+    public FirstRollStateState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/Interrupt.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class Interrupt extends ServerState {
-    public Interrupt(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/Lobby.java

@@ -1,14 +0,0 @@
-package pp.mdga.server;
-
-public class Lobby extends ServerState {
-
-
-    /**
-     * Constructs a server state of the specified game logic.
-     *
-     * @param logic the game logic
-     */
-    public Lobby(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/MovePiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class MovePiece extends Turn {
-    public MovePiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/MovePieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class MovePieceState extends TurnState {
+    public MovePieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/NoPiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class NoPiece extends ChoosePiece {
-    public NoPiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/NoPieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class NoPieceState extends ChoosePieceState {
+    public NoPieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/NoTurn.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class NoTurn extends ChoosePiece {
-    public NoTurn(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/NoTurnState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class NoTurnState extends ChoosePieceState {
+    public NoTurnState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/PowerCard.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class PowerCard extends Turn {
-    public PowerCard(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/PowerCardState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class PowerCardState extends TurnState {
+    public PowerCardState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/RollDice.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class RollDice extends Turn {
-    public RollDice(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/RollDiceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class RollDiceState extends TurnState {
+    public RollDiceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/SecondRoll.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class SecondRoll extends RollDice {
-    public SecondRoll(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/SecondRollState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class SecondRollState extends RollDiceState {
+    public SecondRollState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/SelectPiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class SelectPiece extends ChoosePiece {
-    public SelectPiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/SelectPieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class SelectPieceState extends ChoosePieceState {
+    public SelectPieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/ServerGameLogic.java

@@ -2,128 +2,215 @@
 
 import pp.mdga.game.Game;
 import pp.mdga.message.client.*;
-import pp.mdga.message.server.NoTurn;
+import pp.mdga.server.automaton.*;
-import pp.mdga.message.server.StartPiece;
 
 import java.lang.System.Logger;
 
+/**
+ *
+ */
 public class ServerGameLogic implements ClientInterpreter  {
+    /**
+     * Constants.
+     */
     private static final Logger LOGGER = System.getLogger(ServerGameLogic.class.getName());
 
+    /**
+     *
+     */
     private final ServerSender serverSender;
-
     private final Game game;
 
-    private final ServerState state;
+    /**
-
+     * States
-    private final ServerState lobby = new Lobby(this);
+     */
-    private final ServerState game = new Game(this);
+    private ServerState currentState;
-    private final ServerState interrupt = new Interrupt(this);
+    private final ServerState lobbyState;
-    private final ServerState ceremony = new Ceremony(this);
+    private final ServerState gameState;
-    private final ServerState turn = new Turn(this);
+    private final ServerState interruptState;
-    private final ServerState determineStartPlayer = new DetermineStartPlayer(this);
+    private final ServerState ceremonyState;
-    private final ServerState rollDice = new RollDice(this);
-    private final ServerState powerCard = new PowerCard(this);
-    private final ServerState movePiece = new MovePiece(this);
-    private final ServerState choosePiece = new ChoosePiece(this);
-    private final ServerState firstRoll = new FirstRoll(this);
-    private final ServerState secondRoll = new SecondRoll(this);
-    private final ServerState thirdRoll = new ThirdRoll(this);
-    private final ServerState noPiece = new NoPiece(this);
-    private final ServerState noTurn = new NoTurn(this);
-    private final ServerState waitingPiece = new WaitingPiece(this);
-    private final ServerState startPiece = new StartPiece(this);
-    private final ServerState selectPiece = new SelectPiece(this);
 
+    /**
+     * Constructor.
+     *
+     * @param serverSender
+     * @param game
+     */
     public ServerGameLogic(ServerSender serverSender, Game game) {
         this.serverSender = serverSender;
         this.game = game;
-        this.state = lobby;
+        this.lobbyState = new LobbyState(this);
+        this.gameState = new GameState(this);
+        this.interruptState = new InterruptState(this);
+        this.ceremonyState = new CeremonyState(this);
+        this.currentState = this.lobbyState;
     }
 
 
     @Override
     public void received(AnimationEnd msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(DeselectTSK msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(StartGame msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(JoinServer msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(LeaveGame msg, int from) {
-
+        this.currentState.received(msg, from);
-    }
-
-    @Override
-    public void received(LobbyNotReady msg, int from) {
-
     }
 
     @Override
     public void received(LobbyReady msg, int from) {
+        this.currentState.received(msg, from);
+    }
 
+    @Override
+    public void received(LobbyNotReady msg, int from) {
+        this.currentState.received(msg, from);
+    }
+
+    @Override
+    public void received(Disconnected msg, int from) {
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(RequestBriefing msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
-    public void received(RequestDice msg, int from) {
+    public void received(RequestDie msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(RequestMove msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(RequestPlayCard msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(SelectCard msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(SelectTSK msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(ForceContinueGame msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(ClientStartGame msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(NoPowerCard msg, int from) {
-
+        this.currentState.received(msg, from);
     }
 
     @Override
     public void received(SelectedPieces msg, int from) {
+        this.currentState.received(msg, from);
+    }
 
+    /**
+     * This method will be used to return serverSender attribute of ServerGameLogic class.
+     *
+     * @return serverSender as a ServerSender object.
+     */
+    public ServerSender getServerSender() {
+        return this.serverSender;
+    }
+
+    /**
+     * This method will be used to return game attribute of ServerGameLogic class.
+     *
+     * @return game as a Game object.
+     */
+    public Game getGame() {
+        return this.game;
+    }
+
+    /**
+     * This method will be used to return currentState attribute of ServerGameLogic class.
+     *
+     * @return currentState as a ServerState object.
+     */
+    public ServerState getCurrentState() {
+        return this.currentState;
+    }
+
+    /**
+     * This method will be used to return lobbyState attribute of ServerGameLogic class.
+     *
+     * @return lobbyState as a ServerState object.
+     */
+    public ServerState getLobbyState() {
+        return this.lobbyState;
+    }
+
+    /**
+     * This method will be used to return gameState attribute of ServerGameLogic class.
+     *
+     * @return gameState as a ServerState object.
+     */
+    public ServerState getGameState() {
+        return this.gameState;
+    }
+
+    /**
+     * This method will be used to return interruptState attribute of ServerGameLogic class.
+     *
+     * @return interruptState as a ServerState object.
+     */
+    public ServerState getInterruptState() {
+        return this.interruptState;
+    }
+
+    /**
+     * This method will be used to return ceremonyState attribute of ServerGameLogic class.
+     *
+     * @return ceremonyState as a ServerState object.
+     */
+    public ServerState getCeremonyState() {
+        return this.ceremonyState;
+    }
+
+    /**
+     * This method will be used to set currentState attribute of ServerGameLogic class to the given state parameter.
+     * In Addition, the currentState will be exited, changed and entered.
+     *
+     * @param state as the new currentState attribute as a ServerState object.
+     */
+    public void setCurrentState(ServerState state) {
+        if (this.currentState != null) {
+            this.currentState.exit();
+        }
+        this.currentState = state;
+        this.currentState.enter();
     }
 }

Projekte/mdga/model/src/main/java/pp/mdga/server/ServerSender.java

@@ -13,4 +13,12 @@ public interface ServerSender {
      * @param message the message
      */
     void send(int id, ServerMessage message);
+
+    /**
+     * This method will be used to send the given message parameter to all connected players which are saved inside the
+     * players attribute of Game class.
+     *
+     * @param message as the message which will be sent to all players as a ServerMessage.
+     */
+    void broadcast(ServerMessage message);
 }

Projekte/mdga/model/src/main/java/pp/mdga/server/ServerState.java

@@ -1,25 +0,0 @@
-package pp.mdga.server;
-
-/**
- * Defines the behavior and state transitions for the server-side game logic.
- * Different states of the game logic implement this interface to handle various game events and actions.
- */
-public class ServerState {
-    /**
-     * The server logic object.
-     */
-    private final ServerGameLogic logic;
-
-    /**
-     * Constructs a server state of the specified game logic.
-     *
-     * @param logic the game logic
-     */
-    public ServerState(ServerGameLogic logic) {
-        this.logic = logic;
-    }
-
-
-
-
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/StartPiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class StartPiece extends ChoosePiece {
-    public StartPiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/StartPieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class StartPieceState extends ChoosePieceState {
+    public StartPieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/ThirdRoll.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class ThirdRoll extends RollDice {
-    public ThirdRoll(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/ThirdRollState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class ThirdRollState extends RollDiceState {
+    public ThirdRollState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/Turn.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class Turn extends Game {
-    public Turn(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/TurnState.java

@@ -0,0 +1,9 @@
+package pp.mdga.server;
+
+import pp.mdga.server.automaton.GameState;
+
+public class TurnState extends GameState {
+    public TurnState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

Projekte/mdga/model/src/main/java/pp/mdga/server/WaitingPiece.java

@@ -1,7 +0,0 @@
-package pp.mdga.server;
-
-public class WaitingPiece extends ChoosePiece {
-    public WaitingPiece(ServerGameLogic logic) {
-        super(logic);
-    }
-}

Projekte/mdga/model/src/main/java/pp/mdga/server/WaitingPieceState.java

@@ -0,0 +1,7 @@
+package pp.mdga.server;
+
+public class WaitingPieceState extends ChoosePieceState {
+    public WaitingPieceState(ServerGameLogic logic) {
+        super(logic);
+    }
+}

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

@@ -0,0 +1,33 @@
+package pp.mdga.server.automaton;
+
+import pp.mdga.server.ServerGameLogic;
+
+/**
+ *
+ */
+public class CeremonyState extends ServerState {
+    /**
+     * Constructor.
+     *
+     * @param logic as the server game logic which is the automaton as a ServerGameLogic object.
+     */
+    public CeremonyState(ServerGameLogic logic) {
+        super(logic);
+    }
+
+    /**
+     * This method will be used whenever this state will be entered.
+     */
+    @Override
+    public void enter() {
+        // ToDo: Close server.
+    }
+
+    /**
+     * This method will be used whenever this state will be exited.
+     */
+    @Override
+    public void exit() {
+
+    }
+}

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

@@ -0,0 +1,60 @@
+package pp.mdga.server.automaton;
+
+import pp.mdga.message.client.Disconnected;
+import pp.mdga.message.client.LeaveGame;
+import pp.mdga.message.server.PauseGame;
+import pp.mdga.server.ServerGameLogic;
+
+/**
+ *
+ */
+public class GameState extends ServerState {
+    /**
+     * Constructor.
+     *
+     * @param logic as the server game logic which is the automaton as a ServerGameLogic object.
+     */
+    public GameState(ServerGameLogic logic) {
+        super(logic);
+    }
+
+    /**
+     * This method will be used whenever this state will be entered.
+     */
+    @Override
+    public void enter() {
+
+    }
+
+    /**
+     * This method will be used whenever this state will be exited.
+     */
+    @Override
+    public void exit() {
+
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a Disconnected object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(Disconnected msg, int from) {
+        this.logic.getServerSender().broadcast(new PauseGame());
+        this.logic.setCurrentState(this.logic.getInterruptState());
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a LeaveGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(LeaveGame msg, int from) {
+        this.logic.getGame().updatePlayerActiveState(from, false);
+        if (this.logic.getGame().getNumberOfActivePlayers() == 1) {
+            this.logic.setCurrentState(this.logic.getCeremonyState());
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+package pp.mdga.server.automaton;
+
+import com.jme3.system.Timer;
+import pp.mdga.message.client.ForceContinueGame;
+import pp.mdga.message.server.ResumeGame;
+import pp.mdga.server.ServerGameLogic;
+
+/**
+ *
+ */
+public class InterruptState extends ServerState {
+    /**
+     * Attributes.
+     */
+    private Timer timer;
+
+    /**
+     * Constructor.
+     *
+     * @param logic as the server game logic which is the automaton as a ServerGameLogic object.
+     */
+    public InterruptState(ServerGameLogic logic) {
+        super(logic);
+    }
+
+    /**
+     * This method will be used whenever this state will be entered.
+     */
+    @Override
+    public void enter() {
+        // Create timer and connect signal.
+    }
+
+    /**
+     * This method will be used whenever this state will be exited.
+     */
+    @Override
+    public void exit() {
+
+    }
+
+    @Override
+    public void received(ForceContinueGame msg, int from) {
+        this.logic.getServerSender().broadcast(new ResumeGame());
+        this.logic.setCurrentState(this.logic.getGameState());
+    }
+}

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

@@ -0,0 +1,88 @@
+package pp.mdga.server.automaton;
+
+import pp.mdga.message.client.*;
+import pp.mdga.message.server.ServerStartGame;
+import pp.mdga.message.server.UpdateReady;
+import pp.mdga.message.server.UpdateTSK;
+import pp.mdga.server.ServerGameLogic;
+
+/**
+ *
+ */
+public class LobbyState extends ServerState {
+    /**
+     * Constructs a server state of the specified game logic.
+     *
+     * @param logic the game logic
+     */
+    public LobbyState(ServerGameLogic logic) {
+        super(logic);
+    }
+
+    /**
+     * This method will be used whenever this state will be entered.
+     */
+    @Override
+    public void enter() {
+
+    }
+
+    /**
+     * This method will be used whenever this state will be exited.
+     */
+    @Override
+    public void exit() {
+
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a SelectTSK object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(SelectTSK msg, int from) {
+        this.logic.getServerSender().broadcast(new UpdateTSK(from, msg.getColor()));
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a DeselectTSK object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(DeselectTSK msg, int from) {
+        this.logic.getServerSender().broadcast(new UpdateTSK(from, msg.getColor()));
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a LobbyReady object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(LobbyReady msg, int from) {
+        this.logic.getServerSender().broadcast(new UpdateReady(from, true));
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a LobbyNotReady object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(LobbyNotReady msg, int from) {
+        this.logic.getServerSender().broadcast(new UpdateReady(from, false));
+    }
+
+    /**
+     *
+     * @param msg  as the message which was sent by the player as a ForceStartGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    @Override
+    public void received(ForceStartGame msg, int from) {
+        this.logic.getServerSender().broadcast(new ServerStartGame());
+        this.logic.setCurrentState(this.logic.getGameState());
+    }
+}

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

@@ -0,0 +1,196 @@
+package pp.mdga.server.automaton;
+
+import pp.mdga.message.client.*;
+import pp.mdga.server.ServerGameLogic;
+
+/**
+ * Defines the behavior and state transitions for the server-side game logic.
+ * Different states of the game logic implement this interface to handle various game events and actions.
+ */
+public abstract class ServerState {
+    /**
+     * The server logic object.
+     */
+    protected final ServerGameLogic logic;
+
+    /**
+     * Constructs a server state of the specified game logic.
+     *
+     * @param logic the game logic
+     */
+    public ServerState(ServerGameLogic logic) {
+        this.logic = logic;
+    }
+
+    /**
+     * This method will be used whenever this state will be entered.
+     */
+    public abstract void enter();
+
+    /**
+     * This method will be used whenever this state will be exited.
+     */
+    public abstract void exit();
+
+    /**
+     * This method will be called whenever the server received an AnimationEnd message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a AnimationEnd object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(AnimationEnd msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received an DeselectTSK message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a DeselectTSK object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(DeselectTSK msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a StartGame message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a StartGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(StartGame msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a JoinServer message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a JoinServer object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(JoinServer msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received an LeaveGame message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a LeaveGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(LeaveGame msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a LobbyReady message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a LobbyReady object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(LobbyReady msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a LobbyNotReady message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a LobbyNotReady object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(LobbyNotReady msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a Disconnected message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a Disconnected object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(Disconnected msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a Briefing message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a Briefing object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(RequestBriefing msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a Die message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a Die object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(RequestDie msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a RequestMove message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a RequestMove object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(RequestMove msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a PlayCard message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a PlayCard object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(RequestPlayCard msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a SelectCard message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a SelectCard object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(SelectCard msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a SelectTSK message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a SelectTSK object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(SelectTSK msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a ForceContinueGame message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a ForceContinueGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(ForceContinueGame msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a ClientStartGame message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a ClientStartGame object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(ClientStartGame msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a NoPowerCard message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a NoPowerCard object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(NoPowerCard msg, int from) {}
+
+    /**
+     * This method will be called whenever the server received a SelectedPieces message.
+     * It will also get the client id of the player who send this message.
+     *
+     * @param msg  as the message which was sent by the player as a SelectedPieces object.
+     * @param from as the client id of the player as an Integer.
+     */
+    public void received(SelectedPieces msg, int from) {}
+}

Projekte/mdga/model/src/test/java/pp/mdga/client/Dialog/LobbyStateTest.java

@@ -6,7 +6,7 @@
 /**
  * this test-class tests the testcases T084-T095
  */
-public class LobbyTest {
+public class LobbyStateTest {
 
     @Before
     public void setUp() {

Projekte/mdga/model/src/test/java/pp/mdga/server/serverState/ServerStateTest.java

@@ -5,6 +5,11 @@
 import pp.mdga.game.Game;
 import pp.mdga.message.server.ServerMessage;
 import pp.mdga.server.*;
+import pp.mdga.server.automaton.CeremonyState;
+import pp.mdga.server.automaton.InterruptState;
+import pp.mdga.server.automaton.LobbyState;
+import pp.mdga.server.automaton.ServerAutomaton;
+
 import static org.junit.Assert.*;
 
 /**
@@ -46,25 +51,25 @@ public class ServerStateTest {
 
     //TODO
     private Animation animation;
-    private Ceremony ceremony;
+    private CeremonyState ceremonyState;
-    private ChoosePiece choosePiece;
+    private ChoosePieceState choosePieceState;
-    private DetermineStartPlayer determineStartPlayer;
+    private DetermineStartPlayerState determineStartPlayerState;
-    private FirstRoll firstRoll;
+    private FirstRollStateState firstRollState;
     private GameState gameState;
-    private Interrupt interrupt;
+    private InterruptState interruptState;
-    private Lobby lobby;
+    private LobbyState lobbyState;
-    private MovePiece movePiece;
+    private MovePieceState movePieceState;
-    private NoPiece noPiece;
+    private NoPieceState noPiece;
-    private NoTurn noTurn;
+    private NoTurnState noTurnState;
     private PlayPowerCard playPowerCard;
-    private PowerCard powerCard;
+    private PowerCardState powerCardState;
-    private RollDice rollDice;
+    private RollDiceState rollDiceState;
-    private SecondRoll secondRoll;
+    private SecondRollState secondRoll;
-    private SelectPiece selectPiece;
+    private SelectPieceState selectPiece;
-    private StartPiece startPiece;
+    private StartPieceState startPiece;
-    private ThirdRoll thirdRoll;
+    private ThirdRollState thirdRoll;
-    private Turn turn;
+    private TurnState turnState;
-    private WaitingPiece waitingPiece;
+    private WaitingPieceState waitingPiece;
 
     /**
      * TODO
@@ -115,36 +120,36 @@ public void send(int id, ServerMessage msg) {
         from = 1234;
         fromHost = 2345;
 
-        choosePieceStateMachine = choosePiece.getChoosePieceMachine();
+        choosePieceStateMachine = choosePieceState.getChoosePieceMachine();
-        rollDiceMachine = rollDice.getRollDicemachine();
+        rollDiceMachine = rollDiceState.getRollDicemachine();
-        turnStateMachine = turn.getTurnStatemachine();
+        turnStateMachine = turnState.getTurnStatemachine();
         serverAutomaton = logic.getServerAutomaton();
         gameStateMachine = gameState.getGameStatemachine();
 
-        thirdRoll = new ThirdRoll(rollDiceMachine, logic);
+        thirdRoll = new ThirdRollState(rollDiceMachine, logic);
-        secondRoll = new SecondRoll(rollDiceMachine, logic);
+        secondRoll = new SecondRollState(rollDiceMachine, logic);
-        firstRoll = new FirstRoll(rollDiceMachine, logic);
+        firstRollState = new FirstRollStateState(rollDiceMachine, logic);
 
-        noPiece = new NoPiece(choosePieceStateMachine, logic);
+        noPiece = new NoPieceState(choosePieceStateMachine, logic);
-        noTurn = new NoTurn(choosePieceStateMachine, logic);
+        noTurnState = new NoTurnState(choosePieceStateMachine, logic);
-        waitingPiece = new WaitingPiece(choosePieceStateMachine, logic);
+        waitingPiece = new WaitingPieceState(choosePieceStateMachine, logic);
-        startPiece = new StartPiece(choosePieceStateMachine, logic);
+        startPiece = new StartPieceState(choosePieceStateMachine, logic);
-        selectPiece = new SelectPiece(choosePieceStateMachine, logic);
+        selectPiece = new SelectPieceState(choosePieceStateMachine, logic);
 
-        powerCard = new PowerCard(turnStateMachine, logic);
+        powerCardState = new PowerCardState(turnStateMachine, logic);
         playPowerCard = new PlayPowerCard(turnStateMachine, logic);
-        rollDice = new RollDice(turnStateMachine, logic);
+        rollDiceState = new RollDiceState(turnStateMachine, logic);
-        choosePiece = new ChoosePiece(turnStateMachine, logic);
+        choosePieceState = new ChoosePieceState(turnStateMachine, logic);
-        movePiece = new MovePiece(turnStateMachine, logic);
+        movePieceState = new MovePieceState(turnStateMachine, logic);
 
-        determineStartPlayer = new DetermineStartPlayer(gameStateMachine, logic);
+        determineStartPlayerState = new DetermineStartPlayerState(gameStateMachine, logic);
-        turn = new Turn(gameStateMachine, logic);
+        turnState = new TurnState(gameStateMachine, logic);
         animation = new Animation(gameStateMachine, logic);
 
-        lobby = new Lobby(serverAutomaton, logic);
+        lobbyState = new LobbyState(serverAutomaton, logic);
         gameState = new GameState(serverAutomaton, logic);
-        ceremony = new Ceremony(serverAutomaton, logic);
+        ceremonyState = new CeremonyState(serverAutomaton, logic);
-        interrupt = new Interrupt(serverAutomaton, logic, gameState);
+        interruptState = new InterruptState(serverAutomaton, logic, gameState);
     }
 
     /**
@@ -152,7 +157,7 @@ public void send(int id, ServerMessage msg) {
      */
     @Test
     public void testInitialStateServerState() {
-        assertTrue(serverAutomaton.getState() instanceof Lobby);
+        assertTrue(serverAutomaton.getState() instanceof LobbyState);
     }
 
     /**
@@ -162,8 +167,8 @@ public void testInitialStateServerState() {
     @Test
     public void testLobbyToDetermineStartPlayer() {
         //sends the server in the lobby-state
-        serverAutomaton.gotoState(lobby);
+        serverAutomaton.gotoState(lobbyState);
-        assertTrue(serverAutomaton.getState() instanceof Lobby);
+        assertTrue(serverAutomaton.getState() instanceof LobbyState);
 
         //sends the startGame message from the Host to the server
         logic.received(clientStartGame, from);
@@ -172,7 +177,7 @@ public void testLobbyToDetermineStartPlayer() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
         GameState gameState1 = (GameState) serverAutomaton.getState();//Todo erzeuge state
         GameStateMachine gameStateMachine1 = gameState.getGameStateMachine();
-        assertTrue(gameStateMachine1.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine1.getState() instanceof DetermineStartPlayerState);
     }
 
     /**
@@ -181,8 +186,8 @@ public void testLobbyToDetermineStartPlayer() {
     @Test
     public void testStayInLobby() {
         //sends the server in the lobby-state
-        serverAutomaton.gotoState(lobby);
+        serverAutomaton.gotoState(lobbyState);
-        assertTrue(serverAutomaton.getState() instanceof Lobby);
+        assertTrue(serverAutomaton.getState() instanceof LobbyState);
 
         //TODO logic gets all messages
         logic.received(animationEnd, from);
@@ -203,7 +208,7 @@ public void testStayInLobby() {
         logic.received(selectTSK, from);
 
         //tests if Server is still in Lobby
-        assertTrue(serverAutomaton.getState() instanceof Lobby);
+        assertTrue(serverAutomaton.getState() instanceof LobbyState);
     }
 
     /**
@@ -218,7 +223,7 @@ public void testServerGameSubStatesToInterrupt() {
         //TODO create interrupt
 
         //tests if the server is in the Interrupt-state
-        assertTrue(serverAutomaton.getState() instanceof Interrupt);
+        assertTrue(serverAutomaton.getState() instanceof InterruptState);
     }
 
     /**
@@ -233,7 +238,7 @@ public void testServerGameToCeremony() {
         //Todo game is finished
 
         //tests if the server is in the Ceremony-state
-        assertTrue(serverAutomaton.getState() instanceof Ceremony);
+        assertTrue(serverAutomaton.getState() instanceof CeremonyState);
     }
 
     /**
@@ -242,8 +247,8 @@ public void testServerGameToCeremony() {
     @Test
     public void testInterruptToGameContinue() {
         //sends the server in the Interrupt-State
-        serverAutomaton.gotoState(interrupt);
+        serverAutomaton.gotoState(interruptState);
-        assertTrue(serverAutomaton.getState() instanceof Interrupt);
+        assertTrue(serverAutomaton.getState() instanceof InterruptState);
 
         //sends the continue-message to the server
         logic.received(forceContinueGame, from);
@@ -258,8 +263,8 @@ public void testInterruptToGameContinue() {
     @Test
     public void testInterruptToGameReconnect() {
         //sends the server in the Interrupt-State
-        serverAutomaton.gotoState(interrupt);
+        serverAutomaton.gotoState(interruptState);
-        assertTrue(serverAutomaton.getState() instanceof Interrupt);
+        assertTrue(serverAutomaton.getState() instanceof InterruptState);
 
         //todo implement the timer
 
@@ -273,8 +278,8 @@ public void testInterruptToGameReconnect() {
     @Test
     public void testInterruptToGameTimer() {
         //sends the server in the Interrupt-State
-        serverAutomaton.gotoState(interrupt);
+        serverAutomaton.gotoState(interruptState);
-        assertTrue(serverAutomaton.getState() instanceof Interrupt);
+        assertTrue(serverAutomaton.getState() instanceof InterruptState);
 
         //Todo implement the timer
 
@@ -301,14 +306,14 @@ public void testDetermineStartPlayerToDetermineStartPlayer1() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in DSP-state
-        gameStateMachine.gotoState(determineStartPlayer);
+        gameStateMachine.gotoState(determineStartPlayerState);
-        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayerState);
 
         //TODO sends messages to the server
 
         //tests if the server is still in DSP-state
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayerState);
     }
 
     /**
@@ -321,14 +326,14 @@ public void testDetermineStartPlayerToDetermineStartPlayer2() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in DSP-state
-        gameStateMachine.gotoState(determineStartPlayer);
+        gameStateMachine.gotoState(determineStartPlayerState);
-        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayerState);
 
         //TODO sends messages 2 RequestDiceMessage, die gleich geränkt werden to the server
 
         //tests if the server is still in DSP-state
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayerState);
     }
 
     /**
@@ -341,8 +346,8 @@ public void testDetermineStartPlayerToAnimation() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in DSP-state
-        gameStateMachine.gotoState(determineStartPlayer);
+        gameStateMachine.gotoState(determineStartPlayerState);
-        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayer);
+        assertTrue(gameStateMachine.getState() instanceof DetermineStartPlayerState);
 
         //TODO sends messages 2 RequestDiceMessage, die ungleich geränkt werden, sodass der server weitergeht
 
@@ -375,10 +380,10 @@ public void testAnimationToPowerCard() {
 
         //tests if the server is in the PowerCard-state
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        Turn turn1 = (Turn) gameStateMachine.getState();
+        TurnState turnState1 = (TurnState) gameStateMachine.getState();
-        TurnStateMachine turnStateMachine = (TurnStateMachine) turn1.getTurnStateMachine();
+        TurnStateMachine turnStateMachine = (TurnStateMachine) turnState1.getTurnStateMachine();
-        assertTrue(turnStateMachine.getState() instanceof PowerCard);
+        assertTrue(turnStateMachine.getState() instanceof PowerCardState);
     }
 
     /**
@@ -392,8 +397,8 @@ public void testTurnToAnimation() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //todo set the turn finished and there are still two players left
 
@@ -413,13 +418,13 @@ public void testTurnToGameEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //todo set the turn finished and there is only one players left
 
         //tests if the server is in the end-state of game, Ceremony
-        assertTrue(serverAutomaton.getState() instanceof Ceremony);
+        assertTrue(serverAutomaton.getState() instanceof CeremonyState);
     }
 
     /**
@@ -433,19 +438,19 @@ public void testStayInPowerCard() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in PowerCard
-        turnStateMachine.gotoState(powerCard);
+        turnStateMachine.gotoState(powerCardState);
-        assertTrue(turnStateMachine.getState() instanceof PowerCard);
+        assertTrue(turnStateMachine.getState() instanceof PowerCardState);
 
         //Todo: receive messages which dont lead to a state change
 
         //tests if the server is in PowerCard
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof PowerCard);
+        assertTrue(turnStateMachine.getState() instanceof PowerCardState);
     }
 
     /**
@@ -459,18 +464,18 @@ public void testPowerCardToPlayPowerCard() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in PowerCard
-        turnStateMachine.gotoState(powerCard);
+        turnStateMachine.gotoState(powerCardState);
-        assertTrue(turnStateMachine.getState() instanceof PowerCard);
+        assertTrue(turnStateMachine.getState() instanceof PowerCardState);
 
         //todo
 
         //tests if the server is in PlayPowerCard
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
         assertTrue(turnStateMachine.getState() instanceof PlayPowerCard);
     }
 
@@ -485,8 +490,8 @@ public void testPlayPowerCardToRollDice() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in PowerCard
         turnStateMachine.gotoState(playPowerCard);
@@ -495,7 +500,7 @@ public void testPlayPowerCardToRollDice() {
         //receive first AnimationEndMessage from the host
         logic.received(animationEnd, fromHost);
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
         assertTrue(turnStateMachine.getState() instanceof PlayPowerCard);
 
         //receive second AnimationEndMessage
@@ -503,11 +508,11 @@ public void testPlayPowerCardToRollDice() {
 
         //tests if the server is in RollDice and in FirstRoll
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
-        RollDice rollDice = (RollDice) turnStateMachine.getState();
+        RollDiceState rollDiceState = (RollDiceState) turnStateMachine.getState();
-        RollDiceMachine rollDiceMachine1 = rollDice.getRollDiceStateMachine();
+        RollDiceMachine rollDiceMachine1 = rollDiceState.getRollDiceStateMachine();
-        assertTrue(rollDiceMachine1.getState() instanceof FirstRoll);
+        assertTrue(rollDiceMachine1.getState() instanceof FirstRollStateState);
     }
 
     /**
@@ -521,18 +526,18 @@ public void testChoosePieceToMovePiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //Todo ???
 
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof MovePiece);
+        assertTrue(turnStateMachine.getState() instanceof MovePieceState);
     }
 
     /**
@@ -546,12 +551,12 @@ public void testMovePieceToTurnEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in MovePiece
-        turnStateMachine.gotoState(movePiece);
+        turnStateMachine.gotoState(movePieceState);
-        assertTrue(turnStateMachine.getState() instanceof MovePiece);
+        assertTrue(turnStateMachine.getState() instanceof MovePieceState);
 
         //Todo no 6 was rolled, so the server looks, if there are 2 or less player are still in the game
         //TODO
@@ -569,21 +574,21 @@ public void testMovePieceToFirstRoll() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in MovePiece
-        turnStateMachine.gotoState(movePiece);
+        turnStateMachine.gotoState(movePieceState);
-        assertTrue(turnStateMachine.getState() instanceof MovePiece);
+        assertTrue(turnStateMachine.getState() instanceof MovePieceState);
 
         //Todo the player rolled a 6 and the player is not finished
 
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
-        RollDice rollDice = (RollDice) turnStateMachine.getState();
+        RollDiceState rollDiceState = (RollDiceState) turnStateMachine.getState();
-        RollDiceMachine rollDiceMachine1 = rollDice.getRollDiceStateMachine();
+        RollDiceMachine rollDiceMachine1 = rollDiceState.getRollDiceStateMachine();
-        assertTrue(rollDiceMachine1.getState() instanceof FirstRoll);
+        assertTrue(rollDiceMachine1.getState() instanceof FirstRollStateState);
     }
 
     /**
@@ -597,26 +602,26 @@ public void testFirstRollToRollDiceEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in FirstRoll
-        rollDiceMachine.gotoState(firstRoll);
+        rollDiceMachine.gotoState(firstRollState);
-        assertTrue(rollDiceMachine.getState() instanceof FirstRoll);
+        assertTrue(rollDiceMachine.getState() instanceof FirstRollStateState);
 
         //TODO 2 Möglichkeiten
 
         //tests if the server is in NoPiece of ChoosePiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        ChoosePiece choosePiece1 = (ChoosePiece) turnStateMachine.getState();
+        ChoosePieceState choosePieceState1 = (ChoosePieceState) turnStateMachine.getState();
-        ChoosePieceStateMachine choosePieceStateMachine = choosePiece1.getChoosePieceStateMachine();
+        ChoosePieceStateMachine choosePieceStateMachine = choosePieceState1.getChoosePieceStateMachine();
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
     }
 
     /**
@@ -630,24 +635,24 @@ public void testFirstRollToSecondRoll() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in FirstRoll
-        rollDiceMachine.gotoState(firstRoll);
+        rollDiceMachine.gotoState(firstRollState);
-        assertTrue(rollDiceMachine.getState() instanceof FirstRoll);
+        assertTrue(rollDiceMachine.getState() instanceof FirstRollStateState);
 
         //Todo player has no figures to move and had no 6
 
         //tests if the server is in the SecondRoll
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
-        assertTrue(rollDiceMachine.getState() instanceof SecondRoll);
+        assertTrue(rollDiceMachine.getState() instanceof SecondRollState);
     }
 
     /**
@@ -661,26 +666,26 @@ public void testSecondRollToRollDiceEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in SecondRoll
         rollDiceMachine.gotoState(secondRoll);
-        assertTrue(rollDiceMachine.getState() instanceof SecondRoll);
+        assertTrue(rollDiceMachine.getState() instanceof SecondRollState);
 
         //Todo
 
         //tests if the server is in NoPiece of ChoosePiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        ChoosePiece choosePiece1 = (ChoosePiece) turnStateMachine.getState();
+        ChoosePieceState choosePieceState1 = (ChoosePieceState) turnStateMachine.getState();
-        ChoosePieceStateMachine choosePieceStateMachine = choosePiece1.getChoosePieceStateMachine();
+        ChoosePieceStateMachine choosePieceStateMachine = choosePieceState1.getChoosePieceStateMachine();
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
     }
 
     /**
@@ -694,24 +699,24 @@ public void testSecondRollToThirdRoll() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in SecondRoll
         rollDiceMachine.gotoState(secondRoll);
-        assertTrue(rollDiceMachine.getState() instanceof SecondRoll);
+        assertTrue(rollDiceMachine.getState() instanceof SecondRollState);
 
         //Todo player has no figures to move and had no 6
 
         //tests if the server is in the ThirdRoll
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
-        assertTrue(rollDiceMachine.getState() instanceof ThirdRoll);
+        assertTrue(rollDiceMachine.getState() instanceof ThirdRollState);
     }
 
     /**
@@ -725,26 +730,26 @@ public void testThirdRollToRollDiceEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in ThirdRoll
         rollDiceMachine.gotoState(thirdRoll);
-        assertTrue(rollDiceMachine.getState() instanceof ThirdRoll);
+        assertTrue(rollDiceMachine.getState() instanceof ThirdRollState);
 
         //Todo
 
         //tests if the server is in NoPiece of ChoosePiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        ChoosePiece choosePiece1 = (ChoosePiece) turnStateMachine.getState();
+        ChoosePieceState choosePieceState1 = (ChoosePieceState) turnStateMachine.getState();
-        ChoosePieceStateMachine choosePieceStateMachine = choosePiece1.getChoosePieceStateMachine();
+        ChoosePieceStateMachine choosePieceStateMachine = choosePieceState1.getChoosePieceStateMachine();
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
     }
 
     /**
@@ -758,16 +763,16 @@ public void testThirdRollToTurnEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the gameStateMachine in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the TurnStateMachine in RollDice
-        turnStateMachine.gotoState(rollDice);
+        turnStateMachine.gotoState(rollDiceState);
-        assertTrue(turnStateMachine.getState() instanceof RollDice);
+        assertTrue(turnStateMachine.getState() instanceof RollDiceState);
 
         //sends the RollDiceMachine in ThirdRoll
         rollDiceMachine.gotoState(thirdRoll);
-        assertTrue(rollDiceMachine.getState() instanceof ThirdRoll);
+        assertTrue(rollDiceMachine.getState() instanceof ThirdRollState);
 
         //Todo
     }
@@ -783,24 +788,24 @@ public void testNoPieceToWaitingPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in NoPiece
         choosePieceStateMachine.gotoState(noPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
 
         //TODO
 
         //tests if the server is in WaitingPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPieceState);
 
     }
 
@@ -815,24 +820,24 @@ public void testNoPieceToNoTurn() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in NoPiece
         choosePieceStateMachine.gotoState(noPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
 
         //TODO
 
         //tests if the server is in NoTurn
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoTurn);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoTurnState);
     }
 
     /**
@@ -846,16 +851,16 @@ public void testNoTurnToTurnEndState() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in NoTurn
-        choosePieceStateMachine.gotoState(noTurn);
+        choosePieceStateMachine.gotoState(noTurnState);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoTurn);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoTurnState);
 
         //TODO
     }
@@ -871,24 +876,24 @@ public void testStayInWaitingPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in WaitingPiece
         choosePieceStateMachine.gotoState(waitingPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPieceState);
 
         //TODO
 
         //tests if the server is in WaitingPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPieceState);
     }
 
     /**
@@ -902,16 +907,16 @@ public void testWaitingPieceToMovePiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in WaitingPiece
         choosePieceStateMachine.gotoState(waitingPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof WaitingPieceState);
 
         //TODO
     }
@@ -927,24 +932,24 @@ public void testNoPieceToSelectPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in NoPiece
         choosePieceStateMachine.gotoState(noPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
 
         //TODO
 
         //tests if the server is in SelectPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof SelectPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof SelectPieceState);
     }
 
     /**
@@ -958,24 +963,24 @@ public void testNoPieceToStartPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in NoPiece
         choosePieceStateMachine.gotoState(noPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof NoPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof NoPieceState);
 
         //TODO
 
         //tests if the server is in StartPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof StartPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof StartPieceState);
     }
 
     /**
@@ -989,24 +994,24 @@ public void testStayInSelectPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in SelectPiece
         choosePieceStateMachine.gotoState(selectPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof SelectPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof SelectPieceState);
 
         //TODO
 
         //tests if the server is in SelectPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof SelectPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof SelectPieceState);
     }
 
     /**
@@ -1020,16 +1025,16 @@ public void testSelectPieceToMovePiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in SelectPiece
         choosePieceStateMachine.gotoState(selectPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof SelectPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof SelectPieceState);
 
         //TODO
     }
@@ -1045,24 +1050,24 @@ public void testStayInStartPiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in StartPiece
         choosePieceStateMachine.gotoState(startPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof StartPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof StartPieceState);
 
         //TODO
 
         //tests if the server is in StartPiece
         assertTrue(serverAutomaton.getState() instanceof GameState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
-        assertTrue(choosePieceStateMachine.getState() instanceof StartPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof StartPieceState);
     }
 
     /**
@@ -1076,16 +1081,16 @@ public void testStartPieceToMovePiece() {
         assertTrue(serverAutomaton.getState() instanceof GameState);
 
         //sends the server in Turn
-        gameStateMachine.gotoState(turn);
+        gameStateMachine.gotoState(turnState);
-        assertTrue(gameStateMachine.getState() instanceof Turn);
+        assertTrue(gameStateMachine.getState() instanceof TurnState);
 
         //sends the server in ChoosePiece
-        turnStateMachine.gotoState(choosePiece);
+        turnStateMachine.gotoState(choosePieceState);
-        assertTrue(turnStateMachine.getState() instanceof ChoosePiece);
+        assertTrue(turnStateMachine.getState() instanceof ChoosePieceState);
 
         //sends the server in StartPiece
         choosePieceStateMachine.gotoState(startPiece);
-        assertTrue(choosePieceStateMachine.getState() instanceof StartPiece);
+        assertTrue(choosePieceStateMachine.getState() instanceof StartPieceState);
 
         //TODO
     }