chore: update mod version to 2.2.1 and enhance PlayerPreset validation

KdGaming0 · KdGaming0 · commit b222c74340a0 · 2025-11-17T08:35:28.000+01:00
diff --git a/gradle.properties b/gradle.properties
@@ -4,7 +4,7 @@ org.gradle.parallel=true
 org.gradle.configuration-cache=true
 
 # Mod properties
-mod.version=2.2.0
+mod.version=2.2.1
 mod.group=com.github.kd_gaming1
 mod.id=scaleme
 mod.name=ScaleMe
diff --git a/src/main/java/com/github/kd_gaming1/scaleme/client/data/PlayerPreset.java b/src/main/java/com/github/kd_gaming1/scaleme/client/data/PlayerPreset.java
@@ -7,118 +7,96 @@
 import java.util.Objects;
 import java.util.UUID;
 
-/**
- * Represents a scaling preset for a specific player.
- * <p>
- * Each preset contains:
- * <ul>
- *   <li>An identifier (UUID or username)</li>
- *   <li>An optional friendly display name</li>
- *   <li>A scale factor for the player</li>
- *   <li>An enabled/disabled state</li>
- * </ul>
- * <p>
- * Presets are immutable after creation, use {@link #copy()} to create modified versions.
- */
 public class PlayerPreset {
 
     @SerializedName("identifier")
-    public String identifier; // Package-private for manager access
+    public String identifier;
 
     @SerializedName("friendlyName")
-    public String friendlyName; // Package-private for manager access
+    public String friendlyName;
 
     @SerializedName("scale")
-    public float scale; // Package-private for manager access
+    public float scale;
 
     @SerializedName("enabled")
-    public boolean enabled; // Package-private for manager access
+    public boolean enabled;
 
     /**
      * Creates a new player preset with validation.
      * @param identifier The player identifier (UUID or username)
      * @param friendlyName Optional display name (can be null)
      * @param scale The scale factor
-     * @throws IllegalArgumentException if identifier is invalid or scale is out of range
+     * @throws IllegalArgumentException if scale is out of range
      */
     public PlayerPreset(String identifier, String friendlyName, float scale) {
-        validateIdentifier(identifier);
-        validateScale(scale);
-
-        this.identifier = identifier.trim();
+        // Allow empty identifier for draft presets
+        // Validation will occur during save operation
+        this.identifier = identifier != null ? identifier.trim() : "";
         this.friendlyName = (friendlyName != null && !friendlyName.trim().isEmpty())
                 ? friendlyName.trim() : null;
+
+        validateScale(scale);
         this.scale = ScaleConstants.clampScale(scale);
         this.enabled = true;
     }
 
-    // ===== Validation Helper Methods =====
+    /**
+     * Validates that this preset is ready to be saved.
+     * @throws IllegalArgumentException if preset is invalid
+     */
+    public void validateForSave() {
+        validateIdentifier(this.identifier);
+        validateScale(this.scale);
+    }
 
     /**
-     * Validates and sets the scale value.
-     * @param scale The new scale value
-     * @throws IllegalArgumentException if scale is invalid
+     * Checks if this preset is valid for saving.
+     * @return true if valid, false otherwise
      */
+    public boolean isValidForSave() {
+        try {
+            validateForSave();
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    // ===== Validation Helper Methods =====
+
     public void setScaleValidated(float scale) {
         validateScale(scale);
         this.scale = ScaleConstants.clampScale(scale);
     }
 
-    /**
-     * Validates and sets the identifier.
-     * @param identifier The new identifier
-     * @throws IllegalArgumentException if identifier is invalid
-     */
     public void setIdentifierValidated(String identifier) {
         validateIdentifier(identifier);
         this.identifier = identifier.trim();
     }
 
     // ===== Core Methods =====
 
-    /**
-     * Creates a deep copy of this preset.
-     * @return A new PlayerPreset with identical values
-     */
     public PlayerPreset copy() {
         PlayerPreset copy = new PlayerPreset(this.identifier, this.friendlyName, this.scale);
         copy.enabled = this.enabled;
         return copy;
     }
 
-    /**
-     * Returns the display name for this preset.
-     * Uses friendly name if available, otherwise falls back to identifier.
-     * @return The effective display name
-     */
     public String getEffectiveDisplayName() {
         return (friendlyName != null && !friendlyName.isEmpty())
                 ? friendlyName
                 : identifier;
     }
 
-    /**
-     * Checks if this preset matches a given identifier (case-insensitive).
-     * Only returns true if the preset is enabled.
-     * @param id The identifier to check
-     * @return true if enabled and identifier matches
-     */
     public boolean matches(String id) {
         return enabled && identifier.equalsIgnoreCase(id);
     }
 
-    /**
-     * Checks if this preset matches a player by UUID or username.
-     * @param playerUUID The player's UUID
-     * @param playerName The player's name (can be null)
-     * @return true if enabled and matches either UUID or username
-     */
     public boolean matchesPlayer(UUID playerUUID, String playerName) {
         if (!enabled || playerUUID == null) {
             return false;
         }
 
-        // Check UUID match if identifier is a UUID
         if (isUUID()) {
             try {
                 return UUID.fromString(identifier).equals(playerUUID);
@@ -127,32 +105,19 @@ public boolean matchesPlayer(UUID playerUUID, String playerName) {
             }
         }
 
-        // Check username match (case insensitive)
         return playerName != null && identifier.equalsIgnoreCase(playerName);
     }
 
-    /**
-     * Attempts to resolve this preset's identifier to a UUID.
-     * @return The resolved UUID, or null if resolution fails
-     */
     public UUID resolveToUUID() {
         return PlayerUUIDResolver.resolvePlayerUUID(this.identifier);
     }
 
     // ===== Validation Methods =====
 
-    /**
-     * Checks if the identifier is in UUID format.
-     * @return true if identifier matches UUID pattern
-     */
     public boolean isUUID() {
         return identifier != null && identifier.matches(ScaleConstants.UUID_REGEX);
     }
 
-    /**
-     * Checks if the identifier is in username format.
-     * @return true if identifier matches username pattern
-     */
     public boolean isUsername() {
         return identifier != null && identifier.matches(ScaleConstants.USERNAME_REGEX);
     }
@@ -168,11 +133,6 @@ private void validateIdentifier(String identifier) {
         }
     }
 
-    /**
-     * Validates that a scale value is within acceptable range.
-     * @param scale The scale value to validate
-     * @throws IllegalArgumentException if scale is invalid
-     */
     private void validateScale(float scale) {
         if (!ScaleConstants.isValidScale(scale)) {
             throw new IllegalArgumentException(
diff --git a/src/main/java/com/github/kd_gaming1/scaleme/client/gui/components/PresetEditorComponent.java b/src/main/java/com/github/kd_gaming1/scaleme/client/gui/components/PresetEditorComponent.java
@@ -3,6 +3,7 @@
 import com.github.kd_gaming1.scaleme.client.data.PlayerPreset;
 import com.github.kd_gaming1.scaleme.client.util.PlayerPresetManager;
 import com.github.kd_gaming1.scaleme.client.util.PlayerUUIDResolver;
+import com.github.kd_gaming1.scaleme.client.util.ScaleConstants;
 import io.wispforest.owo.ui.component.ButtonComponent;
 import io.wispforest.owo.ui.component.Components;
 import io.wispforest.owo.ui.component.LabelComponent;
@@ -465,21 +466,38 @@ private void validateIdentifierFormat(String identifier) {
         }
 
         String trimmed = identifier.trim();
+
+        // Check for valid UUID format
         boolean isUUIDFormat = isValidUUID(trimmed);
-        boolean isUsernameFormat = trimmed.matches("^[a-zA-Z0-9_]{3,16}$");
+
+        // Check for valid username format (3-16 chars, alphanumeric + underscore)
+        boolean isUsernameFormat = trimmed.matches(ScaleConstants.USERNAME_REGEX);
 
         if (this.isNewPreset) {
             this.isIdentifierValid = isUsernameFormat;
-            this.statusLabel.text(Text.literal(isUsernameFormat
-                            ? "Username format - will resolve when saved"
-                            : "Only usernames (3-16 chars) are allowed when creating a new preset.")
-                    .formatted(isUsernameFormat ? Formatting.YELLOW : Formatting.RED));
+
+            String message;
+            Formatting color;
+
+            if (isUsernameFormat) {
+                message = "Username format valid - will resolve when saved";
+                color = Formatting.YELLOW;
+            } else if (trimmed.length() < 3) {
+                message = "Username too short (minimum 3 characters)";
+                color = Formatting.RED;
+            } else if (trimmed.length() > 16) {
+                message = "Username too long (maximum 16 characters)";
+                color = Formatting.RED;
+            } else {
+                message = "Invalid characters - use only letters, numbers, and underscores";
+                color = Formatting.RED;
+            }
+
+            this.statusLabel.text(Text.literal(message).formatted(color));
             validateField(this.identifierField, this.isIdentifierValid, 0xFFFFFFFF, 0xFFEB1D36);
         } else {
             this.isIdentifierValid = isUUIDFormat || isUsernameFormat;
-            this.statusLabel.text(Text.literal(isUUIDFormat
-                            ? "Valid UUID format"
-                            : "Username format")
+            this.statusLabel.text(Text.literal(isUUIDFormat ? "Valid UUID format" : "Username format")
                     .formatted(Formatting.GREEN));
         }
     }
@@ -512,7 +530,15 @@ private void updateScaleValueLabel(float scale) {
 
     private void onIdentifierChanged(String newValue) {
         if (!this.isNewPreset) return;
-        validateIdentifierFormat(newValue);
+
+        // Sanitize input: remove spaces and invalid characters
+        String sanitized = newValue.replaceAll("[^a-zA-Z0-9_]", "");
+        if (!sanitized.equals(newValue)) {
+            this.identifierField.text(sanitized);
+            return; // Will trigger this method again with sanitized value
+        }
+
+        validateIdentifierFormat(sanitized);
         this.hasUnsavedChanges = true;
         updateButtonStates();
     }
@@ -564,15 +590,34 @@ private void updateButtonStates() {
     }
 
     private void saveCurrentPreset() {
-        if (this.currentPreset == null || !this.isIdentifierValid) return;
+        if (this.currentPreset == null) return;
+
+        // Validate the preset before saving
+        try {
+            this.currentPreset.validateForSave();
+        } catch (IllegalArgumentException e) {
+            showErrorMessage("Cannot save: " + e.getMessage());
+            return;
+        }
+
+        if (!this.isIdentifierValid) {
+            showErrorMessage("Please provide a valid player identifier");
+            return;
+        }
 
         if (this.isNewPreset) {
             String inputIdentifier = this.identifierField.getText().trim();
 
+            // Additional validation for username format
+            if (!inputIdentifier.matches(ScaleConstants.USERNAME_REGEX)) {
+                showErrorMessage("Invalid username format. Use 3-16 alphanumeric characters or underscores.");
+                return;
+            }
+
             // Resolve UUID from username
             UUID resolvedUUID = PlayerUUIDResolver.resolvePlayerUUID(inputIdentifier);
             if (resolvedUUID == null) {
-                showErrorMessage("Failed to resolve player: " + inputIdentifier + ". Please check the username.");
+                showErrorMessage("Failed to resolve player: " + inputIdentifier + ". Player must be online or check the username.");
                 return;
             }
 
@@ -584,6 +629,12 @@ private void saveCurrentPreset() {
             }
         }
 
+        // Final validation before saving
+        if (!this.currentPreset.isValidForSave()) {
+            showErrorMessage("Preset contains invalid data and cannot be saved");
+            return;
+        }
+
         // Save the preset
         PlayerPresetManager.addOrUpdatePreset(this.currentPreset);
 
@@ -601,7 +652,7 @@ private void saveCurrentPreset() {
         updateButtonStates();
         updateTitle();
         updateStatusLabel();
-        showEditorState(); // Refresh to hide help container and update info
+        showEditorState();
 
         if (this.onPresetUpdated != null) {
             this.onPresetUpdated.accept(this.currentPreset);
diff --git a/src/main/java/com/github/kd_gaming1/scaleme/client/util/PlayerPresetManager.java b/src/main/java/com/github/kd_gaming1/scaleme/client/util/PlayerPresetManager.java
@@ -138,6 +138,14 @@ public static void addOrUpdatePreset(PlayerPreset preset) {
             return;
         }
 
+        // Validate before saving
+        try {
+            preset.validateForSave();
+        } catch (IllegalArgumentException e) {
+            LOGGER.error("Preset validation failed: {}", e.getMessage());
+            throw new IllegalArgumentException("Cannot save invalid preset: " + e.getMessage(), e);
+        }
+
         // Remove existing preset with same identifier
         removePresetQuiet(preset.identifier);
 
diff --git a/src/main/java/com/github/kd_gaming1/scaleme/client/util/ScaleManager.java b/src/main/java/com/github/kd_gaming1/scaleme/client/util/ScaleManager.java
@@ -28,9 +28,11 @@ public static void tick() {
      * Get current scale for a player.
      */
     public static float getCurrentScale(UUID playerUUID) {
+        if (playerUUID == null) {
+            return ScaleConstants.DEFAULT_SCALE;
+        }
         return PlayerPresetManager.getCurrentScale(playerUUID);
     }
-
     /** Returns NPC scale with safety check including dungeons detection. */
     public static float getNpcScale() {
         // Only apply scaling when it's safe (not in competitive modes or dungeons)
