adjust luckperms integration

Author: jacobgranberry

src/main/java/westeroscraft/LuckPermsIntegration.java

@@ -1,56 +1,48 @@
 package westeroscraft;
 
+import net.fabricmc.loader.api.FabricLoader;
 import net.luckperms.api.LuckPerms;
 import net.luckperms.api.LuckPermsProvider;
-import net.luckperms.api.model.user.User;
-import net.luckperms.api.query.QueryOptions;
+import net.luckperms.api.cacheddata.CachedPermissionData;
+import net.luckperms.api.platform.PlayerAdapter;
 import net.minecraft.server.level.ServerPlayer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.UUID;
-
 /**
  * Optional integration with LuckPerms for permission checks.
  * Gracefully handles the case when LuckPerms is not installed.
+ * Uses the recommended PlayerAdapter API for online player permission checks.
  */
 public class LuckPermsIntegration {
     private static final Logger LOGGER = LoggerFactory.getLogger("westeroscraft-essentials");
-    private static boolean available = false;
-    private static boolean checked = false;
+    private static final String LUCKPERMS_MOD_ID = "luckperms";
+    private static boolean initialized = false;
+    private static PlayerAdapter<ServerPlayer> playerAdapter = null;
 
     /**
      * Check if LuckPerms is available on the server.
+     * Uses FabricLoader to check if the mod is loaded, then lazily initializes
+     * the PlayerAdapter on first use.
      */
     public static boolean isAvailable() {
-        if (!checked) {
-            checked = true;
+        if (!FabricLoader.getInstance().isModLoaded(LUCKPERMS_MOD_ID)) {
+            return false;
+        }
+
+        if (!initialized) {
+            initialized = true;
             try {
-                Class.forName("net.luckperms.api.LuckPermsProvider");
-                LuckPermsProvider.get();
-                available = true;
+                LuckPerms luckPerms = LuckPermsProvider.get();
+                playerAdapter = luckPerms.getPlayerAdapter(ServerPlayer.class);
                 LOGGER.info("LuckPerms integration enabled");
-            } catch (ClassNotFoundException | IllegalStateException e) {
-                available = false;
-                LOGGER.info("LuckPerms not found, permission integration disabled");
+            } catch (IllegalStateException e) {
+                LOGGER.warn("LuckPerms is loaded but not yet available: {}", e.getMessage());
+                initialized = false; // Allow retry on next call
+                return false;
             }
         }
-        return available;
-    }
-
-    /**
-     * Check if a player has a specific permission.
-     * Returns true if LuckPerms is not available (fail-open).
-     *
-     * @param player     The server player to check
-     * @param permission The permission node to check
-     * @return true if player has permission or LuckPerms is unavailable
-     */
-    public static boolean hasPermission(ServerPlayer player, String permission) {
-        if (!isAvailable()) {
-            return true; // Fail-open when LuckPerms not installed
-        }
-        return hasPermissionStrict(player.getUUID(), permission);
+        return playerAdapter != null;
     }
 
     /**
@@ -65,32 +57,23 @@ public static boolean hasPermissionStrict(ServerPlayer player, String permission
         if (!isAvailable()) {
             return false; // Fail-closed when LuckPerms not installed
         }
-        return hasPermissionStrict(player.getUUID(), permission);
+        return checkPermission(player, permission);
     }
 
     /**
-     * Check if a player (by UUID) has a specific permission.
+     * Check if a player has a specific permission using the PlayerAdapter API.
+     * This is the recommended way to check permissions for online players.
      *
-     * @param playerUuid The player's UUID
+     * @param player     The server player to check
      * @param permission The permission node to check
      * @return true if player has permission, false otherwise
      */
-    public static boolean hasPermissionStrict(UUID playerUuid, String permission) {
-        if (!isAvailable()) {
-            return false;
-        }
+    private static boolean checkPermission(ServerPlayer player, String permission) {
         try {
-            LuckPerms luckPerms = LuckPermsProvider.get();
-            User user = luckPerms.getUserManager().getUser(playerUuid);
-            if (user == null) {
-                return false;
-            }
-            return user.getCachedData()
-                    .getPermissionData(QueryOptions.nonContextual())
-                    .checkPermission(permission)
-                    .asBoolean();
+            CachedPermissionData permissionData = playerAdapter.getPermissionData(player);
+            return permissionData.checkPermission(permission).asBoolean();
         } catch (Exception e) {
-            LOGGER.warn("Error checking permission {} for {}: {}", permission, playerUuid, e.getMessage());
+            LOGGER.warn("Error checking permission {} for {}: {}", permission, player.getGameProfile().getName(), e.getMessage());
             return false;
         }
     }

src/main/java/westeroscraft/adventure/GameModeEnforcer.java

@@ -10,7 +10,8 @@
 
 /**
  * Enforces Adventure mode for players with the wcessentials.forceadventuremode permission.
- * Players with this permission are blocked from CREATIVE and SURVIVAL modes, but can use SPECTATOR.
+ * On login: Players are always forced to ADVENTURE mode.
+ * On dimension change: Only CREATIVE is blocked; ADVENTURE, SURVIVAL, and SPECTATOR are allowed.
  * Uses LuckPerms for permission checking (fail-closed - no effect if LuckPerms not installed).
  */
 public class GameModeEnforcer {
@@ -28,18 +29,28 @@ public static void enforceGameMode(ServerPlayer player, String context) {
             return;
         }
 
+        if (!LuckPermsIntegration.hasPermissionStrict(player, PERMISSION)) {
+            return;
+        }
+
         GameType currentMode = player.gameMode.getGameModeForPlayer();
 
-        // Only force to ADVENTURE if player is in CREATIVE or SURVIVAL
-        // SPECTATOR mode is allowed for players with this permission
-        if (currentMode == GameType.CREATIVE || currentMode == GameType.SURVIVAL) {
-            if (LuckPermsIntegration.hasPermissionStrict(player, PERMISSION)) {
-                LOGGER.info("Player {} forced from {} to ADVENTURE mode ({})",
-                    player.getDisplayName().getString(),
-                    currentMode.getName(),
-                    context);
-                player.setGameMode(GameType.ADVENTURE);
-            }
+        // On JOIN: always force to ADVENTURE
+        // On DIMENSION_CHANGE: only force if in CREATIVE
+        boolean shouldEnforce;
+        if ("DIMENSION_CHANGE".equals(context)) {
+            shouldEnforce = (currentMode == GameType.CREATIVE);
+        } else {
+            // LOGIN and other contexts: always enforce
+            shouldEnforce = (currentMode != GameType.ADVENTURE);
+        }
+
+        if (shouldEnforce) {
+            LOGGER.info("Player {} forced from {} to ADVENTURE mode ({})",
+                player.getDisplayName().getString(),
+                currentMode.getName(),
+                context);
+            player.setGameMode(GameType.ADVENTURE);
         }
     }