refactor(vanish-service): Refactor the vanish service to uuid based

build.gradle.kts

@@ -58,7 +58,7 @@ tasks {
         finalizedBy(rootProject.tasks.jacocoTestReport)
     }
     runServer {
-        minecraftVersion("1.21.4")
+        minecraftVersion("1.21.10")
         jvmArgs("-Dcom.mojang.eula.agree=true")
     }
     jacocoTestReport {

src/main/java/net/onelitefeather/stardust/api/PlayerVanishService.java

@@ -1,61 +1,66 @@
 package net.onelitefeather.stardust.api;
 
-import org.bukkit.entity.Player;
+import java.util.UUID;
 
-public interface PlayerVanishService<P extends Player> {
+public interface PlayerVanishService {
 
     /**
      * Hides a player for other players
      *
-     * @param player to be hide
+     * @param playerId to be hidden
      */
-    void hidePlayer(P player);
+    void hidePlayer(UUID playerId);
 
     /**
      * Shows a player for other players
      *
-     * @param player to be shown to other player
+     * @param playerId to be shown to other players
      */
-    void showPlayer(P player);
+    void showPlayer(UUID playerId);
 
-    /**
-     * Toggle vanish status of a player
-     *
-     * @param player be affected
+    /*
+     * @param playerId to be affected
+     * @return new vanish state
      */
-    boolean toggle(P player);
+    boolean toggle(UUID playerId);
 
     /**
-     * Check if the player in vanish
+     * Check if the player is vanished
      *
      * @return the current status
      */
-    boolean isVanished(P player);
+    boolean isVanished(UUID playerId);
 
     /**
      * Set a user explicit the vanish status
      *
-     * @param player   to be affected
-     * @param vanished status of the user
+     * @param playerId  to be affected
+     * @param vanished  status of the user
      */
-    void setVanished(P player, boolean vanished);
+    void setVanished(UUID playerId, boolean vanished);
 
     /**
      * Handles if a player joining the server
      *
-     * @param player be affected
+     * @param playerId to be affected
      * @return true if the player is vanished
      */
-    boolean handlePlayerJoin(P player);
+    boolean handlePlayerJoin(UUID playerId);
 
     /**
      * Handles if a player quits the server
      *
-     * @param player be affected
+     * @param playerId to be affected
      */
-    void handlePlayerQuit(P player);
+    void handlePlayerQuit(UUID playerId);
 
-    boolean canSee(P player, P target);
+    boolean canSee(UUID viewerId, UUID targetId);
 
-    boolean isVanishPermitted(P player);
+    /**
+     * Check if a player has permission to vanish
+     *
+     * @param playerId to be checked
+     * @return true if the player has permission to vanish
+     */
+    boolean isVanishPermitted(UUID playerId);
 }

src/main/java/net/onelitefeather/stardust/command/commands/VanishCommand.java

@@ -71,7 +71,7 @@ public void commandVanishToggleProperty(
                 toggleProperty(commandSender, target, property);
                 return;
             }
-            if (stardustPlugin.getUserService().getVanishService().canSee((Player) commandSender, target)) {
+            if (stardustPlugin.getUserService().getVanishService().canSee(((Player) commandSender).getUniqueId(), target.getUniqueId())) {
                 toggleProperty(commandSender, target, property);
             }
         }
@@ -114,7 +114,7 @@ public void toggleVanish(CommandSender commandSender, Player target) {
                         .arguments(stardustPlugin.getPrefix()));
                 return;
             }
-            stardustPlugin.getUserService().getVanishService().toggle(target);
+            stardustPlugin.getUserService().getVanishService().toggle(target.getUniqueId());
         } catch (Exception e) {
             stardustPlugin.getLogger().throwing(VanishCommand.class.getSimpleName(), "toggleVanish", e);
         }

src/main/java/net/onelitefeather/stardust/listener/PlayerAdvancementListener.java

