Merge pull request #763 from ArikSquad/fix/data-handler-fixes

Swofty-Developments · web-flow · commit 3cf942fae6cd · 2026-04-08T19:09:02.000+10:00
Concurrency for DataHandler
diff --git a/commons/src/main/java/net/swofty/commons/skyblock/SkyBlockPlayerProfiles.java b/commons/src/main/java/net/swofty/commons/skyblock/SkyBlockPlayerProfiles.java
@@ -3,7 +3,12 @@
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 
 @Getter
 @Setter
@@ -17,7 +22,7 @@ public class SkyBlockPlayerProfiles {
             "Potato", "Onion", "Garlic", "Celery",
             "Broccoli", "Cauliflower", "Spinach", "Asparagus"
     };
-    private static final Map<UUID, SkyBlockPlayerProfiles> profilesCache = new HashMap<>();
+    private static final Map<UUID, SkyBlockPlayerProfiles> profilesCache = new ConcurrentHashMap<>();
 
     UUID currentlySelected = null;
     ArrayList<UUID> profiles = new ArrayList<>();
diff --git a/type.generic/src/main/java/net/swofty/type/generic/data/DataHandler.java b/type.generic/src/main/java/net/swofty/type/generic/data/DataHandler.java
@@ -6,21 +6,21 @@
 import org.bson.Document;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 
+@Getter
 public abstract class DataHandler {
-    public static Map<UUID, DataHandler> userCache = new HashMap<>();
+    public static Map<UUID, DataHandler> userCache = new ConcurrentHashMap<>();
 
-    @Getter protected UUID uuid;
-    protected final Map<String, Datapoint<?>> datapoints = new HashMap<>();
+    protected UUID uuid;
+    protected final Map<String, Datapoint<?>> datapoints = new ConcurrentHashMap<>();
 
     protected DataHandler() {}
     protected DataHandler(UUID uuid) { this.uuid = uuid; }
 
     public Datapoint<?> getDatapoint(String key) { return this.datapoints.get(key); }
-    public Map<String, Datapoint<?>> getDatapoints() { return this.datapoints; }
 
     public static @NonNull DataHandler getUser(UUID uuid) {
         if (!userCache.containsKey(uuid)) throw new RuntimeException("User " + uuid + " does not exist!");
diff --git a/type.skyblockgeneric/src/main/java/net/swofty/type/skyblockgeneric/data/SkyBlockDataHandler.java b/type.skyblockgeneric/src/main/java/net/swofty/type/skyblockgeneric/data/SkyBlockDataHandler.java
@@ -42,13 +42,14 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
 public class SkyBlockDataHandler extends DataHandler {
 
     // SkyBlock specific cache
-    public static final Map<UUID, SkyBlockDataHandler> skyBlockCache = new HashMap<>();
+    public static final Map<UUID, SkyBlockDataHandler> skyBlockCache = new ConcurrentHashMap<>();
 
     @Getter
     private UUID currentProfileId;
@@ -522,4 +523,4 @@ public static void startRepeatSetValueLoop() {
             return TaskSchedule.nextTick();
         });
     }
-}
+}
diff --git a/type.skyblockgeneric/src/main/java/net/swofty/type/skyblockgeneric/event/actions/player/data/ActionPlayerSkyBlockDataLoad.java b/type.skyblockgeneric/src/main/java/net/swofty/type/skyblockgeneric/event/actions/player/data/ActionPlayerSkyBlockDataLoad.java
@@ -3,6 +3,7 @@
 import lombok.SneakyThrows;
 import net.minestom.server.event.player.AsyncPlayerConfigurationEvent;
 import net.swofty.commons.skyblock.SkyBlockPlayerProfiles;
+import net.swofty.type.generic.data.datapoints.DatapointString;
 import net.swofty.type.generic.data.mongodb.ProfilesDatabase;
 import net.swofty.type.generic.data.mongodb.UserDatabase;
 import net.swofty.type.generic.event.EventNodes;
@@ -15,6 +16,7 @@
 import org.bson.Document;
 import org.tinylog.Logger;
 
