Development

.gitignore

@@ -30,3 +30,6 @@ build/
 
 ### VS Code ###
 .vscode/
+
+### State Persistence ###
+data/

docker-compose.yml

@@ -3,4 +3,6 @@ services:
     image: ghcr.io/ss26-se2-codenames/backend:latest
     restart: unless-stopped
     ports:
-      - "53213:8080"
+      - "53213:8080"
+    volumes:
+      - ./data:/app/data

src/main/java/com/codenames/codenames/backend/chat/ChatController.java

@@ -1,67 +1,35 @@
 package com.codenames.codenames.backend.chat;
 
 import com.codenames.codenames.backend.lobby.services.LobbyService;
+import com.codenames.codenames.backend.utility.ChatMessageType;
 import com.codenames.codenames.backend.utility.Role;
 import com.codenames.codenames.backend.utility.Team;
-import com.codenames.codenames.backend.websocket.SessionRegistry;
 import org.springframework.messaging.handler.annotation.DestinationVariable;
 import org.springframework.messaging.handler.annotation.MessageMapping;
 import org.springframework.messaging.handler.annotation.Payload;
-import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
 import org.springframework.stereotype.Controller;
-
 /**
  * Controller for broadcasting client messages to the desired destination with STOMP.
  *
  * <p>The destination is based on the lobbyID or team parameters passed when the method is invoked.
  * The parameters are appended to the destination and broadcasted to all subscribers.
  */