@@ -15,7 +15,7 @@ public PlayerAdvancementListener(StardustPlugin plugin) {
     @EventHandler
     public void onPlayerAdvancement(PlayerAdvancementCriterionGrantEvent event) {
         var player = event.getPlayer();
-        if (plugin.getUserService().getVanishService().isVanished(player)) {
+        if (plugin.getUserService().getVanishService().isVanished(player.getUniqueId())) {
             event.setCancelled(true);
         }
     }

src/main/java/net/onelitefeather/stardust/listener/PlayerConnectionListener.java

@@ -1,7 +1,5 @@
 package net.onelitefeather.stardust.listener;
 
-import org.bukkit.event.Listener;
-
 import net.kyori.adventure.text.Component;
 import net.onelitefeather.stardust.StardustPlugin;
 import net.onelitefeather.stardust.user.User;
@@ -57,15 +55,15 @@ public void onPlayerQuit(PlayerQuitEvent event) {
             } else {
                 event.quitMessage(Component.translatable("listener.quit-message").arguments(player.displayName()));
             }
-            stardustPlugin.getUserService().getVanishService().handlePlayerQuit(player);
+            stardustPlugin.getUserService().getVanishService().handlePlayerQuit(player.getUniqueId());
         } catch (Exception e) {
             stardustPlugin.getLogger().log(Level.SEVERE, "Something went wrong during the quit process", e);
         }
     }
 
     private void joinMessage(PlayerJoinEvent event) {
         Player player = event.getPlayer();
-        boolean isVanished = stardustPlugin.getUserService().getVanishService().handlePlayerJoin(player);
+        boolean isVanished = stardustPlugin.getUserService().getVanishService().handlePlayerJoin(player.getUniqueId());
         if (isVanished) {
             event.joinMessage(null);
         } else {

src/main/java/net/onelitefeather/stardust/listener/PlayerVanishListener.java

@@ -44,7 +44,7 @@ public PlayerVanishListener(StardustPlugin stardustPlugin) {
     }
 
     private boolean isVanished(Player player) {
-        return stardustPlugin.getUserService().getVanishService().isVanished(player);
+        return stardustPlugin.getUserService().getVanishService().isVanished(player.getUniqueId());
     }
 
     @EventHandler
@@ -245,7 +245,7 @@ public void handleGameEvent(BlockReceiveGameEvent event) {
         }
 
         if (resultPlayer == null) return;
-        event.setCancelled(stardustPlugin.getUserService().getVanishService().isVanished(resultPlayer));
+        event.setCancelled(stardustPlugin.getUserService().getVanishService().isVanished(resultPlayer.getUniqueId()));
     }
 
     @EventHandler

src/main/java/net/onelitefeather/stardust/listener/VanishNoPacketListener.java

@@ -49,6 +49,6 @@ private boolean isVanished(WrapperPlayServerPlayerInfo.PlayerData data) {
         if (userProfile == null) return false;
         var user = this.stardustPlugin.getUserService().getUser(userProfile.getUUID());
         if (user == null) return false;
-        return this.stardustPlugin.getUserService().getVanishService().isVanished(user.getBase());
+        return this.stardustPlugin.getUserService().getVanishService().isVanished(user.getUniqueId());
     }
 }

src/main/java/net/onelitefeather/stardust/listener/VanishSilentContainerFeature.java

