v8.4.0

Titles
Now uses Player#setPlayerListHeaderFooter() for sendTabList()

XMaterial
Added 1.16+ getId() support.
Removed the material version as it wasn't really that useful.
Removed glazed terracotta data values because they were unused.
Fixed potted flower materials for pre-1.13
Fixed spruce and dark oak leaves material for pre-1.13

XBlock
setBlock() now supports all the legacy materials.

Author: CryptoMorin

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.cryptomorin</groupId>
     <artifactId>XSeries</artifactId>
-    <version>8.3.0</version>
+    <version>8.4.0</version>
 
     <name>XSeries</name>
     <description>A set of utilities for Minecraft plugins</description>

src/main/java/com/cryptomorin/xseries/XBlock.java

@@ -25,12 +25,14 @@
 import org.bukkit.DyeColor;
 import org.bukkit.Material;
 import org.bukkit.TreeSpecies;
+import org.bukkit.block.Banner;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.material.*;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.util.*;
 
@@ -62,10 +64,26 @@ public final class XBlock {
     ));
     public static final byte CAKE_SLICES = 6;
     private static final boolean ISFLAT = XMaterial.supports(13);
+    private static final Map<XMaterial, XMaterial> ITEM_TO_BLOCK = new EnumMap<>(XMaterial.class);
 
