Add player registration system with /hg register command and refactor services for improved state management.

src/main/java/com/alttd/hunger_games/services/PlayerService.java

@@ -3,9 +3,10 @@ package com.alttd.hunger_games.services;
 import com.alttd.hunger_games.data_objects.PLAYER_STATE;
 import com.alttd.hunger_games.data_objects.ROUND_STATE;
 import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
-import java.util.Optional;
+import java.util.*;
 
 @RequiredArgsConstructor
 public class PlayerService implements RoundListener {
@@ -16,29 +17,70 @@ public class PlayerService implements RoundListener {
     @Override
     public void stateChange(ROUND_STATE roundState) {
         this.roundState = roundState;
-        //TODO: Implement player state change logic
+        switch (roundState) {
+            case PLAYER_REGISTRATION, KILL_PHASE -> {
+                //Nothing
+            }
+            case COUNTDOWN -> {
+                setNonRegisteredPlayersToSpectator();
+                //TODO: teleport players to spawn location
+            }
+            case FINALE -> {
+                //TODO: teleport players to finale location
+            }
+            case ENDED -> {
+                roundService.clear();
+                //TODO: teleport everyone to spawn (or spectator?) location
+            }
+        }
+    }
+
+    private void setNonRegisteredPlayersToSpectator() {
+        Set<UUID> playerUUIDs = roundService.getPlayers(PLAYER_STATE.REGISTERED);
+        List<Player> playerList = new ArrayList<>(Bukkit.getOnlinePlayers());
+        List<Player> unregisteredPlayers = playerList.stream().filter(player -> !playerUUIDs.contains(player.getUniqueId())).toList();
+        unregisteredPlayers.forEach(player -> roundService.setPlayerState(player.getUniqueId(), PLAYER_STATE.SPECTATING));
     }
 
     @Override
     public void roundReset() {
-        //TODO: Implement player reset logic
+        //TODO: teleport everyone to spawn (or spectator?) location (from where they can join the game)
     }
 
     public Optional<PLAYER_STATE> registerPlayer(Player player) {
         if (roundState == null) {
             return Optional.empty();
         }
-        switch (roundState) {
-            case PLAYER_REGISTRATION -> {
-            }
-            case COUNTDOWN -> {
-            }
-            case KILL_PHASE -> {
-            }
-            case FINALE -> {
-            }
-            case ENDED -> {
-            }
+        Optional<PLAYER_STATE> optionalPlayerState = determinePlayerState(player.getUniqueId());
+        if (optionalPlayerState.isEmpty()) {
+            return Optional.empty();
         }
+        PLAYER_STATE playerState = optionalPlayerState.get();
+
+        if (playerState == PLAYER_STATE.SPECTATING) {
+            //TODO: teleport player to spectator location
+        }
+
+        roundService.setPlayerState(player.getUniqueId(), playerState);
+        return optionalPlayerState;
+    }
+
+    private Optional<PLAYER_STATE> determinePlayerState(UUID playerUuid) {
+        if (roundState == null) {
+            return Optional.empty();
+        }
+        Optional<PLAYER_STATE> optionalPlayerState = roundService.getPlayerState(playerUuid);
+        if (optionalPlayerState.isPresent()) {
+            PLAYER_STATE playerState = optionalPlayerState.get();
+            return Optional.of(switch (playerState) {
+                case DISCONNECTED, SPECTATING -> PLAYER_STATE.SPECTATING;
+                case IN_GAME -> PLAYER_STATE.IN_GAME;
+                case REGISTERED -> PLAYER_STATE.REGISTERED;
+            });
+        }
+        return switch (roundState) {
+            case PLAYER_REGISTRATION, COUNTDOWN -> Optional.of(PLAYER_STATE.REGISTERED);
+            case KILL_PHASE, FINALE, ENDED -> Optional.of(PLAYER_STATE.SPECTATING);
+        };
     }
 }

src/main/java/com/alttd/hunger_games/services/RoundService.java

@@ -5,10 +5,7 @@ import com.alttd.hunger_games.data_objects.ROUND_STATE;
 import lombok.Getter;
 import org.bukkit.entity.Player;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class RoundService implements RoundListener {
@@ -32,8 +29,12 @@ public class RoundService implements RoundListener {
         players.put(uuid, playerState);
     }
 
-    public PLAYER_STATE getPlayerState(UUID uuid) {
-        return players.get(uuid);
+    protected void clear() {
+        players.clear();
+    }
+
+    public Optional<PLAYER_STATE> getPlayerState(UUID uuid) {
+        return Optional.ofNullable(players.get(uuid));
     }
 
     @Override
@@ -43,7 +44,7 @@ public class RoundService implements RoundListener {
 
     @Override
     public void roundReset() {
-        players.clear();
+        clear();
         roundState = null;
     }
 }