@@ -35,7 +35,7 @@ public void handleInventoryClick(InventoryClickEvent event) {
         if (!(event.getWhoClicked() instanceof Player whoClicked)) return;
         Inventory clickedInventory = event.getInventory();
 
-        if (stardustPlugin.getUserService().getVanishService().isVanished(whoClicked)) {
+        if (stardustPlugin.getUserService().getVanishService().isVanished(whoClicked.getUniqueId())) {
             Inventory inventory = silentContainerLooter.get(whoClicked);
             if (inventory == null) return;
             boolean canInteract = whoClicked.hasPermission("stardust.vanish.silentopen.interact");
@@ -52,7 +52,7 @@ public void handlePlayerInteract(PlayerInteractEvent event) {
         BlockState blockState = event.getClickedBlock().getState();
 
         boolean hasPermission = player.hasPermission("stardust.vanish.silentopen");
-        boolean vanished = stardustPlugin.getUserService().getVanishService().isVanished(player);
+        boolean vanished = stardustPlugin.getUserService().getVanishService().isVanished(player.getUniqueId());
 
         if (blockState instanceof EnderChest) {
             boolean useInteractBlock = vanished && !player.isSneaking() || player.isSneaking();

src/main/java/net/onelitefeather/stardust/service/BukkitPlayerVanishService.java

@@ -11,7 +11,11 @@
 import org.bukkit.entity.Player;
 import org.bukkit.persistence.PersistentDataType;
 
-public class BukkitPlayerVanishService implements PlayerVanishService<Player> {
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public final class BukkitPlayerVanishService implements PlayerVanishService {
 
     private static final String VANISH_PERMISSION = "stardust.command.vanish";
     private final StardustPlugin plugin;
@@ -26,111 +30,135 @@ public BukkitPlayerVanishService(UserService userService, StardustPlugin plugin)
     }
 
     @Override
-    public void hidePlayer(Player player) {
-        plugin.getServer().getScheduler().getMainThreadExecutor(plugin)
-                .execute(() -> plugin.getServer().getOnlinePlayers().forEach(onlinePlayer -> {
+    public void hidePlayer(UUID playerId) {
+        Player player = plugin.getServer().getPlayer(playerId);
+        if (player == null) return;
 
-                    if (!canSee(onlinePlayer, player)) {
-                        onlinePlayer.hidePlayer(plugin, player);
-                    }
-                }));
+        Predicate<Player> cannotSeePredicate = onlinePlayer -> !canSee(onlinePlayer.getUniqueId(), playerId);
+        Consumer<Player> hideAction = onlinePlayer -> onlinePlayer.hidePlayer(plugin, player);
+
+        plugin.getServer()
+                .getScheduler()
+                .getMainThreadExecutor(plugin)
+                .execute(() -> plugin.getServer().getOnlinePlayers().stream().filter(cannotSeePredicate).forEach(hideAction));
     }
 
     @Override
-    public void showPlayer(Player player) {
-        plugin.getServer().getScheduler().getMainThreadExecutor(plugin)
-                .execute(() -> plugin.getServer().getOnlinePlayers().forEach(onlinePlayer -> {
+    public void showPlayer(UUID playerId) {
+        Player player = plugin.getServer().getPlayer(playerId);
+        if (player == null) return;
 
+        plugin.getServer()
+                .getScheduler()
+                .getMainThreadExecutor(plugin)
+                .execute(() -> plugin.getServer().getOnlinePlayers().forEach(onlinePlayer -> {
                     onlinePlayer.showPlayer(plugin, player);
                     onlinePlayer.sendMessage(Component.translatable("listener.join-message").arguments(player.displayName()));
                 }));
     }
 
     @Override
-    public boolean toggle(Player player) {
-
-        var currentState = isVanished(player);
+    public boolean toggle(UUID playerId) {
+        Player player = plugin.getServer().getPlayer(playerId);
+        if (player == null) return false;
+        var currentState = isVanished(playerId);
 
         if (currentState) {
-            showPlayer(player);
+            showPlayer(playerId);
             sendReappearedMessage(player);
         } else {
-            hidePlayer(player);
+            hidePlayer(playerId);
             sendDisappearedMessage(player);
         }
 
         var newState = !currentState;
-        setVanished(player, newState);
+        setVanished(playerId, newState);
         togglePlayerProperties(player, newState);
 
         return newState;
     }
 
     @Override
-    public boolean isVanished(Player player) {
-        var vanished = player.getPersistentDataContainer().get(vanishedKey, PersistentDataType.BOOLEAN);
-        if (vanished == null) return false;
+    public boolean isVanished(UUID playerId) {
 
-        var user = userService.getUser(player.getUniqueId());
+        var user = userService.getUser(playerId);
         if (user == null) return false;
-        return user.isVanished() || vanished;
+
+        Player player = plugin.getServer().getPlayer(playerId);
+        var vanished = player != null && Boolean.TRUE.equals(player.getPersistentDataContainer().get(vanishedKey, PersistentDataType.BOOLEAN));
+        return Boolean.logicalAnd(user.isVanished(), vanished);
     }
 
     @Override
-    public void setVanished(Player player, boolean vanished) {
+    public void setVanished(UUID playerId, boolean vanished) {
 
-        var user = userService.getUser(player.getUniqueId());
+        var user = userService.getUser(playerId);
         if (user == null) return;
 
         this.userService.setUserProperty(user, UserPropertyType.VANISHED, vanished);
-        player.getPersistentDataContainer().set(vanishedKey, PersistentDataType.BOOLEAN, vanished);
+
+        Player player = plugin.getServer().getPlayer(playerId);
+        if (player != null) {
+            player.getPersistentDataContainer().set(vanishedKey, PersistentDataType.BOOLEAN, vanished);
+        }
     }
 
     @Override
-    public boolean handlePlayerJoin(Player player) {
+    public boolean handlePlayerJoin(UUID playerId) {
 
-        player.getServer().getOnlinePlayers().stream().filter(this::isVanished).forEach(this::hidePlayer);
+        Player player = plugin.getServer().getPlayer(playerId);
+        if (player == null) return false;
+
+        player.getServer().getOnlinePlayers().stream().map(Player::getUniqueId).filter(this::isVanished).forEach(this::hidePlayer);
 
         if (handleAutoVanish(player)) return true;
 
-        if (isVanished(player)) {
+        if (isVanished(playerId)) {
 
             if (!player.hasPermission("stardust.command.vanish")) {
-                setVanished(player, false);
-                showPlayer(player);
+                setVanished(playerId, false);
+                showPlayer(playerId);
                 togglePlayerProperties(player, false);
                 return true;
             }
 
             player.sendMessage(Component.translatable("vanish.join.self").arguments(plugin.getPrefix()));
             broadcastMessage(player,
                     Component.translatable("vanish.join.silently").arguments(vanishDisplayName(player)));
-            hidePlayer(player);
+            hidePlayer(playerId);
             togglePlayerProperties(player, true);
         }
 
         return false;
     }
 
     @Override
-    public void handlePlayerQuit(Player player) {
-        if (!isVanished(player)) return;
+    public void handlePlayerQuit(UUID playerId) {
+        var player = plugin.getServer().getPlayer(playerId);
+        if (player == null) return;
+        if (!isVanished(playerId)) return;
         broadcastMessage(player,
                 Component.translatable("vanish.quit.silently")
                         .arguments(plugin.getPrefix(), vanishDisplayName(player)));
     }
 
     @Override
-    public boolean canSee(Player player, Player target) {
+    public boolean canSee(UUID playerId, UUID targetId) {
+
+        Player player = plugin.getServer().getPlayer(playerId);
+        Player target = plugin.getServer().getPlayer(targetId);
+        if (player == null) return false;
+
         if (!isGroupWeightBased()) return player.hasPermission(VANISH_SEE_OTHERS_PERMISSION);
         var playerGroupPriority = plugin.getLuckPermsService().getGroupPriority(player);
         var targetGroupPriority = plugin.getLuckPermsService().getGroupPriority(target);
         return playerGroupPriority >= targetGroupPriority;
     }
 
     @Override
-    public boolean isVanishPermitted(Player player) {
-        return player.hasPermission(VANISH_PERMISSION);
+    public boolean isVanishPermitted(UUID playerId) {
+        Player player = plugin.getServer().getPlayer(playerId);
+        return player != null && player.hasPermission(VANISH_PERMISSION);
     }
 
     private void sendReappearedMessage(Player player) {
@@ -176,8 +204,8 @@ private boolean handleAutoVanish(Player player) {
         if (player.hasPermission("stardust.vanish.auto")) {
             var displayName = vanishDisplayName(player);
 
-            setVanished(player, true);
-            hidePlayer(player);
+            setVanished(player.getUniqueId(), true);
+            hidePlayer(player.getUniqueId());
             togglePlayerProperties(player, true);
             player.sendMessage(Component.translatable("vanish.join.self").arguments(plugin.getPrefix()));