+import java.util.Objects;
 import java.util.UUID;
 
 public class ActionPlayerSkyBlockDataLoad implements HypixelEventClass {
@@ -26,7 +28,6 @@ public void run(AsyncPlayerConfigurationEvent event) {
 
         final SkyBlockPlayer player = (SkyBlockPlayer) event.getPlayer();
         UUID playerUuid = player.getUuid();
-        UUID islandUUID;
 
         // Check if player has ever joined SkyBlock before
         SkyBlockPlayerProfiles profiles = new UserDatabase(playerUuid).getProfiles();
@@ -37,8 +38,6 @@ public void run(AsyncPlayerConfigurationEvent event) {
             Logger.info("New SkyBlock player detected: " + player.getUsername() + " - initializing...");
 
             profileId = UUID.randomUUID();
-            islandUUID = profileId; // Use profile ID as island ID for new players
-
             // Create new profiles object
             profiles = new SkyBlockPlayerProfiles(playerUuid);
             profiles.setCurrentlySelected(profileId);
@@ -53,50 +52,55 @@ public void run(AsyncPlayerConfigurationEvent event) {
             if (profileId == null) {
                 // Player has profiles but no selected profile - create new one
                 profileId = UUID.randomUUID();
-                islandUUID = profileId;
                 profiles.setCurrentlySelected(profileId);
                 profiles.addProfile(profileId);
 
                 // Save updated profiles
                 UserDatabase userDb = new UserDatabase(playerUuid);
                 userDb.saveProfiles(profiles);
-            } else {
-                // Load existing profile's island UUID
-                ProfilesDatabase temp = new ProfilesDatabase(profileId.toString());
-                Document doc = temp.getDocument();
-                if (doc != null) {
-                    islandUUID = SkyBlockDataHandler.createFromProfileOnly(doc)
-                            .get(SkyBlockDataHandler.Data.ISLAND_UUID, DatapointUUID.class).getValue();
-                } else {
-                    // Profile doesn't exist in database yet
-                    islandUUID = profileId;
-                }
             }
         }
 
-
-        // Set up the island
-        SkyBlockIsland island = (SkyBlockIsland.getIsland(islandUUID) == null)
-                ? new SkyBlockIsland(islandUUID, profileId)
-                : SkyBlockIsland.getIsland(islandUUID);
-        player.setSkyBlockIsland(island);
-
         // Load SkyBlock profile data
         ProfilesDatabase profileDb = new ProfilesDatabase(profileId.toString());
         SkyBlockDataHandler handler;
+        boolean shouldPersistProfile = false;
 
         if (profileDb.exists()) {
             Document profileDocument = profileDb.getDocument();
             handler = SkyBlockDataHandler.createFromProfile(playerUuid, profileId, profileDocument);
         } else {
             handler = SkyBlockDataHandler.initUserWithDefaultData(playerUuid, profileId);
-            // Save the new profile
-            profileDb.saveDocument(handler.toProfileDocument());
+            shouldPersistProfile = true;
+        }
+
+        DatapointUUID islandDatapoint = handler.get(SkyBlockDataHandler.Data.ISLAND_UUID, DatapointUUID.class);
+        UUID islandUUID = islandDatapoint.getValue();
+        if (islandUUID == null) {
+            islandUUID = profileId;
+            islandDatapoint.setValue(islandUUID);
+            shouldPersistProfile = true;
+        }
+
+        DatapointString profileNameDatapoint = handler.get(SkyBlockDataHandler.Data.PROFILE_NAME, DatapointString.class);
+        if (Objects.equals(profileNameDatapoint.getValue(), "null")) {
+            profileNameDatapoint.setValue(SkyBlockPlayerProfiles.getRandomName());
+            shouldPersistProfile = true;
         }
 
         // Put in SkyBlock cache
         SkyBlockDataHandler.skyBlockCache.put(playerUuid, handler);
 
+        if (shouldPersistProfile) {
+            profileDb.saveDocument(handler.toProfileDocument());
+        }
+
+        // Set up the island after the cache is populated so island init can see the player as loaded
+        SkyBlockIsland island = (SkyBlockIsland.getIsland(islandUUID) == null)
+            ? new SkyBlockIsland(islandUUID, profileId)
+            : SkyBlockIsland.getIsland(islandUUID);
+        player.setSkyBlockIsland(island);
+
         Logger.info("Successfully loaded SkyBlock (profile " + profileId + ") for: " + player.getUsername());
     }
-}
+}
diff --git a/velocity.extension/src/main/java/net/swofty/velocity/gamemanager/TransferHandler.java b/velocity.extension/src/main/java/net/swofty/velocity/gamemanager/TransferHandler.java
@@ -9,17 +9,16 @@
 import net.swofty.velocity.redis.RedisMessage;
 import org.json.JSONObject;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
 
 public record TransferHandler(Player player) {
-	public static final Map<Player, ServerType> playersGoalServerType = new HashMap<>();
-	private static final Map<Player, RegisteredServer> playersOriginServer = new HashMap<>();
-	private static final List<Player> disregard = new ArrayList<>();
+	public static final Map<Player, ServerType> playersGoalServerType = new ConcurrentHashMap<>();
+	private static final Map<Player, RegisteredServer> playersOriginServer = new ConcurrentHashMap<>();
+	private static final Set<Player> disregard = ConcurrentHashMap.newKeySet();
 
 	public boolean isInLimbo() {
 		return playersGoalServerType.containsKey(player);
@@ -37,6 +36,13 @@ public CompletableFuture<Boolean> sendToLimbo() {
 		CompletableFuture<Boolean> future = new CompletableFuture<>();
 
 		new Thread(() -> {
+			if (isInLimbo() && player.getCurrentServer()
+				.map(server -> server.getServer().equals(SkyBlockVelocity.getLimboServer()))
+				.orElse(false)) {
+				future.complete(true);
+				return;
+			}
+
 			if (player.getCurrentServer().isPresent()) {
 				RegisteredServer previousServer = player.getCurrentServer().get().getServer();
 				playersOriginServer.put(player, previousServer);
@@ -81,17 +87,28 @@ public void previousServerIsFinished(RegisteredServer manualPick) {
 
 	public void previousServerIsFinished() {
 		new Thread(() -> {
-			if (disregard.contains(player)) return;
+			if (disregard.contains(player) || !isInLimbo()) return;
 
 			ServerType type = playersGoalServerType.get(player);
+			if (type == null) {
+				playersGoalServerType.remove(player);
+				playersOriginServer.remove(player);
+				return;
+			}
 			GameManager.GameServer server = BalanceConfigurations.getServerFor(player, type);
 
 			if (server == null) {
+				playersGoalServerType.remove(player);
+				playersOriginServer.remove(player);
 				player.disconnect(Component.text("§cThere are no Hypixel (type=" + type.name() + ") servers available at the moment."));
 				return;
 			}
 
 			RegisteredServer originServer = playersOriginServer.get(player);
+			if (originServer == null) {
+				playersGoalServerType.remove(player);
+				return;
+			}
 			UUID originServerUUID = UUID.fromString(originServer.getServerInfo().getName());
 			UUID sendingToServerUUID = server.internalID();
 			ServerType originServerType = GameManager.getTypeFromRegisteredServer(originServer);
@@ -116,33 +133,8 @@ public void previousServerIsFinished() {
 
 	public void transferTo(ServerType type) {
 		new Thread(() -> {
-			RegisteredServer originServer = playersOriginServer.get(player);
-			if (originServer == null) {
-				player.getCurrentServer().ifPresent(conn -> playersOriginServer.put(player, conn.getServer()));
-				originServer = playersOriginServer.get(player);
-			}
-			ServerType originServerType = GameManager.getTypeFromRegisteredServer(originServer);
-
-			playersGoalServerType.remove(player);
-			playersOriginServer.remove(player);
-
-			GameManager.GameServer server = BalanceConfigurations.getServerFor(player, type);
-
-			if (server == null) {
-				player.disconnect(Component.text("§cThere are no Hypixel (type=" + type.name() + ") servers available at the moment."));
-				return;
-			}
-
-			if (originServer != null && originServerType != null) {
-				RedisMessage.sendMessageToServer(server.internalID(),
-						FromProxyChannels.GIVE_PLAYERS_ORIGIN_TYPE,
-						new JSONObject().put("uuid", player.getUniqueId().toString())
-								.put("origin-type", originServerType.name())
-				);
-			}
-
-			player.sendMessage(Component.text("§7Sending to server " + server.displayName() + "..."));
-			player.createConnectionRequest(server.registeredServer()).connectWithIndication();
+			playersGoalServerType.put(player, type);
+			sendToLimbo().join();
 		}).start();
 	}
 
diff --git a/velocity.extension/src/main/java/net/swofty/velocity/redis/listeners/ListenerServerFinishedWithPlayer.java b/velocity.extension/src/main/java/net/swofty/velocity/redis/listeners/ListenerServerFinishedWithPlayer.java
@@ -24,6 +24,9 @@ public JSONObject receivedMessage(JSONObject message, UUID serverUUID) {
 
         Player player = potentialPlayer.get();
         TransferHandler handler = new TransferHandler(player);
+        if (!handler.isInLimbo()) {
+            return new JSONObject();
+        }
         handler.previousServerIsFinished();
 
         return new JSONObject();