+
 @Controller
 public class ChatController {
 
   private final ChatService chatService;
   private final LobbyService lobbyService;
-  private final SessionRegistry sessionRegistry;
 
   /**
    * Constructor for the ChatController.
    *
    * @param chatService the service used to validate and persist chat history
    */
   public ChatController(
-      ChatService chatService, LobbyService lobbyService, SessionRegistry sessionRegistry) {
+      ChatService chatService, LobbyService lobbyService) {
     this.chatService = chatService;
     this.lobbyService = lobbyService;
-    this.sessionRegistry = sessionRegistry;
-  }
-
-  /**
-   * Verifies the username of the sender and checks if they are sending the message to their own
-   * lobby before allowing them to send a message.
-   *
-   * @param headerAccessor the header accessor containing the session information of the sender
-   * @param targetLobbyId the actual lobby ID associated with the sender's session, used to verify
-   *     that they are sending the message to their own lobby
-   * @return the username if sender is verified, otherwise throws an exception
-   * @throws IllegalStateException if the username is null or if the sender is trying to send a
-   *     message to a lobby they are not in
-   */
-  private String getVerifiedUsername(
-      SimpMessageHeaderAccessor headerAccessor, String targetLobbyId) {
-    String sessionId = headerAccessor.getSessionId();
-    String realUsername = sessionRegistry.getUser(sessionId);
-    String realLobbyId = sessionRegistry.getLobby(sessionId);
-
-    if (realUsername == null) {
-      throw new IllegalStateException("Null username.");
-    }
-    if (targetLobbyId == null) {
-      throw new IllegalStateException("Null lobby ID.");
-    }
-    if (!targetLobbyId.equals(realLobbyId)) {
-      throw new IllegalStateException("Wrong lobby, user not in lobby " + realLobbyId);
-    }
-    return realUsername;
   }
 
   /**
@@ -72,18 +40,19 @@ private String getVerifiedUsername(
    */
   @MessageMapping("/chat/{lobbyId}")
   public void sendLobbyMessage(
-      @DestinationVariable String lobbyId,
-      @Payload ChatDto chatDto,
-      SimpMessageHeaderAccessor headerAccessor) {
-    String realUsername = getVerifiedUsername(headerAccessor, lobbyId);
-
-    // Create a new ChatDto with the verified username to prevent passing false username
-    ChatDto verifiedChatDto = new ChatDto(realUsername, chatDto.content(), chatDto.type());
+          @DestinationVariable String lobbyId,
+          @Payload ChatDto chatDto) {
+
+    ChatDto verifiedChatDto = new ChatDto(
+            chatDto.senderUsername(),
+            chatDto.content(),
+            ChatMessageType.CHAT
+    );
     chatService.processMessage(lobbyId, "LOBBY", "", verifiedChatDto);
   }
 
   /**
-   * Verifies the sender's name, lobbyID, and team before sending a message to the entire team.
+   * Verifies the sender's team and delegates message processing to {@link ChatService}.
    *
    * @param lobbyId the ID of the lobby the client is in
    * @param team the team the client is in (RED, BLUE)
@@ -93,25 +62,26 @@ public void sendLobbyMessage(
   public void sendTeamMessage(
       @DestinationVariable String lobbyId,
       @DestinationVariable Team team,
-      @Payload ChatDto chatDto,
-      SimpMessageHeaderAccessor headerAccessor) {
-    String realUsername = getVerifiedUsername(headerAccessor, lobbyId);
+      @Payload ChatDto chatDto) {
 
-    Team playerTeam = lobbyService.getPlayerTeam(realUsername, lobbyId);
+    Team playerTeam = lobbyService.getPlayerTeam(chatDto.senderUsername(), lobbyId);
     if (playerTeam != team) {
       throw new IllegalStateException("You are not on team " + team.name());
     }
 
-    ChatDto verifiedDto = new ChatDto(realUsername, chatDto.content(), chatDto.type());
+    ChatDto verifiedDto = new ChatDto(
+            chatDto.senderUsername(),
+            chatDto.content(),
+            ChatMessageType.CHAT
+    );
 
     String roomKey = "TEAM_" + team.name();
     String topicSuffix = "/" + team.name();
     chatService.processMessage(lobbyId, roomKey, topicSuffix, verifiedDto);
   }
 
   /**
-   * Verifies the sender's name, lobbyID, team and role sending a message to the operatives on the
-   * respective team.
+   * Verifies the sender's team and role and delegates message processing to {@link ChatService}.
    *
    * @param lobbyId the ID of the lobby the client is in
    * @param team the team the client is in (RED, BLUE)
@@ -121,19 +91,21 @@ public void sendTeamMessage(
   public void sendTeamOperativeMessage(
       @DestinationVariable String lobbyId,
       @DestinationVariable Team team,
-      @Payload ChatDto chatDto,
-      SimpMessageHeaderAccessor headerAccessor) {
-    String realUsername = getVerifiedUsername(headerAccessor, lobbyId);
+      @Payload ChatDto chatDto) {
 
-    Team playerTeam = lobbyService.getPlayerTeam(realUsername, lobbyId);
-    Role playerRole = lobbyService.getPlayerRole(realUsername, lobbyId);
+    Team playerTeam = lobbyService.getPlayerTeam(chatDto.senderUsername(), lobbyId);
+    Role playerRole = lobbyService.getPlayerRole(chatDto.senderUsername(), lobbyId);
 
     if (playerTeam != team || playerRole != Role.OPERATIVE) {
       throw new IllegalStateException(
           "You are either not an operative or are sending to the wrong team.");
     }
 
-    ChatDto verifiedDto = new ChatDto(realUsername, chatDto.content(), chatDto.type());
+    ChatDto verifiedDto = new ChatDto(
+            chatDto.senderUsername(),
+            chatDto.content(),
+            ChatMessageType.CHAT
+    );
 
     String roomKey = "OPERATIVE_" + team.name();
     String topicSuffix = "/" + team.name() + "/operative";

src/main/java/com/codenames/codenames/backend/controller/HealthController.java

@@ -0,0 +1,23 @@
+package com.codenames.codenames.backend.controller;
+
+import java.util.Map;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * Controller providing a simple health check endpoint to verify that the backend application is
+ * running.
+ */
+@RestController
+public class HealthController {
+
+  /**
+   * Returns the current health status of the backend.
+   *
+   * @return a map containing the application status
+   */
+  @GetMapping("/health")
+  public Map<String, String> health() {
+    return Map.of("status", "UP");
+  }
+}

src/main/java/com/codenames/codenames/backend/game/controller/GameSocketController.java

@@ -0,0 +1,114 @@
+package com.codenames.codenames.backend.game.controller;
+
+import com.codenames.codenames.backend.clue.Clue;
+import com.codenames.codenames.backend.game.dto.ClueMessage;
+import com.codenames.codenames.backend.game.dto.PassTurnMessage;
+import com.codenames.codenames.backend.game.dto.RevealCardMessage;
+import com.codenames.codenames.backend.game.dto.StartGameMessage;
+import com.codenames.codenames.backend.playingfield.GameService;
+import com.codenames.codenames.backend.recovery.SystemStatePersistenceService;
+import org.springframework.messaging.handler.annotation.MessageMapping;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Controller;
+
+/**
+ * WebSocket controller for real-time gameplay interactions.
+ *
+ * <p>Handles game-related WebSocket requests such as starting games, submitting clues, and
+ * revealing cards. Broadcasts updated game state information to subscribed clients.
+ */
+@Controller
+public class GameSocketController {
+
+  private final GameService gameService;
+
+  private final SimpMessagingTemplate messagingTemplate;
+  private final SystemStatePersistenceService persistenceService;
+
+  private static final String GAME_TOPIC_PREFIX = "/topic/game/";
+
+  /**
+   * Creates a new {@code GameSocketController}.
+   *
+   * @param gameService service responsible for gameplay logic
+   * @param messagingTemplate template used for broadcasting websocket messages
+   * @param persistenceService service used to persist current backend state
+   */
+  public GameSocketController(
+      GameService gameService,
+      SimpMessagingTemplate messagingTemplate,
+      SystemStatePersistenceService persistenceService) {
+
+    this.gameService = gameService;
+    this.messagingTemplate = messagingTemplate;
+    this.persistenceService = persistenceService;
+  }
+
+  /**
+   * Sends the current game state to subscribed players.
+   *
+   * @param message contains the lobby code
+   */
+  @MessageMapping("/start-game")
+  public void startGame(StartGameMessage message) {
+
+    messagingTemplate.convertAndSend(
+        GAME_TOPIC_PREFIX + message.getLobbyCode(),
+        gameService.getCurrentGameState(message.getLobbyCode()));
+  }
+
+  /**
+   * Reveals a card on the board.
+   *
+   * <p>Updates the game state and broadcasts the updated board to all subscribed players.
+   *
+   * @param message the reveal card request
+   */
+  @MessageMapping("/reveal-card")
+  public void revealCard(RevealCardMessage message) {
+
+    gameService.flipCard(message.getLobbyCode(), message.getPosition(), message.getCurrentTurn());
+    persistenceService.persistCurrentState();
+
+    messagingTemplate.convertAndSend(
+        GAME_TOPIC_PREFIX + message.getLobbyCode(),
+        gameService.getCurrentGameState(message.getLobbyCode()));
+  }
+
+  /**
+   * Submits a clue for the current turn.
+   *
+   * <p>Updates the current clue and broadcasts the updated game state to all subscribed players.
+   *
+   * @param message the clue submission request
+   */
+  @MessageMapping("/submit-clue")
+  public void submitClue(ClueMessage message) {
+
+    gameService.submitClue(
+        message.getLobbyCode(),
+        new Clue(message.getWord(), message.getGuessAmount()),
+        message.getCurrentTurn());
+    persistenceService.persistCurrentState();
+
+    messagingTemplate.convertAndSend(
+        GAME_TOPIC_PREFIX + message.getLobbyCode(),
+        gameService.getCurrentGameState(message.getLobbyCode()));
+  }
+
+  /**
+   * Ends the current turn early and broadcasts the updated game state.
+   *
+   * @param message contains lobby and team information
+   */
+  @MessageMapping("/pass-turn")
+  public void passTurn(PassTurnMessage message) {
+
+    gameService.passTurn(message.getLobbyCode(), message.getCurrentTurn());
+    persistenceService.persistCurrentState();
+
+    messagingTemplate.convertAndSend(
+        GAME_TOPIC_PREFIX + message.getLobbyCode(),
+        gameService.getCurrentGameState(message.getLobbyCode()));
+  }
+}

src/main/java/com/codenames/codenames/backend/game/dto/ClueDto.java

@@ -0,0 +1,12 @@
+package com.codenames.codenames.backend.game.dto;
+
+/**
+ * Data transfer object for a clue, containing the clue word and the allowed number of guesses.
+ * This is only used for sending clues, not for receiving them.
+ * Therefore, the +1 is already included in the guessAmount.
+ *
+ * @param word the hint word
+ * @param guessAmount how many guesses are allowed
+ */
+public record ClueDto(String word, int guessAmount) {
+}

src/main/java/com/codenames/codenames/backend/game/dto/ClueMessage.java

@@ -0,0 +1,19 @@
+package com.codenames.codenames.backend.game.dto;
+
+import com.codenames.codenames.backend.utility.Team;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * WebSocket message for submitting a clue.
+ *
+ * <p>Contains the clue word and the allowed amount of guesses.
+ */
+@Getter
+@Setter
+public class ClueMessage {
+  private String lobbyCode;
+  private String word;
+  private int guessAmount;
+  private Team currentTurn;
+}

src/main/java/com/codenames/codenames/backend/game/dto/PassTurnMessage.java

@@ -0,0 +1,17 @@
+package com.codenames.codenames.backend.game.dto;
+
+import com.codenames.codenames.backend.utility.Team;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Message used for requesting an early turn pass.
+ *
+ * <p>Contains the lobby code and team initiating the action.
+ */
+@Getter
+@Setter
+public class PassTurnMessage {
+  private String lobbyCode;
+  private Team currentTurn;
+}

src/main/java/com/codenames/codenames/backend/game/dto/RevealCardMessage.java

@@ -0,0 +1,18 @@
+package com.codenames.codenames.backend.game.dto;
+
+import com.codenames.codenames.backend.utility.Team;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * WebSocket message for revealing a card on the board.
+ *
+ * <p>Contains the lobby code, selected card position, and the current team's turn color.
+ */
+@Getter
+@Setter
+public class RevealCardMessage {
+  private String lobbyCode;
+  private int position;
+  private Team currentTurn;
+}