-    private XBlock() {
+    static {
+        ITEM_TO_BLOCK.put(XMaterial.MELON_SLICE, XMaterial.MELON_STEM);
+        ITEM_TO_BLOCK.put(XMaterial.MELON_SEEDS, XMaterial.MELON_STEM);
+
+        ITEM_TO_BLOCK.put(XMaterial.CARROT_ON_A_STICK, XMaterial.CARROTS);
+        ITEM_TO_BLOCK.put(XMaterial.GOLDEN_CARROT, XMaterial.CARROTS);
+        ITEM_TO_BLOCK.put(XMaterial.CARROT, XMaterial.CARROTS);
+
+        ITEM_TO_BLOCK.put(XMaterial.POTATO, XMaterial.POTATOES);
+        ITEM_TO_BLOCK.put(XMaterial.BAKED_POTATO, XMaterial.POTATOES);
+        ITEM_TO_BLOCK.put(XMaterial.POISONOUS_POTATO, XMaterial.POTATOES);
+
+        ITEM_TO_BLOCK.put(XMaterial.PUMPKIN_SEEDS, XMaterial.PUMPKIN_STEM);
+        ITEM_TO_BLOCK.put(XMaterial.PUMPKIN_PIE, XMaterial.PUMPKIN);
     }
 
+    private XBlock() { }
+
     public static boolean isLit(Block block) {
         if (ISFLAT) {
             if (!(block.getBlockData() instanceof org.bukkit.block.data.Lightable)) return false;
@@ -213,25 +231,114 @@ public static boolean setDirection(Block block, BlockFace facing) {
         return false;
     }
 
+    public static boolean setType(@Nonnull Block block, @Nullable XMaterial material) {
+        Objects.requireNonNull(block, "Cannot set type of null block");
+        if (material == null) material = XMaterial.AIR;
+        XMaterial smartConversion = ITEM_TO_BLOCK.get(material);
+        if (smartConversion != null) material = smartConversion;
+        if (material.parseMaterial() == null) return false;
 
-    private static String getMetaString(XMaterial material) {
-        return material.name().substring(0, material.name().indexOf('_'));
-    }
-
-    public static boolean setType(Block block, XMaterial material) {
         block.setType(material.parseMaterial());
         if (XMaterial.supports(13)) return false;
 
+        String parsedName = material.parseMaterial().name();
+        if (parsedName.endsWith("_ITEM")) {
+            String blockName = parsedName.substring(0, parsedName.length() - "_ITEM".length());
+            Material blockMaterial = Objects.requireNonNull(Material.getMaterial(blockName),
+                    () -> "Could not find block material for item '" + parsedName + "' as '" + blockName + '\'');
+            block.setType(blockMaterial);
+        } else if (parsedName.contains("CAKE")) {
+            Material blockMaterial = Material.getMaterial("CAKE_BLOCK");
+            block.setType(blockMaterial);
+        }
+
+        LegacyMaterial legacyMaterial = LegacyMaterial.getMaterial(parsedName);
+        if (legacyMaterial == LegacyMaterial.BANNER) block.setType(LegacyMaterial.STANDING_BANNER.material);
+        LegacyMaterial.Handling handling = legacyMaterial == null ? null : legacyMaterial.handling;
+
         BlockState state = block.getState();
-        MaterialData data = state.getData();
         boolean update = false;
 
-        if (data instanceof Wood) {
-            Wood wood = (Wood) data;
-            wood.setSpecies(TreeSpecies.valueOf(getMetaString(material)));
+        if (handling == LegacyMaterial.Handling.COLORABLE) {
+            if (state instanceof Banner) {
+                Banner banner = (Banner) state;
+                String xName = material.name();
+                int colorIndex = xName.indexOf('_');
+                String color = xName.substring(0, colorIndex);
+                if (color.equals("LIGHT")) color = xName.substring(0, "LIGHT_".length() + 4);
+
+                banner.setBaseColor(DyeColor.valueOf(color));
+            } else state.setRawData(material.getData());
             update = true;
-        } else if (data instanceof Colorable) {
-            ((Colorable) data).setColor(DyeColor.valueOf(getMetaString(material)));
+        } else if (handling == LegacyMaterial.Handling.WOOD_SPECIES) {
+            // Wood doesn't exist in 1.8
+            // https://hub.spigotmc.org/stash/projects/SPIGOT/repos/bukkit/browse/src/main/java/org/bukkit/material/Wood.java?until=7d83cba0f2575112577ed7a091ed8a193bfc261a&untilPath=src%2Fmain%2Fjava%2Forg%2Fbukkit%2Fmaterial%2FWood.java
+            // https://hub.spigotmc.org/stash/projects/SPIGOT/repos/bukkit/browse/src/main/java/org/bukkit/TreeSpecies.java
+
+            String name = material.name();
+            int firstIndicator = name.indexOf('_');
+            if (firstIndicator < 0) return false;
+            String woodType = name.substring(0, firstIndicator);
+
+            TreeSpecies species;
+            switch (woodType) {
+                case "OAK":
+                    species = TreeSpecies.GENERIC;
+                    break;
+                case "DARK":
+                    species = TreeSpecies.DARK_OAK;
+                    break;
+                case "SPRUCE":
+                    species = TreeSpecies.REDWOOD;
+                    break;
+                default: {
+                    try {
+                        species = TreeSpecies.valueOf(woodType);
+                    } catch (IllegalArgumentException ex) {
+                        throw new AssertionError("Unknown material " + legacyMaterial + " for wood species");
+                    }
+                }
+            }
+
+            // Doesn't handle stairs, slabs, fence and fence gates as they had their own separate materials.
+            boolean firstType = false;
+            switch (legacyMaterial) {
+                case WOOD:
+                case WOOD_DOUBLE_STEP:
+                    state.setRawData(species.getData());
+                    update = true;
+                    break;
+                case LOG:
+                case LEAVES:
+                    firstType = true;
+                    // fall through to next switch statement below
+                case LOG_2:
+                case LEAVES_2:
+                    switch (species) {
+                        case GENERIC:
+                        case REDWOOD:
+                        case BIRCH:
+                        case JUNGLE:
+                            if (!firstType) throw new AssertionError("Invalid tree species " + species + " for block type" + legacyMaterial + ", use block type 2 instead");
+                            break;
+                        case ACACIA:
+                        case DARK_OAK:
+                            if (firstType) throw new AssertionError("Invalid tree species " + species + " for block type 2 " + legacyMaterial + ", use block type instead");
+                            break;
+                    }
+                    state.setRawData((byte) ((state.getRawData() & 0xC) | (species.getData() & 0x3)));
+                    update = true;
+                    break;
+                case SAPLING:
+                case WOOD_STEP:
+                    state.setRawData((byte) ((state.getRawData() & 0x8) | species.getData()));
+                    update = true;
+                    break;
+                default:
+                    throw new AssertionError("Unknown block type " + legacyMaterial + " for tree species: " + species);
+            }
+        } else if (material.getData() != 0) {
+            state.setRawData(material.getData());
             update = true;
         }
 
@@ -423,20 +530,6 @@ public static int addCakeSlices(Block block, int slices) {
         }
     }
 
-    public static boolean setWooden(Block block, XMaterial species) {
-        block.setType(species.parseMaterial());
-        if (ISFLAT) return true;
-
-        TreeSpecies type = species == XMaterial.SPRUCE_LOG ? TreeSpecies.REDWOOD :
-                TreeSpecies.valueOf(getMetaString(species));
-
-        BlockState state = block.getState();
-        MaterialData data = state.getData();
-        ((Wood) data).setSpecies(type);
-        state.update(true);
-        return true;
-    }
-
     public static void setEnderPearlOnFrame(Block endPortalFrame, boolean eye) {
         BlockState state = endPortalFrame.getState();
         if (ISFLAT) {
@@ -638,6 +731,40 @@ private static boolean isMaterial(Block block, BlockMaterial... materials) {
         return false;
     }
 
+    private enum LegacyMaterial {
+        // Colorable
+        STANDING_BANNER(Handling.COLORABLE), WALL_BANNER(Handling.COLORABLE), BANNER(Handling.COLORABLE),
+        CARPET(Handling.COLORABLE), WOOL(Handling.COLORABLE), STAINED_CLAY(Handling.COLORABLE),
+        STAINED_GLASS(Handling.COLORABLE), STAINED_GLASS_PANE(Handling.COLORABLE), THIN_GLASS(Handling.COLORABLE),
+
+        // Wood Species
+        WOOD(Handling.WOOD_SPECIES), WOOD_STEP(Handling.WOOD_SPECIES), WOOD_DOUBLE_STEP(Handling.WOOD_SPECIES),
+        LEAVES(Handling.WOOD_SPECIES), LEAVES_2(Handling.WOOD_SPECIES),
+        LOG(Handling.WOOD_SPECIES), LOG_2(Handling.WOOD_SPECIES),
+        SAPLING(Handling.WOOD_SPECIES);
+
+        private static final Map<String, LegacyMaterial> LOOKUP = new HashMap<>();
+
+        static {
+            for (LegacyMaterial legacyMaterial : values()) {
+                LOOKUP.put(legacyMaterial.name(), legacyMaterial);
+            }
+        }
+
+        private final Material material = Material.getMaterial(name());
+        private final Handling handling;
+
+        LegacyMaterial(Handling handling) {
+            this.handling = handling;
+        }
+
+        private static LegacyMaterial getMaterial(String name) {
+            return LOOKUP.get(name);
+        }
+
+        private enum Handling {COLORABLE, WOOD_SPECIES;}
+    }
+
     /**
      * An enum with cached legacy materials which can be used when comparing blocks with blocks and blocks with items.
      *