Improve support for 1.8.8

Author: broken1arrow

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/CreateItemStack.java

@@ -6,6 +6,7 @@
 import org.broken.arrow.library.itemcreator.meta.BottleEffectMeta;
 import org.broken.arrow.library.itemcreator.meta.enhancement.EnhancementMeta;
 import org.broken.arrow.library.itemcreator.meta.MetaHandler;
+import org.broken.arrow.library.itemcreator.meta.potion.PotionTypeWrapper;
 import org.broken.arrow.library.itemcreator.utility.ConvertToItemStack;
 import org.broken.arrow.library.itemcreator.utility.Tuple;
 import org.broken.arrow.library.itemcreator.utility.builders.ItemBuilder;
@@ -22,6 +23,7 @@
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.Damageable;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.PotionMeta;
 import org.bukkit.potion.PotionEffect;
 
 import javax.annotation.Nonnull;
@@ -919,7 +921,7 @@ private ItemStack checkTypeOfItem() {
             }
             ConvertToItemStack convertToItemStack = this.getConvertItems();
             if (builder.getMaterial() != null) {
-                if (serverVersion > 1.12) {
+                if (serverVersion > 12.2f) {
                     result = new ItemStack(builder.getMaterial());
                 } else {
                     result = convertToItemStack.checkItem(builder.getMaterial(), this.getDamage(), this.color, this.getData());
@@ -937,7 +939,7 @@ private ItemStack checkTypeOfItem(final Object object) {
         return getConvertItems().checkItem(object);
     }
 
-    private void addItemMeta(ItemStack itemStack, final ItemMeta itemMeta) {
+    private void addItemMeta(@Nonnull final ItemStack itemStack,@Nonnull final ItemMeta itemMeta) {
         this.setDamageMeta(itemStack, itemMeta);
         if (this.serverVersion > 10.0F)
             setUnbreakableMeta(itemMeta);
@@ -947,15 +949,30 @@ private void addItemMeta(ItemStack itemStack, final ItemMeta itemMeta) {
             hideEnchantments(itemMeta);
     }
 
-    private void setDamageMeta(ItemStack itemStack, ItemMeta itemMeta) {
-        short dmg = this.getDamage();
+    private void setDamageMeta(final ItemStack itemStack,final ItemMeta itemMeta) {
+        short dmg = getDmg(itemMeta);
         if (dmg > 0) {
-            if (serverVersion < 1.13) {
-                itemStack.setDurability(dmg);
-            } else {
+            if (serverVersion > 12.2F) {
                 ((Damageable) itemMeta).setDamage(dmg);
+            } else {
+                itemStack.setDurability(dmg);
+            }
+        }
+    }
+
+    private short getDmg(@Nonnull final ItemMeta itemMeta) {
+        final MetaHandler handler = getMetaHandler();
+        if (itemMeta instanceof PotionMeta && handler != null) {
+            final BottleEffectMeta bottleEffect = handler.getBottleEffect();
+
+            if (bottleEffect != null && bottleEffect.getPotionEffects().isEmpty()) {
+                final PotionTypeWrapper potionTypeWrapper = bottleEffect.getPotionTypeWrapper();
+                if (potionTypeWrapper != null) {
+                    return potionTypeWrapper.toLegacyDamage();
+                }
             }
         }
+        return this.getDamage();
     }
 
     private void hideEnchantments(final ItemMeta itemMeta) {

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/SkullCreator.java

@@ -282,7 +282,7 @@ public static void blockWithUrl(@Nonnull final Block block, @Nonnull final UUID
         final BlockState skullState = block.getState();
         if (!(skullState instanceof Skull)) return;
 
-        if (checks.isDoesHavePlayerProfile()) {
+        if (checks.isDoesHaveOwnerProfile()) {
             PlayerProfile profile = Bukkit.createPlayerProfile(id);
             if (url != null) {
                 try {
@@ -681,7 +681,6 @@ public static class CheckClassesExist {
         private boolean legacy;
         private boolean warningPosted = false;
         private boolean doesHaveOwnerProfile = true;
-        private boolean doesHavePlayerProfile = true;
 
         /**
          * When instance is created it will check what classes exists for your minecraft version.
@@ -694,12 +693,6 @@ public CheckClassesExist() {
             } catch (ClassNotFoundException | NoSuchMethodException e) {
                 legacy = true;
             }
-            try {
-                final UUID id = UUID.randomUUID();
-                PlayerProfile profile = Bukkit.createPlayerProfile(id);
-            } catch (NoClassDefFoundError | NoSuchMethodError e) {
-                doesHavePlayerProfile = false;
-            }
             final ItemStack skull = createSkull();
             if (skull != null) {
                 final ItemMeta skullMeta = Bukkit.getItemFactory().getItemMeta(skull.getType());
@@ -728,23 +721,14 @@ public boolean isWarningPosted() {
         }
 
         /**
-         * Checks if it has OwnerProfile setter in the metadata class.
+         * Checks if it has OwnerProfile setter in the metadata class and PlayerProfile class.
          *
          * @return Returns true if the profile exists.
          */
         public boolean isDoesHaveOwnerProfile() {
             return doesHaveOwnerProfile;
         }
 
-        /**
-         * If it modern version where PlayerProfile class exists.
-         *
-         * @return Returns true if PlayerProfile class exists.
-         */
-        public boolean isDoesHavePlayerProfile() {
-            return doesHavePlayerProfile;
-        }
-
         /**
          * Checks if running on legacy Bukkit API and logs a warning if using legacy API on modern server.
          */

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/meta/BottleEffectMeta.java

@@ -139,6 +139,20 @@ public PotionType getPotionType() {
         return (this.potionTypeWrapper == null ? null : this.potionTypeWrapper.getPotionType());
     }
 
+    /**
+     * Returns the predefined {@link PotionTypeWrapper} associated with this potion, if available.
+     *
+     * <p>This wrapper can provide additional metadata or configuration not exposed by
+     * the standard {@link PotionType} from the Bukkit/Spigot API, useful when legacy
+     * values, extended information, or custom behavior is required.</p>
+     *
+     * @return the associated {@code PotionTypeWrapper}, or {@code null} if none is set.
+     */
+    @Nullable
+    public PotionTypeWrapper getPotionTypeWrapper () {
+        return  this.potionTypeWrapper;
+    }
+
     /**
      * Gets the predefined {@link PotionType} to apply to the potion, if any.
      * <p>

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/meta/potion/PotionTypeWrapper.java

@@ -28,15 +28,15 @@ public enum PotionTypeWrapper {
     /**
      * Mundane potion (no special effects).
      */
-    MUNDANE(PotionType.MUNDANE, PotionModifier.NORMAL),
+    MUNDANE(getMundane(), PotionModifier.NORMAL),
     /**
      * Thick potion (usually for brewing).
      */
-    THICK(PotionType.THICK, PotionModifier.NORMAL),
+    THICK(getPotionType("THICK"), PotionModifier.NORMAL),
     /**
      * Awkward potion (base potion for many effects).
      */
-    AWKWARD(PotionType.AWKWARD, PotionModifier.NORMAL),
+    AWKWARD(getPotionType("AWKWARD"), PotionModifier.NORMAL),
     /**
      * Night Vision potion, normal duration.
      */
@@ -168,7 +168,7 @@ public enum PotionTypeWrapper {
     /**
      * Luck potion, normal duration (if applicable).
      */
-    LUCK(PotionType.LUCK, PotionModifier.NORMAL),
+    LUCK(getPotionType("LUCK"), PotionModifier.NORMAL),
     /**
      * Turtle Master potion, normal duration.
      */
@@ -213,7 +213,7 @@ private static Map<String, PotionTypeWrapper> loadPotions() {
         for (PotionTypeWrapper data : values()) {
             typeWrapperHashMap.put(data.getPotionType().name(), data);
         }
-        return typeWrapperHashMap ;
+        return typeWrapperHashMap;
     }
 
     /**
@@ -245,7 +245,7 @@ public PotionType getPotionType() {
      */
     @Nullable
     public static PotionTypeWrapper findPotionByType(final PotionType bukkitPotionType) {
-        if(bukkitPotionType == null)
+        if (bukkitPotionType == null)
             return null;
         return POTION_TYPE_NAME.get(bukkitPotionType.name());
     }
@@ -372,6 +372,109 @@ private PotionType getPotionMapping() {
         }
     }
 
+    /**
+     * Converts this {@code PotionTypeWrapper} to the legacy pre-1.12 potion
+     * "damage" (durability) value.
+     *
+     * <p>In Minecraft versions prior to 1.12 (including 1.8.x), potion types are
+     * encoded in the item damage value of a potion ItemStack. This method returns
+     * the corresponding legacy short value that can be written via
+     * {@link org.bukkit.inventory.ItemStack#setDurability} or
+     * {@link org.bukkit.inventory.meta.Damageable#setDamage}.</p>
+     *
+     * <p>If this potion type cannot be represented in legacy (e.g., newer potion
+     * types or special variants), the method returns {@code 0}, which corresponds
+     * to a water bottle, acting as a safe fallback.</p>
+     *
+     * <p><b>Note:</b> If the ItemStack has custom potion effects, you generally
+     * should not overwrite its damage value, unless you specifically need a
+     * legacy-compatible representation.</p>
+     *
+     * @return the legacy potion damage value usable on pre-1.12 servers/clients.
+     */
+    public short toLegacyDamage() {
+        switch (this) {
+            case NIGHT_VISION:
+                return 8230;
+            case LONG_NIGHT_VISION:
+                return 8262;
+
+            case INVISIBILITY:
+                return 8238;
+            case LONG_INVISIBILITY:
+                return 8270;
+
+            case JUMP:
+                return 8203;
+            case LONG_LEAPING:
+                return 8267;
+            case STRONG_LEAPING:
+                return 8235;
+
+            case FIRE_RESISTANCE:
+                return 8227;
+            case LONG_FIRE_RESISTANCE:
+                return 8259;
+
+            case SPEED:
+                return 8194;
+            case LONG_SWIFTNESS:
+                return 8258;
+            case STRONG_SWIFTNESS:
+                return 8226;
+
+            case SLOWNESS:
+                return 8234;
+            case LONG_SLOWNESS:
+                return 8266;
+            case STRONG_SLOWNESS:
+                return 8202;
+
+            case WATER_BREATHING:
+                return 8237;
+            case LONG_WATER_BREATHING:
+                return 8269;
+
+            case INSTANT_HEAL:
+                return 8261;
+            case STRONG_HEALING:
+                return 8229;
+
+            case INSTANT_DAMAGE:
+                return 8268;
+            case STRONG_HARMING:
+                return 8236;
+
+            case POISON:
+                return 8196;
+            case LONG_POISON:
+                return 8260;
+            case STRONG_POISON:
+                return 8228;
+
+            case REGEN:
+                return 8193;
+            case LONG_REGENERATION:
+                return 8257;
+            case STRONG_REGENERATION:
+                return 8225;
+
+            case STRENGTH:
+                return 8201;
+            case LONG_STRENGTH:
+                return 8265;
+            case STRONG_STRENGTH:
+                return 8233;
+
+            case LONG_WEAKNESS:
+                return 8264;
+            case WEAKNESS:
+                return 8232;
+            default:
+                return 0;
+        }
+    }
+
     /**
      * Attempting to get the uncraftable type, this default back
      * to mundane on newer Minecraft versions like 1.21 and beyond.
@@ -384,7 +487,20 @@ private static PotionType getUncraftable() {
         try {
             return PotionType.valueOf("UNCRAFTABLE");
         } catch (IllegalArgumentException | NoSuchFieldError ex) {
-            return PotionType.MUNDANE;
+            try {
+                return PotionType.MUNDANE;
+            } catch (NoSuchFieldError exception) {
+                return PotionType.WATER;
+            }
+        }
+    }
+
+    @Nonnull
+    private static PotionType getMundane() {
+        try {
+            return PotionType.valueOf("MUNDANE");
+        } catch (IllegalArgumentException | NoSuchFieldError ex) {
+            return PotionType.WATER;
         }
     }
 

Item Creator/src/main/java/org/broken/arrow/library/itemcreator/meta/potion/PotionsUtility.java

@@ -3,6 +3,7 @@
 import org.broken.arrow.library.itemcreator.ItemCreator;
 import org.broken.arrow.library.logging.Logging;
 import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.Potion;
 import org.bukkit.potion.PotionData;
 import org.bukkit.potion.PotionType;
 
@@ -79,6 +80,10 @@ public void setPotion(@Nonnull final PotionType potion, @Nullable final PotionMo
             return;
         }
 
+        if (serverVersion < 9.0F) {
+            return;
+        }
+
         try {
             boolean couldUpgrade = potionModifier == PotionModifier.STRONG;
             boolean couldExtended = potionModifier == PotionModifier.LONG;