From beb80f0422214933dc93e1cd6b8d09868ccef465 Mon Sep 17 00:00:00 2001 From: cyberpwn Date: Sun, 22 Aug 2021 03:04:24 -0400 Subject: [PATCH] Modernize B --- .../java/com/volmit/iris/util/data/B.java | 818 ++++++++---------- 1 file changed, 374 insertions(+), 444 deletions(-) diff --git a/src/main/java/com/volmit/iris/util/data/B.java b/src/main/java/com/volmit/iris/util/data/B.java index 25fc1b483..9a09b0b81 100644 --- a/src/main/java/com/volmit/iris/util/data/B.java +++ b/src/main/java/com/volmit/iris/util/data/B.java @@ -22,7 +22,12 @@ import com.volmit.iris.Iris; import com.volmit.iris.core.IrisSettings; import com.volmit.iris.util.collection.KList; import com.volmit.iris.util.collection.KMap; -import com.volmit.iris.util.collection.KSet; +import com.volmit.iris.util.scheduling.ChronoLatch; +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; +import it.unimi.dsi.fastutil.ints.IntSet; +import it.unimi.dsi.fastutil.ints.IntSets; +import it.unimi.dsi.fastutil.objects.ReferenceLinkedOpenHashSet; +import it.unimi.dsi.fastutil.objects.ReferenceSet; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.block.data.BlockData; @@ -33,388 +38,192 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Collectors; +import static org.bukkit.Material.*; + public class B { private static final Material AIR_MATERIAL = Material.AIR; private static final BlockData AIR = AIR_MATERIAL.createBlockData(); - private static final KSet nullBlockDataCache = new KSet<>(); - private static final KSet nullMaterialCache = new KSet<>(); - private static final KMap solidCache = new KMap<>(); - private static final KMap updatableCache = new KMap<>(); - private static final KMap foliageCache = new KMap<>(); - private static final KMap litCache = new KMap<>(); - private static final KMap decorantCache = new KMap<>(); - private static final KMap storageCache = new KMap<>(); - private static final KMap storageChestCache = new KMap<>(); + private static final IntSet decorantCache = buildDecorantCache(); + private static final IntSet foliageCache = buildFoliageCache(); + private static final IntSet storageCache = buildStorageCache(); + private static final IntSet storageChestCache = buildStorageChestCache(); + private static final IntSet litCache = buildLitCache(); private static final KMap blockDataCache = new KMap<>(); - private static final KMap materialCache = new KMap<>(); + private static final ChronoLatch clw = new ChronoLatch(1000); - public static boolean isWater(BlockData b) { - return b.getMaterial().equals(Material.WATER); + private static IntSet buildFoliageCache() { + IntSet b = new IntOpenHashSet(); + Arrays.stream(new Material[]{ + POPPY, + DANDELION, + CORNFLOWER, + SWEET_BERRY_BUSH, + CRIMSON_ROOTS, + WARPED_ROOTS, + NETHER_SPROUTS, + ALLIUM, + AZURE_BLUET, + BLUE_ORCHID, + POPPY, + DANDELION, + OXEYE_DAISY, + LILY_OF_THE_VALLEY, + WITHER_ROSE, + DARK_OAK_SAPLING, + ACACIA_SAPLING, + JUNGLE_SAPLING, + BIRCH_SAPLING, + SPRUCE_SAPLING, + OAK_SAPLING, + ORANGE_TULIP, + PINK_TULIP, + RED_TULIP, + WHITE_TULIP, + FERN, + LARGE_FERN, + GRASS, + TALL_GRASS + }).forEach((i) -> b.add(i.ordinal())); + + return IntSets.unmodifiable(b); } - public static BlockData getAir() { - return AIR; + private static IntSet buildDecorantCache() { + IntSet b = new IntOpenHashSet(); + Arrays.stream(new Material[]{ + + GRASS, + TALL_GRASS, + FERN, + LARGE_FERN, + CORNFLOWER, + SUNFLOWER, + CHORUS_FLOWER, + POPPY, + DANDELION, + OXEYE_DAISY, + ORANGE_TULIP, + PINK_TULIP, + RED_TULIP, + WHITE_TULIP, + LILAC, + DEAD_BUSH, + SWEET_BERRY_BUSH, + ROSE_BUSH, + WITHER_ROSE, + ALLIUM, + BLUE_ORCHID, + LILY_OF_THE_VALLEY, + CRIMSON_FUNGUS, + WARPED_FUNGUS, + RED_MUSHROOM, + BROWN_MUSHROOM, + CRIMSON_ROOTS, + AZURE_BLUET, + WEEPING_VINES, + WEEPING_VINES_PLANT, + WARPED_ROOTS, + NETHER_SPROUTS, + TWISTING_VINES, + TWISTING_VINES_PLANT, + SUGAR_CANE, + WHEAT, + POTATOES, + CARROTS, + BEETROOTS, + NETHER_WART, + SEA_PICKLE, + SEAGRASS, + ACACIA_BUTTON, + BIRCH_BUTTON, + CRIMSON_BUTTON, + DARK_OAK_BUTTON, + JUNGLE_BUTTON, + OAK_BUTTON, + POLISHED_BLACKSTONE_BUTTON, + SPRUCE_BUTTON, + STONE_BUTTON, + WARPED_BUTTON, + TORCH, + SOUL_TORCH + }).forEach((i) -> b.add(i.ordinal())); + + return IntSets.unmodifiable(b); } - public static Material getMaterial(String bdx) { - Material mat = getMaterialOrNull(bdx); + private static IntSet buildLitCache() { + IntSet b = new IntOpenHashSet(); + Arrays.stream(new Material[]{ + GLOWSTONE, + END_ROD, + SOUL_SAND, + TORCH, + REDSTONE_TORCH, + SOUL_TORCH, + REDSTONE_WALL_TORCH, + WALL_TORCH, + SOUL_WALL_TORCH, + LANTERN, + CANDLE, + JACK_O_LANTERN, + REDSTONE_LAMP, + MAGMA_BLOCK, + SHROOMLIGHT, + SEA_LANTERN, + SOUL_LANTERN, + FIRE, + SOUL_FIRE, + SEA_PICKLE, + BREWING_STAND, + REDSTONE_ORE, + }).forEach((i) -> b.add(i.ordinal())); - if (mat != null) { - return mat; - } - - return AIR_MATERIAL; + return IntSets.unmodifiable(b); } - public static Material getMaterialOrNull(String bdxx) { - String bx = bdxx.trim().toUpperCase(); + private static IntSet buildStorageCache() { + IntSet b = new IntOpenHashSet(); + Arrays.stream(new Material[]{ + CHEST, SMOKER, + TRAPPED_CHEST, + SHULKER_BOX, + WHITE_SHULKER_BOX, + ORANGE_SHULKER_BOX, + MAGENTA_SHULKER_BOX, + LIGHT_BLUE_SHULKER_BOX, + YELLOW_SHULKER_BOX, + LIME_SHULKER_BOX, + PINK_SHULKER_BOX, + GRAY_SHULKER_BOX, + LIGHT_GRAY_SHULKER_BOX, + CYAN_SHULKER_BOX, + PURPLE_SHULKER_BOX, + BLUE_SHULKER_BOX, + BROWN_SHULKER_BOX, + GREEN_SHULKER_BOX, + RED_SHULKER_BOX, + BLACK_SHULKER_BOX, + BARREL, + DISPENSER, + DROPPER, + HOPPER, + FURNACE, + BLAST_FURNACE + }).forEach((i) -> b.add(i.ordinal())); - if (nullMaterialCache.contains(bx)) { - return null; - } - - Material mat = materialCache.get(bx); - - if (mat != null) { - return mat; - } - - try { - Material mm = Material.valueOf(bx); - materialCache.put(bx, mm); - return mm; - } catch (Throwable e) { - Iris.reportError(e); - nullMaterialCache.add(bx); - return null; - } + return IntSets.unmodifiable(b); } - public static boolean isSolid(BlockData mat) { - return isSolid(mat.getMaterial()); - } + private static IntSet buildStorageChestCache() { + IntSet b = new IntOpenHashSet(storageCache); + b.remove(SMOKER.ordinal()); + b.remove(FURNACE.ordinal()); + b.remove(BLAST_FURNACE.ordinal()); - public static boolean isSolid(Material mat) { - Boolean solid = solidCache.get(mat); - - if (solid != null) { - return solid; - } - - solid = mat.isSolid(); - solidCache.put(mat, solid); - - return solid; - } - - public static BlockData getOrNull(String bdxf) { - try { - String bd = bdxf.trim(); - BlockData bdx = parseBlockData(bd); - - if (bdx == null) { - Iris.warn("Unknown Block Data '" + bd + "'"); - return AIR; - } - - return bdx; - } catch (Throwable e) { - Iris.reportError(e); - Iris.warn("Unknown Block Data '" + bdxf + "'"); - } - - return null; - } - - public static BlockData get(String bdxf) { - BlockData bd = getOrNull(bdxf); - - if (bd != null) { - return bd; - } - - return AIR; - } - - private static BlockData parseBlockDataOrNull(String ix) { - if (nullBlockDataCache.contains(ix)) { - return null; - } - - try { - BlockData bb = blockDataCache.get(ix); - - if (bb != null) { - return bb; - } - BlockData bx = null; - - if (ix.startsWith("oraxen:") && Iris.linkOraxen.supported()) { - bx = Iris.linkOraxen.getBlockDataFor(ix.split("\\Q:\\E")[1]); - } - - if (bx == null) { - bx = Bukkit.createBlockData(ix); - } - - if (bx instanceof Leaves && IrisSettings.get().getGenerator().preventLeafDecay) { - ((Leaves) bx).setPersistent(true); - } else if (bx instanceof Leaves) { - ((Leaves) bx).setPersistent(false); - } - - blockDataCache.put(ix, bx); - return bx; - } catch (Exception e) { - //Iris.reportError(e); - Iris.debug("Failed to load block \"" + ix + "\""); - - String block = ix.contains(":") ? ix.split(":")[1].toLowerCase() : ix.toLowerCase(); - String state = block.contains("[") ? block.split("\\[")[1].split("\\]")[0] : ""; - Map stateMap = new HashMap<>(); - if (!state.equals("")) { - Arrays.stream(state.split(",")).forEach(s -> { - stateMap.put(s.split("=")[0], s.split("=")[1]); - }); - } - block = block.split("\\[")[0]; - - switch (block) { - case "cauldron" -> block = "water_cauldron"; //Would fail to load if it has a level parameter - case "grass_path" -> block = "dirt_path"; - case "concrete" -> block = "white_concrete"; - case "wool" -> block = "white_wool"; - case "beetroots" -> { - if (stateMap.containsKey("age")) { - String updated = stateMap.get("age"); - switch (updated) { - case "7" -> updated = "3"; - case "3", "4", "5" -> updated = "2"; - case "1", "2" -> updated = "1"; - } - stateMap.put("age", updated); - } - } - } - - Map newStates = new HashMap<>(); - for (String key : stateMap.keySet()) { //Iterate through every state and check if its valid - try { - String newState = block + "[" + key + "=" + stateMap.get(key) + "]"; - Bukkit.createBlockData(newState); - - //If we get to here, the state is okay so we can use it - newStates.put(key, stateMap.get(key)); - - } catch (IllegalArgumentException ignored) { - } - } - - //Combine all the "good" states again - state = newStates.entrySet().stream().map(entry -> entry.getKey() + "=" + entry.getValue()).collect(Collectors.joining(",")); - if (!state.equals("")) state = "[" + state + "]"; - String newBlock = block + state; - Iris.debug("Converting " + ix + " to " + newBlock); - - try { - BlockData bd = Bukkit.createBlockData(newBlock); - blockDataCache.put(ix, bd); - return bd; - } catch (Throwable e1) { - Iris.reportError(e1); - } - - nullBlockDataCache.add(ix); - return null; - } - } - - private static BlockData parseBlockData(String ix) { - BlockData bd = parseBlockDataOrNull(ix); - - if (bd != null) { - return bd; - } - - Iris.warn("Unknown Block Data: " + ix); - - return AIR; - } - - public static boolean isStorage(BlockData mat) { - Material mm = mat.getMaterial(); - Boolean f = storageCache.get(mm); - - if (f != null) { - return f; - } - - f = mm.equals(B.getMaterial("CHEST")) - || mm.equals(B.getMaterial("TRAPPED_CHEST")) - || mm.equals(B.getMaterial("SHULKER_BOX")) - || mm.equals(B.getMaterial("WHITE_SHULKER_BOX")) - || mm.equals(B.getMaterial("ORANGE_SHULKER_BOX")) - || mm.equals(B.getMaterial("MAGENTA_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIGHT_BLUE_SHULKER_BOX")) - || mm.equals(B.getMaterial("YELLOW_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIME_SHULKER_BOX")) - || mm.equals(B.getMaterial("PINK_SHULKER_BOX")) - || mm.equals(B.getMaterial("GRAY_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIGHT_GRAY_SHULKER_BOX")) - || mm.equals(B.getMaterial("CYAN_SHULKER_BOX")) - || mm.equals(B.getMaterial("PURPLE_SHULKER_BOX")) - || mm.equals(B.getMaterial("BLUE_SHULKER_BOX")) - || mm.equals(B.getMaterial("BROWN_SHULKER_BOX")) - || mm.equals(B.getMaterial("GREEN_SHULKER_BOX")) - || mm.equals(B.getMaterial("RED_SHULKER_BOX")) - || mm.equals(B.getMaterial("BLACK_SHULKER_BOX")) - || mm.equals(B.getMaterial("BARREL")) - || mm.equals(B.getMaterial("DISPENSER")) - || mm.equals(B.getMaterial("DROPPER")) - || mm.equals(B.getMaterial("HOPPER")) - || mm.equals(B.getMaterial("FURNACE")) - || mm.equals(B.getMaterial("BLAST_FURNACE")) - || mm.equals(B.getMaterial("SMOKER")); - storageCache.put(mm, f); - return f; - } - - public static boolean isStorageChest(BlockData mat) { - if (!isStorage(mat)) { - return false; - } - - Material mm = mat.getMaterial(); - Boolean f = storageChestCache.get(mm); - - if (f != null) { - return f; - } - - f = mm.equals(B.getMaterial("CHEST")) - || mm.equals(B.getMaterial("TRAPPED_CHEST")) - || mm.equals(B.getMaterial("SHULKER_BOX")) - || mm.equals(B.getMaterial("WHITE_SHULKER_BOX")) - || mm.equals(B.getMaterial("ORANGE_SHULKER_BOX")) - || mm.equals(B.getMaterial("MAGENTA_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIGHT_BLUE_SHULKER_BOX")) - || mm.equals(B.getMaterial("YELLOW_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIME_SHULKER_BOX")) - || mm.equals(B.getMaterial("PINK_SHULKER_BOX")) - || mm.equals(B.getMaterial("GRAY_SHULKER_BOX")) - || mm.equals(B.getMaterial("LIGHT_GRAY_SHULKER_BOX")) - || mm.equals(B.getMaterial("CYAN_SHULKER_BOX")) - || mm.equals(B.getMaterial("PURPLE_SHULKER_BOX")) - || mm.equals(B.getMaterial("BLUE_SHULKER_BOX")) - || mm.equals(B.getMaterial("BROWN_SHULKER_BOX")) - || mm.equals(B.getMaterial("GREEN_SHULKER_BOX")) - || mm.equals(B.getMaterial("RED_SHULKER_BOX")) - || mm.equals(B.getMaterial("BLACK_SHULKER_BOX")) - || mm.equals(B.getMaterial("BARREL")) - || mm.equals(B.getMaterial("DISPENSER")) - || mm.equals(B.getMaterial("DROPPER")) - || mm.equals(B.getMaterial("HOPPER")); - storageChestCache.put(mm, f); - return f; - } - - public static boolean isLit(BlockData mat) { - Material mm = mat.getMaterial(); - Boolean f = litCache.get(mm); - - if (f != null) { - return f; - } - - f = mm.equals(B.getMaterial("GLOWSTONE")) - || mm.equals(B.getMaterial("END_ROD")) - || mm.equals(B.getMaterial("SOUL_SAND")) - || mm.equals(B.getMaterial("TORCH")) - || mm.equals(Material.REDSTONE_TORCH) - || mm.equals(B.getMaterial("SOUL_TORCH")) - || mm.equals(Material.REDSTONE_WALL_TORCH) - || mm.equals(Material.WALL_TORCH) - || mm.equals(B.getMaterial("SOUL_WALL_TORCH")) - || mm.equals(B.getMaterial("LANTERN")) - || mm.equals(Material.JACK_O_LANTERN) - || mm.equals(Material.REDSTONE_LAMP) - || mm.equals(Material.MAGMA_BLOCK) - || mm.equals(B.getMaterial("SHROOMLIGHT")) - || mm.equals(B.getMaterial("SEA_LANTERN")) - || mm.equals(B.getMaterial("SOUL_LANTERN")) - || mm.equals(Material.FIRE) - || mm.equals(B.getMaterial("SOUL_FIRE")) - || mm.equals(B.getMaterial("SEA_PICKLE")) - || mm.equals(Material.BREWING_STAND) - || mm.equals(Material.REDSTONE_ORE); - litCache.put(mm, f); - return f; - } - - public static boolean isUpdatable(BlockData mat) { - Boolean u = updatableCache.get(mat.getMaterial()); - - if (u != null) { - return u; - } - - u = isLit(mat) || isStorage(mat); - updatableCache.put(mat.getMaterial(), u); - return u; - } - - public static boolean isFoliage(Material d) { - return isFoliage(d.createBlockData()); - } - - public static boolean isFoliage(BlockData d) { - Boolean f = foliageCache.get(d.getMaterial()); - if (f != null) { - return f; - } - - if (isFluid(d) || isAir(d) || isSolid(d)) { - foliageCache.put(d.getMaterial(), false); - return false; - } - - Material mat = d.getMaterial(); - f = mat.equals(Material.POPPY) - || mat.equals(Material.DANDELION) - || mat.equals(B.getMaterial("CORNFLOWER")) - || mat.equals(B.getMaterial("SWEET_BERRY_BUSH")) - || mat.equals(B.getMaterial("CRIMSON_ROOTS")) - || mat.equals(B.getMaterial("WARPED_ROOTS")) - || mat.equals(B.getMaterial("NETHER_SPROUTS")) - || mat.equals(B.getMaterial("ALLIUM")) - || mat.equals(B.getMaterial("AZURE_BLUET")) - || mat.equals(B.getMaterial("BLUE_ORCHID")) - || mat.equals(B.getMaterial("POPPY")) - || mat.equals(B.getMaterial("DANDELION")) - || mat.equals(B.getMaterial("OXEYE_DAISY")) - || mat.equals(B.getMaterial("LILY_OF_THE_VALLEY")) - || mat.equals(B.getMaterial("WITHER_ROSE")) - || mat.equals(Material.DARK_OAK_SAPLING) - || mat.equals(Material.ACACIA_SAPLING) - || mat.equals(Material.JUNGLE_SAPLING) - || mat.equals(Material.BIRCH_SAPLING) - || mat.equals(Material.SPRUCE_SAPLING) - || mat.equals(Material.OAK_SAPLING) - || mat.equals(Material.ORANGE_TULIP) - || mat.equals(Material.PINK_TULIP) - || mat.equals(Material.RED_TULIP) - || mat.equals(Material.WHITE_TULIP) - || mat.equals(Material.FERN) - || mat.equals(Material.LARGE_FERN) - || mat.equals(Material.GRASS) - || mat.equals(Material.TALL_GRASS); - foliageCache.put(d.getMaterial(), f); - return f; + return IntSets.unmodifiable(b); } public static boolean canPlaceOnto(Material mat, Material onto) { - String key = mat.name() + "" + onto.name(); - if (isFoliage(mat)) { if (!isFoliagePlantable(onto)) { return false; @@ -447,86 +256,6 @@ public class B { return true; } - public static boolean isDecorant(BlockData m) { - Material mm = m.getMaterial(); - Boolean f = decorantCache.get(mm); - - if (f != null) { - return f; - } - - f = mm.equals(Material.GRASS) - || mm.equals(Material.TALL_GRASS) - || mm.equals(Material.FERN) - || mm.equals(Material.LARGE_FERN) - || mm.equals(B.getMaterial("CORNFLOWER")) - || mm.equals(Material.SUNFLOWER) - || mm.equals(Material.CHORUS_FLOWER) - || mm.equals(Material.POPPY) - || mm.equals(Material.DANDELION) - || mm.equals(Material.OXEYE_DAISY) - || mm.equals(Material.ORANGE_TULIP) - || mm.equals(Material.PINK_TULIP) - || mm.equals(Material.RED_TULIP) - || mm.equals(Material.WHITE_TULIP) - || mm.equals(Material.LILAC) - || mm.equals(Material.DEAD_BUSH) - || mm.equals(B.getMaterial("SWEET_BERRY_BUSH")) - || mm.equals(Material.ROSE_BUSH) - || mm.equals(B.getMaterial("WITHER_ROSE")) - || mm.equals(Material.ALLIUM) - || mm.equals(Material.BLUE_ORCHID) - || mm.equals(B.getMaterial("LILY_OF_THE_VALLEY")) - || mm.equals(B.getMaterial("CRIMSON_FUNGUS")) - || mm.equals(B.getMaterial("WARPED_FUNGUS")) - || mm.equals(Material.RED_MUSHROOM) - || mm.equals(Material.BROWN_MUSHROOM) - || mm.equals(B.getMaterial("CRIMSON_ROOTS")) - || mm.equals(B.getMaterial("AZURE_BLUET")) - || mm.equals(B.getMaterial("WEEPING_VINES")) - || mm.equals(B.getMaterial("WEEPING_VINES_PLANT")) - || mm.equals(B.getMaterial("WARPED_ROOTS")) - || mm.equals(B.getMaterial("NETHER_SPROUTS")) - || mm.equals(B.getMaterial("TWISTING_VINES")) - || mm.equals(B.getMaterial("TWISTING_VINES_PLANT")) - || mm.equals(Material.SUGAR_CANE) - || mm.equals(Material.WHEAT) - || mm.equals(Material.POTATOES) - || mm.equals(Material.CARROTS) - || mm.equals(Material.BEETROOTS) - || mm.equals(Material.NETHER_WART) - || mm.equals(B.getMaterial("SEA_PICKLE")) - || mm.equals(B.getMaterial("SEAGRASS")) - || mm.equals(B.getMaterial("ACACIA_BUTTON")) - || mm.equals(B.getMaterial("BIRCH_BUTTON")) - || mm.equals(B.getMaterial("CRIMSON_BUTTON")) - || mm.equals(B.getMaterial("DARK_OAK_BUTTON")) - || mm.equals(B.getMaterial("JUNGLE_BUTTON")) - || mm.equals(B.getMaterial("OAK_BUTTON")) - || mm.equals(B.getMaterial("POLISHED_BLACKSTONE_BUTTON")) - || mm.equals(B.getMaterial("SPRUCE_BUTTON")) - || mm.equals(B.getMaterial("STONE_BUTTON")) - || mm.equals(B.getMaterial("WARPED_BUTTON")) - || mm.equals(Material.TORCH) - || mm.equals(B.getMaterial("SOUL_TORCH")); - decorantCache.put(mm, f); - return f; - } - - public static KList get(KList find) { - KList b = new KList<>(); - - for (String i : find) { - BlockData bd = get(i); - - if (bd != null) { - b.add(bd); - } - } - - return b; - } - public static boolean isFoliagePlantable(BlockData d) { return d.getMaterial().equals(Material.GRASS_BLOCK) || d.getMaterial().equals(Material.ROOTED_DIRT) @@ -543,6 +272,207 @@ public class B { || d.equals(Material.PODZOL); } + public static boolean isWater(BlockData b) { + return b.getMaterial().equals(Material.WATER); + } + + public static BlockData getAir() { + return AIR; + } + + public static Material getMaterialOrNull(String bdx) { + try { + return Material.valueOf(bdx.trim().toUpperCase()); + } catch (Throwable e) { + Iris.reportError(e); + if(clw.flip()) + { + Iris.warn("Unknown Material: " + bdx); + } + return null; + } + } + + public static Material getMaterial(String bdx) { + Material m = getMaterialOrNull(bdx); + + if(m == null) + { + return AIR_MATERIAL; + } + + return m; + } + + public static boolean isSolid(BlockData mat) { + return mat.getMaterial().isSolid(); + } + + public static BlockData getOrNull(String bdxf) { + try { + String bd = bdxf.trim(); + BlockData bdx = parseBlockData(bd); + + if (bdx == null) { + if(clw.flip()) + { + Iris.warn("Unknown Block Data '" + bd + "'"); + } + return AIR; + } + + return bdx; + } catch (Throwable e) { + Iris.reportError(e); + + if(clw.flip()) + { + Iris.warn("Unknown Block Data '" + bdxf + "'"); + } + } + + return null; + } + + public static BlockData get(String bdxf) { + BlockData bd = getOrNull(bdxf); + + if (bd != null) { + return bd; + } + + return AIR; + } + + private static BlockData parseBlockData(String ix) { + try { + BlockData bb = blockDataCache.get(ix); + + if (bb != null) { + return bb; + } + + BlockData bx = null; + + if (ix.startsWith("oraxen:") && Iris.linkOraxen.supported()) { + bx = Iris.linkOraxen.getBlockDataFor(ix.split("\\Q:\\E")[1]); + } + + if (bx == null) { + bx = Bukkit.createBlockData(ix); + } + + if (bx instanceof Leaves && IrisSettings.get().getGenerator().preventLeafDecay) { + ((Leaves) bx).setPersistent(true); + } else if (bx instanceof Leaves) { + ((Leaves) bx).setPersistent(false); + } + + blockDataCache.put(ix, bx); + return bx; + } catch (Throwable e) { + if(clw.flip()) + { + Iris.warn("Unknown Block Data: " + ix); + } + + String block = ix.contains(":") ? ix.split(":")[1].toLowerCase() : ix.toLowerCase(); + String state = block.contains("[") ? block.split("\\Q[\\E")[1].split("\\Q]\\E")[0] : ""; + Map stateMap = new HashMap<>(); + if (!state.equals("")) { + Arrays.stream(state.split(",")).forEach(s -> stateMap.put(s.split("=")[0], s.split("=")[1])); + } + block = block.split("\\Q[\\E")[0]; + + switch (block) { + case "cauldron" -> block = "water_cauldron"; + case "grass_path" -> block = "dirt_path"; + case "concrete" -> block = "white_concrete"; + case "wool" -> block = "white_wool"; + case "beetroots" -> { + if (stateMap.containsKey("age")) { + String updated = stateMap.get("age"); + switch (updated) { + case "7" -> updated = "3"; + case "3", "4", "5" -> updated = "2"; + case "1", "2" -> updated = "1"; + } + stateMap.put("age", updated); + } + } + } + + Map newStates = new HashMap<>(); + for (String key : stateMap.keySet()) { //Iterate through every state and check if its valid + try { + String newState = block + "[" + key + "=" + stateMap.get(key) + "]"; + Bukkit.createBlockData(newState); + newStates.put(key, stateMap.get(key)); + + } catch (IllegalArgumentException ignored) { + } + } + + //Combine all the "good" states again + state = newStates.entrySet().stream().map(entry -> entry.getKey() + "=" + entry.getValue()).collect(Collectors.joining(",")); + if (!state.equals("")) state = "[" + state + "]"; + String newBlock = block + state; + Iris.debug("Converting " + ix + " to " + newBlock); + + try { + BlockData bd = Bukkit.createBlockData(newBlock); + blockDataCache.put(ix, bd); + return bd; + } catch (Throwable e1) { + Iris.reportError(e1); + } + + return null; + } + } + + public static boolean isStorage(BlockData mat) { + return storageCache.contains(mat.getMaterial().ordinal()); + } + + public static boolean isStorageChest(BlockData mat) { + return storageChestCache.contains(mat.getMaterial().ordinal()); + } + + public static boolean isLit(BlockData mat) { + return litCache.contains(mat.getMaterial().ordinal()); + } + + public static boolean isUpdatable(BlockData mat) { + return isLit(mat) || isStorage(mat); + } + + public static boolean isFoliage(Material d) { + return foliageCache.contains(d.ordinal()); + } + + public static boolean isFoliage(BlockData d) { + return isFoliage(d.getMaterial()); + } + + public static boolean isDecorant(BlockData m) { + return decorantCache.contains(m.getMaterial().ordinal()); + } + + public static KList get(KList find) { + KList b = new KList<>(); + + for (String i : find) { + BlockData bd = get(i); + + if (bd != null) { + b.add(bd); + } + } + + return b; + } + public static boolean isFluid(BlockData d) { return d.getMaterial().equals(Material.WATER) || d.getMaterial().equals(Material.LAVA); }