From 3e1857b96673573019b960a29d633228860ba0a1 Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 8 Aug 2018 15:42:29 +0100 Subject: [PATCH 01/62] Add module for FlattenedProvider --- Essentials/pom.xml | 6 ++++++ nms/FlattenedProvider/pom.xml | 36 +++++++++++++++++++++++++++++++++++ pom.xml | 1 + 3 files changed, 43 insertions(+) create mode 100644 nms/FlattenedProvider/pom.xml diff --git a/Essentials/pom.xml b/Essentials/pom.xml index 7f35d18c6..8483f9af2 100644 --- a/Essentials/pom.xml +++ b/Essentials/pom.xml @@ -106,6 +106,12 @@ + + net.ess3 + FlattenedProvider + 2.15.0 + compile + diff --git a/nms/FlattenedProvider/pom.xml b/nms/FlattenedProvider/pom.xml new file mode 100644 index 000000000..ce63a9be3 --- /dev/null +++ b/nms/FlattenedProvider/pom.xml @@ -0,0 +1,36 @@ + + + + EssentialsXParent + net.ess3 + 2.15.0 + ../../pom.xml + + 4.0.0 + + FlattenedProvider + + + + project.local + local repo + file:${project.basedir}/lib + + + + + + org.bukkit + craftbukkit + 1.13-R0.1-SNAPSHOT + provided + + + net.ess3 + NMSProvider + 2.15.0 + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index f8a0da05d..d8faeff12 100644 --- a/pom.xml +++ b/pom.xml @@ -47,6 +47,7 @@ nms/1_8_R2Provider nms/LegacyProvider nms/ReflectionProvider + nms/FlattenedProvider From c5376d3088a7332a2df473c472ada939b1cb6a4b Mon Sep 17 00:00:00 2001 From: md678685 Date: Fri, 10 Aug 2018 22:07:02 +0100 Subject: [PATCH 02/62] Implement ItemDbProviders, pt 1 --- .../com/earth2me/essentials/Essentials.java | 10 + .../nms/flattened/FlatItemDbProvider.java | 75 +++++ nms/IdProvider/pom.xml | 32 +++ .../ess3/nms/ids/LegacyItemDbProvider.java | 261 ++++++++++++++++++ .../src/net/ess3/nms/ItemDbProvider.java | 240 ++++++++++++++++ pom.xml | 1 + 6 files changed, 619 insertions(+) create mode 100644 nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java create mode 100644 nms/IdProvider/pom.xml create mode 100644 nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java create mode 100644 nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index d49761f49..09c90abc9 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -34,9 +34,12 @@ import com.google.common.collect.Iterables; import net.ess3.api.*; import net.ess3.api.IEssentials; import net.ess3.api.ISettings; +import net.ess3.nms.ItemDbProvider; import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; import net.ess3.nms.SpawnerProvider; +import net.ess3.nms.flattened.FlatItemDbProvider; +import net.ess3.nms.legacy.LegacyItemDbProvider; import net.ess3.nms.legacy.LegacyPotionMetaProvider; import net.ess3.nms.refl.ReflSpawnEggProvider; import net.ess3.nms.updatedmeta.BasePotionDataProvider; @@ -103,6 +106,7 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { private transient EssentialsTimer timer; private final transient Set vanishedPlayers = new LinkedHashSet<>(); private transient Method oldGetOnlinePlayers; + private transient ItemDbProvider itemDbProvider; private transient SpawnerProvider spawnerProvider; private transient SpawnEggProvider spawnEggProvider; private transient PotionMetaProvider potionMetaProvider; @@ -211,6 +215,12 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { execTimer.mark("Init(Worth/ItemDB)"); jails = new Jails(this); confList.add(jails); + + itemDbProvider = new ProviderFactory<>(getLogger(), + Arrays.asList( + FlatItemDbProvider.class, + LegacyItemDbProvider.class + ), "item database").getProvider(); spawnerProvider = new ProviderFactory<>(getLogger(), Arrays.asList( BlockMetaSpawnerProvider.class, diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java new file mode 100644 index 000000000..77f396edd --- /dev/null +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -0,0 +1,75 @@ +package net.ess3.nms.flattened; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonParser; +import net.ess3.nms.ItemDbProvider; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; +import org.bukkit.potion.PotionType; + +import java.util.List; +import java.util.stream.Collectors; + +public class FlatItemDbProvider extends ItemDbProvider { + private static Gson gson = new Gson(); + + + @Override + public Material resolve(String name) { + return null; + } + + @Override + public boolean supportsLegacyIds() { + return false; + } + + @Override + public int getLegacyId(Material material) { + return -1; + } + + @Override + public Material getFromLegacyId(int id) { + return null; + } + + @Override + public String getPrimaryName(ItemStack item) { + return null; + } + + @Override + public List getNames(ItemStack item) { + return null; + } + + @Override + public void rebuild(List lines) { + String json = lines.stream().collect(Collectors.joining("\n")); + JsonArray jsonArray = (new JsonParser()).parse(json).getAsJsonArray(); + jsonArray.forEach(element -> { + if (element.isJsonObject()) { + } + }); + } + + @Override + public boolean tryProvider() { + // Build the database initially so that we can actually test the provider + this.rebuild(this.loadResource("/items.json")); + return super.tryProvider(); + } + + @Override + public String getHumanName() { + return "Post-1.13 item database provider"; + } + + private class MaterialData { + private Material material; + private PotionType potionEnum; + private String potionModifier; + } +} diff --git a/nms/IdProvider/pom.xml b/nms/IdProvider/pom.xml new file mode 100644 index 000000000..3756f2e7f --- /dev/null +++ b/nms/IdProvider/pom.xml @@ -0,0 +1,32 @@ + + + + EssentialsXParent + net.ess3 + 2.15.0 + ../../pom.xml + + 4.0.0 + + IdProvider + + + + net.ess3 + NMSProvider + 2.15.0 + + + net.ess3 + ReflectionProvider + 2.15.0 + + + org.bukkit + bukkit + 1.12.2-R0.1-SNAPSHOT + + + \ No newline at end of file diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java new file mode 100644 index 000000000..4a47ccbc1 --- /dev/null +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -0,0 +1,261 @@ +package net.ess3.nms.ids; + +import net.ess3.nms.ItemDbProvider; +import net.ess3.nms.PotionMetaProvider; +import net.ess3.nms.SpawnEggProvider; +import net.ess3.nms.refl.ReflUtil; +import org.apache.commons.lang.StringUtils; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.Server; +import org.bukkit.entity.EntityType; +import org.bukkit.inventory.ItemStack; + +import java.util.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class LegacyItemDbProvider extends ItemDbProvider { + private final transient Map items = new HashMap<>(); + private final transient Map> names = new HashMap<>(); + private final transient Map primaryNames = new HashMap<>(); + private final transient Map legacyIds = new HashMap<>(); + private final transient Map durabilities = new HashMap<>(); + private final transient Map nbtData = new HashMap<>(); + + private final transient Pattern splitPattern = Pattern.compile("((.*)[:+',;.](\\d+))"); + private final transient Pattern csvSplitPattern = Pattern.compile("(\"([^\"]*)\"|[^,]*)(,|$)"); + + @Override + public Material resolve(String name) { + return null; + } + + @Override + public ItemStack getStack(String name) throws Exception { + int itemid = 0; + String itemname; + short metaData = 0; + + Matcher parts = splitPattern.matcher(name); + if (parts.matches()) { + itemname = parts.group(2); + metaData = Short.parseShort(parts.group(3)); + } else { + itemname = name; + } + + if (isInt(itemname)) { + itemid = Integer.parseInt(itemname); + } else if (isInt(name)) { + itemid = Integer.parseInt(name); + } else { + itemname = itemname.toLowerCase(Locale.ENGLISH); + } + + if (itemid < 1) { + if (items.containsKey(itemname)) { + itemid = items.get(itemname); + if (durabilities.containsKey(itemname) && metaData == 0) { + metaData = durabilities.get(itemname); + } + } + } + + if (itemid < 1) { + throw new Exception("Unknown item name " + itemname); + } + + ItemData data = legacyIds.get(itemid); + if (data == null) { + throw new Exception("Unknown item ID " + itemid); + } + + Material mat = data.getMaterial(); + ItemStack retval = new ItemStack(mat); + if (nbtData.containsKey(itemname)) { + String nbt = nbtData.get(itemname); + if (nbt.startsWith("*")) { + nbt = nbtData.get(nbt.substring(1)); + } + retval = Bukkit.getServer().getUnsafe().modifyItemStack(retval, nbt); + } + + + Material MOB_SPAWNER; + try { + MOB_SPAWNER = Material.valueOf("SPAWNER"); + } catch (Exception e) { + MOB_SPAWNER = Material.valueOf("MOB_SPAWNER"); + } + if (mat == MOB_SPAWNER) { + if (metaData == 0) metaData = EntityType.PIG.getTypeId(); + try { + retval = getSpawnerProvider().setEntityType(retval, EntityType.fromId(metaData)); + } catch (IllegalArgumentException e) { + throw new Exception("Can't spawn entity ID " + metaData + " from mob spawners."); + } + } else if (mat == Material.MONSTER_EGG) { + EntityType type; + try { + type = EntityType.fromId(metaData); + } catch (IllegalArgumentException e) { + throw new Exception("Can't spawn entity ID " + metaData + " from spawn eggs."); + } + retval = getSpawnEggProvider().createEggItem(type); + } else if (mat.name().endsWith("POTION") + && ReflUtil.getNmsVersionObject().isLowerThan(ReflUtil.V1_11_R1)) { // Only apply this to pre-1.11 as items.csv might only work in 1.11 + retval = getPotionMetaProvider().createPotionItem(mat, metaData); + } else { + retval.setDurability(metaData); + } + retval.setAmount(mat.getMaxStackSize()); + return retval; + } + + @Override + public boolean supportsLegacyIds() { + return true; + } + + @Override + public int getLegacyId(Material material) throws Exception { + for (Map.Entry entry : items.entrySet()) { + if (material.name().toLowerCase(Locale.ENGLISH).equalsIgnoreCase(entry.getKey())) { + return entry.getValue(); + } + } + + throw new Exception("Item ID missing for material " + material.name()); + } + + @Override + public Material getFromLegacyId(int id) { + ItemData data = this.legacyIds.get(id); + if (data == null) { + return null; + } + + return data.getMaterial(); + } + + @Override + public String getPrimaryName(ItemStack item) { + return null; + } + + @Override + public List getNames(ItemStack item) { + return null; + } + + @Override + public void rebuild(List lines) { + durabilities.clear(); + items.clear(); + names.clear(); + primaryNames.clear(); + + lines.stream() + .filter(line -> line.length() > 0 && !(line.charAt(0) == '#')) + .map(this::parseLine) + .filter(itemData -> itemData != null) + .forEach(this::addItem); + + for (List nameList : names.values()) { + nameList.sort(LengthCompare.INSTANCE); + } + } + + private ItemData parseLine(String line) { + String itemName = null; + int numeric = -1; + short data = 0; + String nbt = null; + + int col = 0; + Matcher matcher = csvSplitPattern.matcher(line); + while (matcher.find()) { + String match = matcher.group(1); + if (StringUtils.stripToNull(match) == null) { + continue; + } + match = StringUtils.strip(match.trim(), "\""); + switch (col) { + case 0: + itemName = match.toLowerCase(Locale.ENGLISH); + break; + case 1: + numeric = Integer.parseInt(match); + break; + case 2: + data = Short.parseShort(match); + break; + case 3: + nbt = StringUtils.stripToNull(match); + break; + default: + continue; + } + col++; + } + // Invalid row + if (itemName == null || numeric < 0) { + return null; + } + + Material material = Material.matchMaterial(itemName); + if (material == null) { + return null; + } + + return new ItemData(itemName, material, numeric, data, nbt); + } + + private void addItem(ItemData itemData) { + final String name = itemData.getItemName(); + final int numeric = itemData.getItemNo(); + final short data = itemData.getItemData(); + final String nbt = itemData.getNbt(); + + durabilities.put(name, data); + items.put(name, numeric); + + if (nbt != null) { + nbtData.put(itemData.getItemName(), nbt); + } + + if (names.containsKey(itemData)) { + List nameList = names.get(itemData); + nameList.add(name); + } else { + List nameList = new ArrayList<>(); + nameList.add(name); + names.put(itemData, nameList); + primaryNames.put(itemData, name); + } + + legacyIds.put(numeric, itemData); + } + + @Override + public boolean tryProvider() { + // Build the database initially so that we can actually test the provider + this.rebuild(this.loadResource("/items.csv")); + return super.tryProvider(); + } + + @Override + public String getHumanName() { + return "Pre-1.13 item database provider"; + } + + private boolean isInt(String integer) { + try { + Integer.parseInt(integer); + return true; + } catch (NumberFormatException e) { + return false; + } + } +} diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java new file mode 100644 index 000000000..9f643be02 --- /dev/null +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -0,0 +1,240 @@ +package net.ess3.nms; + +import net.ess3.providers.Provider; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; +import org.bukkit.potion.PotionType; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.List; +import java.util.stream.Collectors; + +public abstract class ItemDbProvider implements Provider { + + private SpawnerProvider spawnerProvider; + private SpawnEggProvider spawnEggProvider; + private PotionMetaProvider potionMetaProvider; + + /** + * Resolves a material name to its corresponding Material + * + * @param name The material name to look up + * @return The corresponding Material for the given name + */ + public abstract Material resolve(String name); + + /** + * Whether the provider supports legacy ID values or not. + * + * @return True if the provider supports legacy IDs, otherwise false + */ + public abstract boolean supportsLegacyIds(); + + /** + * Get the legacy ID for the material. + * + * @param material The material to look up + * @return The ID corresponding to the material, or null if not supported + */ + public abstract int getLegacyId(Material material) throws Exception; + + /** + * Get the material for the legacy ID. + * + * @param id The ID to look up + * @return The material corresponding to the ID, or -1 if not supported + */ + public abstract Material getFromLegacyId(int id); + + /** + * Get the primary name for the item in the given stack. + * + * @param item The ItemStack to check + * @return The primary name for the item + */ + public abstract String getPrimaryName(ItemStack item); + + /** + * Get all names for the item in the given stack. + * + * @param item The ItemStack to check + * @return The names for the item + */ + public abstract List getNames(ItemStack item); + + /** + * Rebuild the item database, using the given lines of a file. + * + * @param lines The lines of the file from which the database should be built. + */ + public abstract void rebuild(List lines); + + /** + * Creates a stack of a given item by its name. + * + * @param name The material name to look up + * @return An ItemStack of size 1 of the given item + */ + public ItemStack getStack(String name) throws Exception { + return new ItemStack(resolve(name)); + } + + /** + * Creates a stack with the given amount of a given item by its name. + * + * @param name The material name to look up + * @param amount The amount of items in the returned ItemStack + * @return An ItemStack with the given amount of the given item + */ + public ItemStack getStack(String name, int amount) throws Exception { + ItemStack is = getStack(name); + is.setAmount(amount); + return is; + } + + /** + * Read a resource from the jar. + * Used to build the database before data from a ManagedFile is available. + * + * @param name The name of the resource to load. + * @return The lines of the resource. + */ + protected List loadResource(final String name) { + try (InputStreamReader isr = new InputStreamReader(ItemDbProvider.class.getResourceAsStream(name))) { + BufferedReader br = new BufferedReader(isr); + return br.lines().collect(Collectors.toList()); + } catch (IOException e) { + return null; + } + } + + @Override + public boolean tryProvider() { + try { + getStack("cstone"); + getStack("diorite"); + getStack("steelbar", 5); + getStack("aoepot"); + getStack("skeletonegg", 12); + return true; + } catch (Exception e) { + return false; + } + } + + protected SpawnerProvider getSpawnerProvider() { + return spawnerProvider; + } + + public void setSpawnerProvider(SpawnerProvider spawnerProvider) { + this.spawnerProvider = spawnerProvider; + } + + protected SpawnEggProvider getSpawnEggProvider() { + return spawnEggProvider; + } + + public void setSpawnEggProvider(SpawnEggProvider spawnEggProvider) { + this.spawnEggProvider = spawnEggProvider; + } + + protected PotionMetaProvider getPotionMetaProvider() { + return potionMetaProvider; + } + + public void setPotionMetaProvider(PotionMetaProvider potionMetaProvider) { + this.potionMetaProvider = potionMetaProvider; + } + + public static class ItemData { + final private String itemName; + final private Material material; + private int legacyId; + private short itemData; + final private String nbt; + private PotionData potionData; + + public ItemData(String itemName, Material material, String nbt) { + this.itemName = itemName; + this.material = material; + this.nbt = nbt; + } + + public ItemData(String itemName, Material material, String nbt, PotionData potionData) { + this.itemName = itemName; + this.material = material; + this.nbt = nbt; + this.potionData = potionData; + } + + @Deprecated + public ItemData(String itemName, Material material, final int legacyId, final short itemData, String nbt) { + this.itemName = itemName; + this.material = material; + this.legacyId = legacyId; + this.itemData = itemData; + this.nbt = nbt; + } + + public String getItemName() { + return itemName; + } + + public Material getMaterial() { + return material; + } + + @Deprecated + public int getItemNo() { + return legacyId; + } + + public short getItemData() { + return itemData; + } + + public String getNbt() { + return nbt; + } + + @Override + public int hashCode() { + return (31 * material.hashCode()) ^ itemData; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (!(o instanceof ItemData)) { + return false; + } + ItemData pairo = (ItemData) o; + return this.material == pairo.getMaterial() && this.itemData == pairo.getItemData() && this.nbt.equals(pairo.getNbt()); + } + } + + public static class PotionData { + private PotionType bukkitType; + private String vanillaType; + private boolean isStrong; + private boolean isLong; + } + + protected static class LengthCompare implements java.util.Comparator { + + public static final LengthCompare INSTANCE = new LengthCompare(); + + public LengthCompare() { + super(); + } + + @Override + public int compare(String s1, String s2) { + return s1.length() - s2.length(); + } + } +} diff --git a/pom.xml b/pom.xml index d8faeff12..c4374ac32 100644 --- a/pom.xml +++ b/pom.xml @@ -47,6 +47,7 @@ nms/1_8_R2Provider nms/LegacyProvider nms/ReflectionProvider + nms/IdProvider nms/FlattenedProvider From 4be28ba193495ce728189b75bb53bb06b5a47475 Mon Sep 17 00:00:00 2001 From: md678685 Date: Tue, 14 Aug 2018 18:57:47 +0100 Subject: [PATCH 03/62] Implement ItemDbProviders, pt 2 --- nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 4a47ccbc1..67ece3d3d 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -159,7 +159,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { lines.stream() .filter(line -> line.length() > 0 && !(line.charAt(0) == '#')) .map(this::parseLine) - .filter(itemData -> itemData != null) + .filter(Objects::nonNull) .forEach(this::addItem); for (List nameList : names.values()) { From c27d05fd4ba5914ffc6b09bbc130913ff4ae866d Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 16:40:01 +0100 Subject: [PATCH 04/62] Fix dependency on IdProvider --- Essentials/pom.xml | 6 ++++++ Essentials/src/com/earth2me/essentials/Essentials.java | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Essentials/pom.xml b/Essentials/pom.xml index 8483f9af2..bd44cb37f 100644 --- a/Essentials/pom.xml +++ b/Essentials/pom.xml @@ -106,6 +106,12 @@ + + net.ess3 + IdProvider + 2.15.0 + compile + net.ess3 FlattenedProvider diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index 09c90abc9..109c89c23 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -39,7 +39,7 @@ import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; import net.ess3.nms.SpawnerProvider; import net.ess3.nms.flattened.FlatItemDbProvider; -import net.ess3.nms.legacy.LegacyItemDbProvider; +import net.ess3.nms.ids.LegacyItemDbProvider; import net.ess3.nms.legacy.LegacyPotionMetaProvider; import net.ess3.nms.refl.ReflSpawnEggProvider; import net.ess3.nms.updatedmeta.BasePotionDataProvider; From 773979cb37fb8e61cc862066064e52e816468a77 Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 16:56:46 +0100 Subject: [PATCH 05/62] Provide ItemDb provider with other providers Provide providers to the provider that needs the providers. Provider provider provider provide provider. --- Essentials/src/com/earth2me/essentials/Essentials.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index 109c89c23..f54cb2e0c 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -238,6 +238,9 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { BasePotionDataProvider.class, LegacyPotionMetaProvider.class ), "potion meta").getProvider(); + itemDbProvider.setSpawnerProvider(spawnerProvider); + itemDbProvider.setSpawnEggProvider(spawnEggProvider); + itemDbProvider.setPotionMetaProvider(potionMetaProvider); reload(); } catch (YAMLException exception) { if (pm.getPlugin("EssentialsUpdate") != null) { From 04feed8524daa7dfc7a386df05de9f3892ff1ff6 Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 17:46:55 +0100 Subject: [PATCH 06/62] Add 1.13+ spawn egg provider Not sure how necessary this is, but I've done it anyway --- .../com/earth2me/essentials/Essentials.java | 2 ++ .../nms/flattened/FlatSpawnEggProvider.java | 31 +++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index f54cb2e0c..eaa0a5dfa 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -39,6 +39,7 @@ import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; import net.ess3.nms.SpawnerProvider; import net.ess3.nms.flattened.FlatItemDbProvider; +import net.ess3.nms.flattened.FlatSpawnEggProvider; import net.ess3.nms.ids.LegacyItemDbProvider; import net.ess3.nms.legacy.LegacyPotionMetaProvider; import net.ess3.nms.refl.ReflSpawnEggProvider; @@ -230,6 +231,7 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { ), "mob spawner").getProvider(); spawnEggProvider = new ProviderFactory<>(getLogger(), Arrays.asList( + FlatSpawnEggProvider.class, ReflSpawnEggProvider.class, LegacySpawnEggProvider.class ), "spawn egg").getProvider(); diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java new file mode 100644 index 000000000..5ea4402e0 --- /dev/null +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java @@ -0,0 +1,31 @@ +package net.ess3.nms.flattened; + +import net.ess3.nms.SpawnEggProvider; +import net.ess3.nms.refl.ReflUtil; +import org.bukkit.Material; +import org.bukkit.entity.EntityType; +import org.bukkit.inventory.ItemStack; + +public class FlatSpawnEggProvider extends SpawnEggProvider { + @Override + public ItemStack createEggItem(EntityType type) throws IllegalArgumentException { + String name = type.name() + "_SPAWN_EGG"; + Material material = Material.valueOf(name); + return new ItemStack(material); + } + + @Override + public EntityType getSpawnedType(ItemStack eggItem) throws IllegalArgumentException { + String materialName = eggItem.getType().name(); + if (materialName.contains("_SPAWN_EGG")) { + return EntityType.valueOf(materialName.replace("_SPAWN_EGG", "")); + } else { + throw new IllegalArgumentException("Not a spawn egg"); + } + } + + @Override + public String getHumanName() { + return "1.13+ flat spawn egg provider"; + } +} From 0e9232ba815996fd966a24f54d4f93bf04053dbd Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 19:40:08 +0100 Subject: [PATCH 07/62] Remove breaking import --- .../src/net/ess3/nms/flattened/FlatSpawnEggProvider.java | 1 - 1 file changed, 1 deletion(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java index 5ea4402e0..b3e5f3f46 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatSpawnEggProvider.java @@ -1,7 +1,6 @@ package net.ess3.nms.flattened; import net.ess3.nms.SpawnEggProvider; -import net.ess3.nms.refl.ReflUtil; import org.bukkit.Material; import org.bukkit.entity.EntityType; import org.bukkit.inventory.ItemStack; From 340baa9703a6fd612bc67286344299c50072c275 Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 19:40:35 +0100 Subject: [PATCH 08/62] Add IEssentials#getItemDbProvider method --- Essentials/src/com/earth2me/essentials/Essentials.java | 5 +++++ Essentials/src/net/ess3/api/IEssentials.java | 3 +++ 2 files changed, 8 insertions(+) diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index eaa0a5dfa..a71a13fe3 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -887,6 +887,11 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { return potionMetaProvider; } + @Override + public ItemDbProvider getItemDbProvider() { + return itemDbProvider; + } + private static void addDefaultBackPermissionsToWorld(World w) { String permName = "essentials.back.into." + w.getName(); diff --git a/Essentials/src/net/ess3/api/IEssentials.java b/Essentials/src/net/ess3/api/IEssentials.java index 1e76dda17..dc418b512 100644 --- a/Essentials/src/net/ess3/api/IEssentials.java +++ b/Essentials/src/net/ess3/api/IEssentials.java @@ -1,5 +1,6 @@ package net.ess3.api; +import net.ess3.nms.ItemDbProvider; import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; @@ -12,4 +13,6 @@ public interface IEssentials extends com.earth2me.essentials.IEssentials { SpawnEggProvider getSpawnEggProvider(); PotionMetaProvider getPotionMetaProvider(); + + ItemDbProvider getItemDbProvider(); } From 3ef0f20b0df82f0fabcd19365830d66591ed3c67 Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 19:42:12 +0100 Subject: [PATCH 09/62] Add tipped arrows support on 1.9/1.10 On a side note, need to investigate why the potion provider is only needed on 1.10 and below - I don't remember what changed in 1.11? --- nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 67ece3d3d..37260afe1 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -103,7 +103,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { throw new Exception("Can't spawn entity ID " + metaData + " from spawn eggs."); } retval = getSpawnEggProvider().createEggItem(type); - } else if (mat.name().endsWith("POTION") + } else if ((mat.name().endsWith("POTION") || mat.name().equals("TIPPED_ARROW")) && ReflUtil.getNmsVersionObject().isLowerThan(ReflUtil.V1_11_R1)) { // Only apply this to pre-1.11 as items.csv might only work in 1.11 retval = getPotionMetaProvider().createPotionItem(mat, metaData); } else { From 3fb4b7958da889f2f13574c9137794d90b4b3a2f Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 15 Aug 2018 19:50:15 +0100 Subject: [PATCH 10/62] Strip out legacy ItemDb code, pt 1 --- .../src/com/earth2me/essentials/ItemDb.java | 85 ++----------------- 1 file changed, 6 insertions(+), 79 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 358ea9ba7..022a96cee 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -3,6 +3,7 @@ package com.earth2me.essentials; import com.earth2me.essentials.utils.NumberUtil; import com.earth2me.essentials.utils.StringUtil; import net.ess3.api.IEssentials; +import net.ess3.nms.ItemDbProvider; import net.ess3.nms.refl.ReflUtil; import org.apache.commons.lang.StringUtils; import org.bukkit.Bukkit; @@ -29,6 +30,7 @@ import static com.earth2me.essentials.I18n.tl; public class ItemDb implements IConf, net.ess3.api.IItemDb { protected static final Logger LOGGER = Logger.getLogger("Essentials"); private final transient IEssentials ess; + private final transient ItemDbProvider provider; private final transient Map items = new HashMap<>(); private final transient Map> names = new HashMap<>(); private final transient Map primaryName = new HashMap<>(); @@ -41,6 +43,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { public ItemDb(final IEssentials ess) { this.ess = ess; + this.provider = ess.getItemDbProvider(); file = new ManagedFile("items.csv", ess); } @@ -130,88 +133,12 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public ItemStack get(final String id, final int quantity) throws Exception { - final ItemStack retval = get(id.toLowerCase(Locale.ENGLISH)); - retval.setAmount(quantity); - return retval; + return provider.getStack(id, quantity); } @Override public ItemStack get(final String id) throws Exception { - int itemid = 0; - String itemname; - short metaData = 0; - Matcher parts = splitPattern.matcher(id); - if (parts.matches()) { - itemname = parts.group(2); - metaData = Short.parseShort(parts.group(3)); - } else { - itemname = id; - } - - if (NumberUtil.isInt(itemname)) { - itemid = Integer.parseInt(itemname); - } else if (NumberUtil.isInt(id)) { - itemid = Integer.parseInt(id); - } else { - itemname = itemname.toLowerCase(Locale.ENGLISH); - } - - if (itemid < 1) { - if (items.containsKey(itemname)) { - itemid = items.get(itemname); - if (durabilities.containsKey(itemname) && metaData == 0) { - metaData = durabilities.get(itemname); - } - } - } - - if (itemid < 1) { - throw new Exception(tl("unknownItemName", itemname)); - } - - ItemData data = legacyIds.get(itemid); - if (data == null) { - throw new Exception(tl("unknownItemId", itemid)); - } - - Material mat = data.getMaterial(); - ItemStack retval = new ItemStack(mat); - if (nbtData.containsKey(itemname)) { - String nbt = nbtData.get(itemname); - if (nbt.startsWith("*")) { - nbt = nbtData.get(nbt.substring(1)); - } - retval = ess.getServer().getUnsafe().modifyItemStack(retval, nbt); - } - Material MOB_SPAWNER; - try { - MOB_SPAWNER = Material.SPAWNER; - } catch (Exception e) { - MOB_SPAWNER = Material.valueOf("MOB_SPAWNER"); - } - if (mat == MOB_SPAWNER) { - if (metaData == 0) metaData = EntityType.PIG.getTypeId(); - try { - retval = ess.getSpawnerProvider().setEntityType(retval, EntityType.fromId(metaData)); - } catch (IllegalArgumentException e) { - throw new Exception("Can't spawn entity ID " + metaData + " from mob spawners."); - } - } else if (mat == Material.LEGACY_MONSTER_EGG) { - EntityType type; - try { - type = EntityType.fromId(metaData); - } catch (IllegalArgumentException e) { - throw new Exception("Can't spawn entity ID " + metaData + " from spawn eggs."); - } - retval = ess.getSpawnEggProvider().createEggItem(type); - } else if (mat.name().endsWith("POTION") - && ReflUtil.getNmsVersionObject().isLowerThan(ReflUtil.V1_11_R1)) { // Only apply this to pre-1.11 as items.csv might only work in 1.11 - retval = ess.getPotionMetaProvider().createPotionItem(mat, metaData); - } else { - retval.setDurability(metaData); - } - retval.setAmount(mat.getMaxStackSize()); - return retval; + return provider.getStack(id); } @Override @@ -456,7 +383,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public Material getFromLegacyId(int id) { ItemData data = this.legacyIds.get(id); - if(data == null) { + if (data == null) { return null; } From b867f121c9838afb893c85c2853bbda20a782d89 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 17:49:34 +0100 Subject: [PATCH 11/62] Implement ItemDbProviders, pt 3 --- .../nms/flattened/FlatItemDbProvider.java | 46 +++++++++++++++---- 1 file changed, 38 insertions(+), 8 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 77f396edd..5fb837028 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -1,19 +1,19 @@ package net.ess3.nms.flattened; -import com.google.gson.Gson; -import com.google.gson.JsonArray; -import com.google.gson.JsonParser; +import com.google.gson.*; import net.ess3.nms.ItemDbProvider; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; import org.bukkit.potion.PotionType; -import java.util.List; +import java.util.*; import java.util.stream.Collectors; public class FlatItemDbProvider extends ItemDbProvider { private static Gson gson = new Gson(); + private final transient Map items = new HashMap<>(); + private final transient Map> aliases = new HashMap<>(); @Override public Material resolve(String name) { @@ -47,12 +47,42 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public void rebuild(List lines) { - String json = lines.stream().collect(Collectors.joining("\n")); - JsonArray jsonArray = (new JsonParser()).parse(json).getAsJsonArray(); - jsonArray.forEach(element -> { + String json = String.join("\n", lines); + JsonObject map = (new JsonParser()).parse(json).getAsJsonObject(); + + for (Map.Entry entry : map.entrySet()) { + String key = entry.getKey(); + JsonElement element = entry.getValue(); + if (element.isJsonObject()) { + ItemData data = gson.fromJson(element, ItemData.class); + items.put(key, data); + addAlias(data, key); + } else { + try { + // TODO: finalise this - how do we handle aliases loading before actual materials? + // Temporary Map> that we copy over from once json parsed? + String target = element.getAsString(); + ItemData data = items.get(target); + addAlias(data, target); + } catch (Exception e) { + // TODO: log invalid entry + } } - }); + } + } + + private void addAlias(ItemData data, String alias) { + Set aliasList; + + if (aliases.containsKey(data)) { + aliasList = aliases.get(data); + } else { + aliasList = new HashSet<>(); + aliases.put(data, aliasList); + } + + aliasList.add(alias); } @Override From e2507d2ff13673f1d025d5c08d030a907cf13a12 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 18:03:53 +0100 Subject: [PATCH 12/62] Implement ItemDbProviders, pt 4 --- .../ess3/nms/ids/LegacyItemDbProvider.java | 23 +++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 37260afe1..398fac4a2 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -141,12 +141,31 @@ public class LegacyItemDbProvider extends ItemDbProvider { @Override public String getPrimaryName(ItemStack item) { - return null; + ItemData itemData = new ItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); + String name = primaryNames.get(itemData); + if (name == null) { + itemData = new ItemData(null, item.getType(), item.getTypeId(), (short) 0, null); + name = primaryNames.get(itemData); + if (name == null) { + return null; + } + } + return name; } @Override public List getNames(ItemStack item) { - return null; + ItemData itemData = new ItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); + List nameList = names.get(itemData); + if (nameList == null) { + itemData = new ItemData(null, item.getType(), item.getTypeId(), (short) 0, null); + nameList = names.get(itemData); + if (nameList == null) { + return null; + } + } + + return nameList; } @Override From 9da58dde5cbe04787ff6b072c2564ab83cc014a3 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 18:04:13 +0100 Subject: [PATCH 13/62] Strip out legacy ItemDb code, pt 2 --- .../src/com/earth2me/essentials/ItemDb.java | 23 +++---------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 022a96cee..d03494e0f 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -176,16 +176,8 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public String names(ItemStack item) { - ItemData itemData = new ItemData(item.getType(), item.getDurability()); - List nameList = names.get(itemData); - if (nameList == null) { - itemData = new ItemData(item.getType(), (short) 0); - nameList = names.get(itemData); - if (nameList == null) { - return null; - } - } - + List nameList = provider.getNames(item); + if (nameList.size() > 15) { nameList = nameList.subList(0, 14); } @@ -194,16 +186,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public String name(ItemStack item) { - ItemData itemData = new ItemData(item.getType(), item.getDurability()); - String name = primaryName.get(itemData); - if (name == null) { - itemData = new ItemData(item.getType(), (short) 0); - name = primaryName.get(itemData); - if (name == null) { - return null; - } - } - return name; + return provider.getPrimaryName(item); } @Override From 9b39509e883f4a7be7f78abe299b4321e2949117 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 18:30:44 +0100 Subject: [PATCH 14/62] Misc changes --- Essentials/src/com/earth2me/essentials/ItemDb.java | 2 +- nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index d03494e0f..6642b5d2b 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -177,7 +177,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public String names(ItemStack item) { List nameList = provider.getNames(item); - + if (nameList.size() > 15) { nameList = nameList.subList(0, 14); } diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 398fac4a2..55d71b0df 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -28,6 +28,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { @Override public Material resolve(String name) { + // TODO: refactor getStack into here return null; } From 102930538271778520b170817b3f4f60360ba21d Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 19:23:20 +0100 Subject: [PATCH 15/62] Implement ItemDbProviders, pt 5 --- .../nms/flattened/FlatItemDbProvider.java | 46 ++++++++++--------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 5fb837028..e66a48b74 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -7,13 +7,12 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.potion.PotionType; import java.util.*; -import java.util.stream.Collectors; public class FlatItemDbProvider extends ItemDbProvider { private static Gson gson = new Gson(); - private final transient Map items = new HashMap<>(); - private final transient Map> aliases = new HashMap<>(); + private final transient Map primaryNames = new HashMap<>(); + private final transient Map> names = new HashMap<>(); @Override public Material resolve(String name) { @@ -37,11 +36,26 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public String getPrimaryName(ItemStack item) { + ItemData itemData = new ItemData(null, item.getType(), null); + + for (Map.Entry entry : primaryNames.entrySet()) { + if (entry.getValue().equals(itemData)) { + return entry.getKey(); + } + } + return null; } @Override public List getNames(ItemStack item) { + String primaryName = getPrimaryName(item); + + for (Map.Entry> entry : names.entrySet()) { + if (entry.getKey().equals(primaryName)) { + return Collections.unmodifiableList(entry.getValue()); + } + } return null; } @@ -56,15 +70,11 @@ public class FlatItemDbProvider extends ItemDbProvider { if (element.isJsonObject()) { ItemData data = gson.fromJson(element, ItemData.class); - items.put(key, data); - addAlias(data, key); + primaryNames.put(key, data); } else { try { - // TODO: finalise this - how do we handle aliases loading before actual materials? - // Temporary Map> that we copy over from once json parsed? String target = element.getAsString(); - ItemData data = items.get(target); - addAlias(data, target); + addAlias(target, key); } catch (Exception e) { // TODO: log invalid entry } @@ -72,14 +82,14 @@ public class FlatItemDbProvider extends ItemDbProvider { } } - private void addAlias(ItemData data, String alias) { - Set aliasList; + private void addAlias(String primaryName, String alias) { + List aliasList; - if (aliases.containsKey(data)) { - aliasList = aliases.get(data); + if (names.containsKey(primaryName)) { + aliasList = names.get(primaryName); } else { - aliasList = new HashSet<>(); - aliases.put(data, aliasList); + aliasList = new ArrayList<>(); + names.put(primaryName, aliasList); } aliasList.add(alias); @@ -96,10 +106,4 @@ public class FlatItemDbProvider extends ItemDbProvider { public String getHumanName() { return "Post-1.13 item database provider"; } - - private class MaterialData { - private Material material; - private PotionType potionEnum; - private String potionModifier; - } } From 56fb8b06cdbd2976ccfa76524f5b3d4cde338c12 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 20:55:56 +0100 Subject: [PATCH 16/62] Add listNames to abstract ItemDbProvider --- .../src/net/ess3/nms/ItemDbProvider.java | 72 ++++++++++++++----- 1 file changed, 53 insertions(+), 19 deletions(-) diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index 9f643be02..4e719a2a6 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -8,6 +8,7 @@ import org.bukkit.potion.PotionType; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; +import java.util.Collection; import java.util.List; import java.util.stream.Collectors; @@ -17,6 +18,29 @@ public abstract class ItemDbProvider implements Provider { private SpawnEggProvider spawnEggProvider; private PotionMetaProvider potionMetaProvider; + /** + * Rebuild the item database, using the given lines of a file. + * + * @param lines The lines of the file from which the database should be built. + */ + public abstract void rebuild(List lines); + + /** + * Read a resource from the jar. + * Used to build the database before data from a ManagedFile is available. + * + * @param name The name of the resource to load. + * @return The lines of the resource. + */ + protected List loadResource(final String name) { + try (InputStreamReader isr = new InputStreamReader(ItemDbProvider.class.getResourceAsStream(name))) { + BufferedReader br = new BufferedReader(isr); + return br.lines().collect(Collectors.toList()); + } catch (IOException e) { + return null; + } + } + /** * Resolves a material name to its corresponding Material * @@ -64,13 +88,6 @@ public abstract class ItemDbProvider implements Provider { */ public abstract List getNames(ItemStack item); - /** - * Rebuild the item database, using the given lines of a file. - * - * @param lines The lines of the file from which the database should be built. - */ - public abstract void rebuild(List lines); - /** * Creates a stack of a given item by its name. * @@ -95,20 +112,12 @@ public abstract class ItemDbProvider implements Provider { } /** - * Read a resource from the jar. - * Used to build the database before data from a ManagedFile is available. + * Get all registered primary names for materials. + * This does not include any additional aliases. * - * @param name The name of the resource to load. - * @return The lines of the resource. + * @return A collection of primary names */ - protected List loadResource(final String name) { - try (InputStreamReader isr = new InputStreamReader(ItemDbProvider.class.getResourceAsStream(name))) { - BufferedReader br = new BufferedReader(isr); - return br.lines().collect(Collectors.toList()); - } catch (IOException e) { - return null; - } - } + public abstract Collection listNames(); @Override public boolean tryProvider() { @@ -124,26 +133,50 @@ public abstract class ItemDbProvider implements Provider { } } + /** + * Get the current spawner provider. + * + * @return The current spawner provider + */ protected SpawnerProvider getSpawnerProvider() { return spawnerProvider; } + /** + * Set the current spawner provider. + */ public void setSpawnerProvider(SpawnerProvider spawnerProvider) { this.spawnerProvider = spawnerProvider; } + /** + * Get the current spawn egg provider. + * + * @return The current spawn egg provider + */ protected SpawnEggProvider getSpawnEggProvider() { return spawnEggProvider; } + /** + * Set the current spawn egg provider. + */ public void setSpawnEggProvider(SpawnEggProvider spawnEggProvider) { this.spawnEggProvider = spawnEggProvider; } + /** + * Get the current potion provider. + * + * @return The current potion provider + */ protected PotionMetaProvider getPotionMetaProvider() { return potionMetaProvider; } + /** + * Set the current potion provider. + */ public void setPotionMetaProvider(PotionMetaProvider potionMetaProvider) { this.potionMetaProvider = potionMetaProvider; } @@ -213,6 +246,7 @@ public abstract class ItemDbProvider implements Provider { return false; } ItemData pairo = (ItemData) o; + // TODO: generalise comparison return this.material == pairo.getMaterial() && this.itemData == pairo.getItemData() && this.nbt.equals(pairo.getNbt()); } } From de2298cf0a5dee64b1f32c53d9384c1e62c132ee Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 20:56:17 +0100 Subject: [PATCH 17/62] Strip out legacy ItemDb code, pt 3 --- .../src/com/earth2me/essentials/ItemDb.java | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 6642b5d2b..3f30208be 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -365,28 +365,17 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public Material getFromLegacyId(int id) { - ItemData data = this.legacyIds.get(id); - if (data == null) { - return null; - } - - return data.getMaterial(); + return provider.getFromLegacyId(id); } @Override public int getLegacyId(Material material) throws Exception { - for(Map.Entry entry : items.entrySet()) { - if(material.name().toLowerCase(Locale.ENGLISH).equalsIgnoreCase(entry.getKey())) { - return entry.getValue(); - } - } - - throw new Exception("Itemid not found for material: " + material.name()); + return provider.getLegacyId(material); } @Override public Collection listNames() { - return primaryName.values(); + return provider.listNames(); } static class ItemData { From dd9a0de98d50696853442cf7bb37af72a8561375 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 20:58:45 +0100 Subject: [PATCH 18/62] Implement ItemDbProviders, pt 6 --- .../src/net/ess3/nms/flattened/FlatItemDbProvider.java | 5 +++++ .../src/net/ess3/nms/ids/LegacyItemDbProvider.java | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index e66a48b74..58e8c9fca 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -59,6 +59,11 @@ public class FlatItemDbProvider extends ItemDbProvider { return null; } + @Override + public Collection listNames() { + return Collections.unmodifiableSet(primaryNames.keySet()); + } + @Override public void rebuild(List lines) { String json = String.join("\n", lines); diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 55d71b0df..d0debf44b 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -114,6 +114,11 @@ public class LegacyItemDbProvider extends ItemDbProvider { return retval; } + @Override + public Collection listNames() { + return primaryNames.values(); + } + @Override public boolean supportsLegacyIds() { return true; From 98809fafd7e32b4344963686f1db336b8fc37e71 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 21:10:54 +0100 Subject: [PATCH 19/62] Strip out legacy ItemDb code, pt 4 --- .../src/com/earth2me/essentials/ItemDb.java | 105 ++---------------- 1 file changed, 9 insertions(+), 96 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 3f30208be..a0ac3b793 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -1,18 +1,14 @@ package com.earth2me.essentials; -import com.earth2me.essentials.utils.NumberUtil; import com.earth2me.essentials.utils.StringUtil; import net.ess3.api.IEssentials; import net.ess3.nms.ItemDbProvider; -import net.ess3.nms.refl.ReflUtil; -import org.apache.commons.lang.StringUtils; -import org.bukkit.Bukkit; +import net.ess3.nms.ids.LegacyItemDbProvider; import org.bukkit.Color; import org.bukkit.FireworkEffect; import org.bukkit.Material; import org.bukkit.block.Banner; import org.bukkit.enchantments.Enchantment; -import org.bukkit.entity.EntityType; import org.bukkit.inventory.ItemFlag; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.*; @@ -21,8 +17,6 @@ import org.bukkit.potion.PotionEffect; import java.util.*; import java.util.logging.Logger; -import java.util.regex.Matcher; -import java.util.regex.Pattern; import static com.earth2me.essentials.I18n.tl; @@ -31,104 +25,23 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { protected static final Logger LOGGER = Logger.getLogger("Essentials"); private final transient IEssentials ess; private final transient ItemDbProvider provider; - private final transient Map items = new HashMap<>(); - private final transient Map> names = new HashMap<>(); - private final transient Map primaryName = new HashMap<>(); - private final transient Map legacyIds = new HashMap<>(); - private final transient Map durabilities = new HashMap<>(); - private final transient Map nbtData = new HashMap<>(); + private final transient ManagedFile file; - private final transient Pattern splitPattern = Pattern.compile("((.*)[:+',;.](\\d+))"); - private final transient Pattern csvSplitPattern = Pattern.compile("(\"([^\"]*)\"|[^,]*)(,|$)"); public ItemDb(final IEssentials ess) { this.ess = ess; this.provider = ess.getItemDbProvider(); - file = new ManagedFile("items.csv", ess); + + if (provider instanceof LegacyItemDbProvider) { + file = new ManagedFile("items.csv", ess); + } else { + file = new ManagedFile("items.json", ess); + } } @Override public void reloadConfig() { - final List lines = file.getLines(); - - if (lines.isEmpty()) { - return; - } - - durabilities.clear(); - items.clear(); - names.clear(); - primaryName.clear(); - - for (String line : lines) { - if (line.length() > 0 && line.charAt(0) == '#') { - continue; - } - - String itemName = null; - int numeric = -1; - short data = 0; - String nbt = null; - - int col = 0; - Matcher matcher = csvSplitPattern.matcher(line); - while (matcher.find()) { - String match = matcher.group(1); - if (StringUtils.stripToNull(match) == null) { - continue; - } - match = StringUtils.strip(match.trim(), "\""); - switch (col) { - case 0: - itemName = match.toLowerCase(Locale.ENGLISH); - break; - case 1: - numeric = Integer.parseInt(match); - break; - case 2: - data = Short.parseShort(match); - break; - case 3: - nbt = StringUtils.stripToNull(match); - break; - default: - continue; - } - col++; - } - // Invalid row - if (itemName == null || numeric < 0) { - continue; - } - - Material material = Material.matchMaterial(itemName); - if (material == null) { - LOGGER.warning(String.format("Failed to find material for %s", itemName)); - continue; - } - durabilities.put(itemName, data); - items.put(itemName, numeric); - if (nbt != null) { - nbtData.put(itemName, nbt); - } - - ItemData itemData = new ItemData(material, numeric, data); - if (names.containsKey(itemData)) { - List nameList = names.get(itemData); - nameList.add(itemName); - } else { - List nameList = new ArrayList<>(); - nameList.add(itemName); - names.put(itemData, nameList); - primaryName.put(itemData, itemName); - } - - legacyIds.put(numeric, itemData); - } - - for (List nameList : names.values()) { - Collections.sort(nameList, LengthCompare.INSTANCE); - } + provider.rebuild(file.getLines()); } @Override From b27a6b5b8ef1b1341407813d7c4f72fe01cd4796 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 21:11:51 +0100 Subject: [PATCH 20/62] Add additional timer marks --- Essentials/src/com/earth2me/essentials/Essentials.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index a71a13fe3..bf00b56f6 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -216,6 +216,7 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { execTimer.mark("Init(Worth/ItemDB)"); jails = new Jails(this); confList.add(jails); + execTimer.mark("Init(Jails)"); itemDbProvider = new ProviderFactory<>(getLogger(), Arrays.asList( @@ -243,6 +244,7 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { itemDbProvider.setSpawnerProvider(spawnerProvider); itemDbProvider.setSpawnEggProvider(spawnEggProvider); itemDbProvider.setPotionMetaProvider(potionMetaProvider); + execTimer.mark("Init(Providers)"); reload(); } catch (YAMLException exception) { if (pm.getPlugin("EssentialsUpdate") != null) { From c37d5169809b2565f7575733bafd1650f2c8090c Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 21:16:16 +0100 Subject: [PATCH 21/62] Use MONSTER_EGG in SpawnEggRefl --- nms/ReflectionProvider/pom.xml | 5 +++++ .../src/net/ess3/nms/refl/SpawnEggRefl.java | 5 ++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/nms/ReflectionProvider/pom.xml b/nms/ReflectionProvider/pom.xml index 945dfa09e..c6831e8cb 100644 --- a/nms/ReflectionProvider/pom.xml +++ b/nms/ReflectionProvider/pom.xml @@ -18,5 +18,10 @@ NMSProvider 2.15.0 + + org.bukkit + bukkit + 1.12.2-R0.1-SNAPSHOT + \ No newline at end of file diff --git a/nms/ReflectionProvider/src/net/ess3/nms/refl/SpawnEggRefl.java b/nms/ReflectionProvider/src/net/ess3/nms/refl/SpawnEggRefl.java index 6838aae58..6f7f8617b 100644 --- a/nms/ReflectionProvider/src/net/ess3/nms/refl/SpawnEggRefl.java +++ b/nms/ReflectionProvider/src/net/ess3/nms/refl/SpawnEggRefl.java @@ -79,8 +79,7 @@ public class SpawnEggRefl { */ @SuppressWarnings("deprecation") public ItemStack toItemStack(int amount) throws Exception { - // TODO: Get off of the deprecated LEGACY material. - ItemStack item = new ItemStack(Material.LEGACY_MONSTER_EGG, amount); + ItemStack item = new ItemStack(Material.MONSTER_EGG, amount); Class craftItemStackClass = ReflUtil.getOBCClass("inventory.CraftItemStack"); Method asNMSCopyMethod = ReflUtil.getMethodCached(craftItemStackClass, "asNMSCopy", ItemStack.class); @@ -123,7 +122,7 @@ public class SpawnEggRefl { public static SpawnEggRefl fromItemStack(ItemStack item) throws Exception { if (item == null) throw new IllegalArgumentException("Item cannot be null"); - if (item.getType() != Material.LEGACY_MONSTER_EGG) + if (item.getType() != Material.MONSTER_EGG) throw new IllegalArgumentException("Item is not a monster egg"); Class NMSItemStackClass = ReflUtil.getNMSClass("ItemStack"); From 3705dbdd2b5a58179dfe53591d615e95def42a82 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 21:43:53 +0100 Subject: [PATCH 22/62] Add items.json TODO: should we auto-download from the CI on build? --- Essentials/src/items.json | 18340 ++++++++++++++++++++++++++++++++++++ pom.xml | 1 + 2 files changed, 18341 insertions(+) create mode 100644 Essentials/src/items.json diff --git a/Essentials/src/items.json b/Essentials/src/items.json new file mode 100644 index 000000000..27b16bb16 --- /dev/null +++ b/Essentials/src/items.json @@ -0,0 +1,18340 @@ +{ + "acacia_boat": { + "material": "ACACIA_BOAT" + }, + "acaciaboat": "acacia_boat", + "aboat": "acacia_boat", + "acacia_button": { + "material": "ACACIA_BUTTON" + }, + "acaciabutton": "acacia_button", + "acacia_door": { + "material": "ACACIA_DOOR" + }, + "acaciadoor": "acacia_door", + "acacia_fence": { + "material": "ACACIA_FENCE" + }, + "acaciafence": "acacia_fence", + "afence": "acacia_fence", + "acacia_fence_gate": { + "material": "ACACIA_FENCE_GATE" + }, + "acaciafencegate": "acacia_fence_gate", + "acaciagate": "acacia_fence_gate", + "afencegate": "acacia_fence_gate", + "agate": "acacia_fence_gate", + "acacia_leaves": { + "material": "ACACIA_LEAVES" + }, + "acacialeaves": "acacia_leaves", + "acaciatreeleaves": "acacia_leaves", + "acacialogleaves": "acacia_leaves", + "acaciatrunkleaves": "acacia_leaves", + "acaciawoodleaves": "acacia_leaves", + "acaciatreeleaf": "acacia_leaves", + "acacialogleaf": "acacia_leaves", + "acaciatrunkleaf": "acacia_leaves", + "acaciawoodleaf": "acacia_leaves", + "acacialeaf": "acacia_leaves", + "acaciatreeleave": "acacia_leaves", + "acacialogleave": "acacia_leaves", + "acaciatrunkleave": "acacia_leaves", + "acaciawoodleave": "acacia_leaves", + "acacialeave": "acacia_leaves", + "atreeleaves": "acacia_leaves", + "alogleaves": "acacia_leaves", + "atrunkleaves": "acacia_leaves", + "awoodleaves": "acacia_leaves", + "aleaves": "acacia_leaves", + "atreeleaf": "acacia_leaves", + "alogleaf": "acacia_leaves", + "atrunkleaf": "acacia_leaves", + "awoodleaf": "acacia_leaves", + "aleaf": "acacia_leaves", + "atreeleave": "acacia_leaves", + "alogleave": "acacia_leaves", + "atrunkleave": "acacia_leaves", + "awoodleave": "acacia_leaves", + "aleave": "acacia_leaves", + "acacia_log": { + "material": "ACACIA_LOG" + }, + "acacialog": "stripped_acacia_log", + "acacia": "stripped_acacia_log", + "logacacia": "stripped_acacia_log", + "acaciatrunk": "stripped_acacia_log", + "acaciatree": "stripped_acacia_log", + "a": "stripped_acacia_log", + "loga": "stripped_acacia_log", + "atrunk": "stripped_acacia_log", + "alog": "stripped_acacia_log", + "atree": "stripped_acacia_log", + "acacia_planks": { + "material": "ACACIA_PLANKS" + }, + "acaciaplanks": "acacia_planks", + "acaciawoodenplank": "acacia_planks", + "acaciawoodplank": "acacia_planks", + "acaciawplank": "acacia_planks", + "acaciaplankwooden": "acacia_planks", + "acaciaplankwood": "acacia_planks", + "acaciaplankw": "acacia_planks", + "acaciaplank": "acacia_planks", + "awoodenplank": "acacia_planks", + "awoodplank": "acacia_planks", + "awplank": "acacia_planks", + "aplankwooden": "acacia_planks", + "aplankwood": "acacia_planks", + "aplankw": "acacia_planks", + "aplank": "acacia_planks", + "acacia_pressure_plate": { + "material": "ACACIA_PRESSURE_PLATE" + }, + "acaciapressureplate": "acacia_pressure_plate", + "acacia_sapling": { + "material": "ACACIA_SAPLING" + }, + "acaciasapling": "potted_acacia_sapling", + "acaciatreesapling": "potted_acacia_sapling", + "acacialogsapling": "potted_acacia_sapling", + "acaciatrunksapling": "potted_acacia_sapling", + "acaciawoodsapling": "potted_acacia_sapling", + "asapling": "potted_acacia_sapling", + "atreesapling": "potted_acacia_sapling", + "alogsapling": "potted_acacia_sapling", + "atrunksapling": "potted_acacia_sapling", + "awoodsapling": "potted_acacia_sapling", + "acacia_slab": { + "material": "ACACIA_SLAB" + }, + "acaciaslab": "acacia_slab", + "acaciawoodenstep": "acacia_slab", + "acaciawoodstep": "acacia_slab", + "acaciawstep": "acacia_slab", + "acaciastep": "acacia_slab", + "acaciawoodenslab": "acacia_slab", + "acaciawoodslab": "acacia_slab", + "acaciawslab": "acacia_slab", + "acaciawoodenhalfblock": "acacia_slab", + "acaciawoodhalfblock": "acacia_slab", + "acaciawhalfblock": "acacia_slab", + "acaciahalfblock": "acacia_slab", + "awoodenstep": "acacia_slab", + "awoodstep": "acacia_slab", + "awstep": "acacia_slab", + "astep": "acacia_slab", + "awoodenslab": "acacia_slab", + "awoodslab": "acacia_slab", + "awslab": "acacia_slab", + "awoodenhalfblock": "acacia_slab", + "awoodhalfblock": "acacia_slab", + "awhalfblock": "acacia_slab", + "ahalfblock": "acacia_slab", + "acacia_stairs": { + "material": "ACACIA_STAIRS" + }, + "acaciastairs": "acacia_stairs", + "acaciawoodenstairs": "acacia_stairs", + "acaciawoodstairs": "acacia_stairs", + "acaciawstairs": "acacia_stairs", + "acaciawoodenstair": "acacia_stairs", + "acaciawoodstair": "acacia_stairs", + "acaciawstair": "acacia_stairs", + "acaciastair": "acacia_stairs", + "awoodenstairs": "acacia_stairs", + "awoodstairs": "acacia_stairs", + "awstairs": "acacia_stairs", + "awoodenstair": "acacia_stairs", + "awoodstair": "acacia_stairs", + "awstair": "acacia_stairs", + "astair": "acacia_stairs", + "acacia_trapdoor": { + "material": "ACACIA_TRAPDOOR" + }, + "acaciatrapdoor": "acacia_trapdoor", + "acacia_wood": { + "material": "ACACIA_WOOD" + }, + "acaciawood": "stripped_acacia_wood", + "acacialogall": "stripped_acacia_wood", + "acaciatrunkall": "stripped_acacia_wood", + "acaciatreeall": "stripped_acacia_wood", + "awood": "stripped_acacia_wood", + "alogall": "stripped_acacia_wood", + "atrunkall": "stripped_acacia_wood", + "atreeall": "stripped_acacia_wood", + "activator_rail": { + "material": "ACTIVATOR_RAIL" + }, + "activatorrail": "activator_rail", + "activatorrails": "activator_rail", + "activatortrack": "activator_rail", + "activaterails": "activator_rail", + "activaterail": "activator_rail", + "activatetrack": "activator_rail", + "triggerrails": "activator_rail", + "triggerrail": "activator_rail", + "triggertrack": "activator_rail", + "arails": "activator_rail", + "arail": "activator_rail", + "atrack": "activator_rail", + "trails": "activator_rail", + "trail": "activator_rail", + "ttrack": "activator_rail", + "air": { + "material": "AIR" + }, + "allium": { + "material": "ALLIUM" + }, + "andesite": { + "material": "ANDESITE" + }, + "astone": "andesite", + "anvil": { + "material": "ANVIL" + }, + "apple": { + "material": "APPLE" + }, + "armor_stand": { + "material": "ARMOR_STAND" + }, + "armorstand": "armor_stand", + "arrow": { + "material": "ARROW" + }, + "attached_melon_stem": { + "material": "ATTACHED_MELON_STEM" + }, + "attachedmelonstem": "attached_melon_stem", + "attached_pumpkin_stem": { + "material": "ATTACHED_PUMPKIN_STEM" + }, + "attachedpumpkinstem": "attached_pumpkin_stem", + "azure_bluet": { + "material": "AZURE_BLUET" + }, + "azurebluet": "azure_bluet", + "baked_potato": { + "material": "BAKED_POTATO" + }, + "bakedpotato": "baked_potato", + "barrier": { + "material": "BARRIER" + }, + "bat_spawn_egg": { + "material": "BAT_SPAWN_EGG" + }, + "batspawnegg": "bat_spawn_egg", + "beacon": { + "material": "BEACON" + }, + "bedrock": { + "material": "BEDROCK" + }, + "oprock": "bedrock", + "opblock": "bedrock", + "adminblock": "bedrock", + "adminrock": "bedrock", + "adminium": "bedrock", + "beef": { + "material": "BEEF" + }, + "beetroot": { + "material": "BEETROOT" + }, + "beetroots": { + "material": "BEETROOTS" + }, + "beetroot_seeds": { + "material": "BEETROOT_SEEDS" + }, + "beetrootseeds": "beetroot_seeds", + "beetroot_soup": { + "material": "BEETROOT_SOUP" + }, + "beetrootsoup": "beetroot_soup", + "birch_boat": { + "material": "BIRCH_BOAT" + }, + "birchboat": "birch_boat", + "bboat": "birch_boat", + "lightboat": "birch_boat", + "lboat": "birch_boat", + "whiteboat": "birch_boat", + "wboat": "birch_boat", + "birch_button": { + "material": "BIRCH_BUTTON" + }, + "birchbutton": "birch_button", + "birch_door": { + "material": "BIRCH_DOOR" + }, + "birchdoor": "birch_door", + "birch_fence": { + "material": "BIRCH_FENCE" + }, + "birchfence": "birch_fence", + "bfence": "birch_fence", + "lightfence": "birch_fence", + "lfence": "birch_fence", + "whitefence": "birch_fence", + "wfence": "birch_fence", + "birch_fence_gate": { + "material": "BIRCH_FENCE_GATE" + }, + "birchfencegate": "birch_fence_gate", + "birchgate": "birch_fence_gate", + "bfencegate": "birch_fence_gate", + "bgate": "birch_fence_gate", + "lightfencegate": "birch_fence_gate", + "lightgate": "birch_fence_gate", + "lfencegate": "birch_fence_gate", + "lgate": "birch_fence_gate", + "whitefencegate": "birch_fence_gate", + "whitegate": "birch_fence_gate", + "wfencegate": "birch_fence_gate", + "wgate": "birch_fence_gate", + "birch_leaves": { + "material": "BIRCH_LEAVES" + }, + "birchleaves": "birch_leaves", + "birchtreeleaves": "birch_leaves", + "birchlogleaves": "birch_leaves", + "birchtrunkleaves": "birch_leaves", + "birchwoodleaves": "birch_leaves", + "birchtreeleaf": "birch_leaves", + "birchlogleaf": "birch_leaves", + "birchtrunkleaf": "birch_leaves", + "birchwoodleaf": "birch_leaves", + "birchleaf": "birch_leaves", + "birchtreeleave": "birch_leaves", + "birchlogleave": "birch_leaves", + "birchtrunkleave": "birch_leaves", + "birchwoodleave": "birch_leaves", + "birchleave": "birch_leaves", + "btreeleaves": "birch_leaves", + "blogleaves": "birch_leaves", + "btrunkleaves": "birch_leaves", + "bwoodleaves": "birch_leaves", + "bleaves": "birch_leaves", + "btreeleaf": "birch_leaves", + "blogleaf": "birch_leaves", + "btrunkleaf": "birch_leaves", + "bwoodleaf": "birch_leaves", + "bleaf": "birch_leaves", + "btreeleave": "birch_leaves", + "blogleave": "birch_leaves", + "btrunkleave": "birch_leaves", + "bwoodleave": "birch_leaves", + "bleave": "birch_leaves", + "lighttreeleaves": "birch_leaves", + "lightlogleaves": "birch_leaves", + "lighttrunkleaves": "birch_leaves", + "lightwoodleaves": "birch_leaves", + "lightleaves": "birch_leaves", + "lighttreeleaf": "birch_leaves", + "lightlogleaf": "birch_leaves", + "lighttrunkleaf": "birch_leaves", + "lightwoodleaf": "birch_leaves", + "lightleaf": "birch_leaves", + "lighttreeleave": "birch_leaves", + "lightlogleave": "birch_leaves", + "lighttrunkleave": "birch_leaves", + "lightwoodleave": "birch_leaves", + "lightleave": "birch_leaves", + "ltreeleaves": "birch_leaves", + "llogleaves": "birch_leaves", + "ltrunkleaves": "birch_leaves", + "lwoodleaves": "birch_leaves", + "lleaves": "birch_leaves", + "ltreeleaf": "birch_leaves", + "llogleaf": "birch_leaves", + "ltrunkleaf": "birch_leaves", + "lwoodleaf": "birch_leaves", + "lleaf": "birch_leaves", + "ltreeleave": "birch_leaves", + "llogleave": "birch_leaves", + "ltrunkleave": "birch_leaves", + "lwoodleave": "birch_leaves", + "lleave": "birch_leaves", + "whitetreeleaves": "birch_leaves", + "whitelogleaves": "birch_leaves", + "whitetrunkleaves": "birch_leaves", + "whitewoodleaves": "birch_leaves", + "whiteleaves": "birch_leaves", + "whitetreeleaf": "birch_leaves", + "whitelogleaf": "birch_leaves", + "whitetrunkleaf": "birch_leaves", + "whitewoodleaf": "birch_leaves", + "whiteleaf": "birch_leaves", + "whitetreeleave": "birch_leaves", + "whitelogleave": "birch_leaves", + "whitetrunkleave": "birch_leaves", + "whitewoodleave": "birch_leaves", + "whiteleave": "birch_leaves", + "wtreeleaves": "birch_leaves", + "wlogleaves": "birch_leaves", + "wtrunkleaves": "birch_leaves", + "wwoodleaves": "birch_leaves", + "wleaves": "birch_leaves", + "wtreeleaf": "birch_leaves", + "wlogleaf": "birch_leaves", + "wtrunkleaf": "birch_leaves", + "wwoodleaf": "birch_leaves", + "wleaf": "birch_leaves", + "wtreeleave": "birch_leaves", + "wlogleave": "birch_leaves", + "wtrunkleave": "birch_leaves", + "wwoodleave": "birch_leaves", + "wleave": "birch_leaves", + "birch_log": { + "material": "BIRCH_LOG" + }, + "birchlog": "stripped_birch_log", + "birch": "stripped_birch_log", + "logbirch": "stripped_birch_log", + "birchtrunk": "stripped_birch_log", + "birchtree": "stripped_birch_log", + "b": "stripped_birch_log", + "logb": "stripped_birch_log", + "btrunk": "stripped_birch_log", + "blog": "stripped_birch_log", + "btree": "stripped_birch_log", + "light": "stripped_birch_log", + "loglight": "stripped_birch_log", + "lighttrunk": "stripped_birch_log", + "lightlog": "stripped_birch_log", + "lighttree": "stripped_birch_log", + "l": "stripped_birch_log", + "logl": "stripped_birch_log", + "ltrunk": "stripped_birch_log", + "llog": "stripped_birch_log", + "ltree": "stripped_birch_log", + "white": "stripped_birch_log", + "logwhite": "stripped_birch_log", + "whitetrunk": "stripped_birch_log", + "whitelog": "stripped_birch_log", + "whitetree": "stripped_birch_log", + "w": "stripped_birch_log", + "logw": "stripped_birch_log", + "wtrunk": "stripped_birch_log", + "wlog": "stripped_birch_log", + "wtree": "stripped_birch_log", + "birch_planks": { + "material": "BIRCH_PLANKS" + }, + "birchplanks": "birch_planks", + "birchwoodenplank": "birch_planks", + "birchwoodplank": "birch_planks", + "birchwplank": "birch_planks", + "birchplankwooden": "birch_planks", + "birchplankwood": "birch_planks", + "birchplankw": "birch_planks", + "birchplank": "birch_planks", + "bwoodenplank": "birch_planks", + "bwoodplank": "birch_planks", + "bwplank": "birch_planks", + "bplankwooden": "birch_planks", + "bplankwood": "birch_planks", + "bplankw": "birch_planks", + "bplank": "birch_planks", + "lightwoodenplank": "birch_planks", + "lightwoodplank": "birch_planks", + "lightwplank": "birch_planks", + "lightplankwooden": "birch_planks", + "lightplankwood": "birch_planks", + "lightplankw": "birch_planks", + "lightplank": "birch_planks", + "lwoodenplank": "birch_planks", + "lwoodplank": "birch_planks", + "lwplank": "birch_planks", + "lplankwooden": "birch_planks", + "lplankwood": "birch_planks", + "lplankw": "birch_planks", + "lplank": "birch_planks", + "whitewoodenplank": "birch_planks", + "whitewoodplank": "birch_planks", + "whitewplank": "birch_planks", + "whiteplankwooden": "birch_planks", + "whiteplankwood": "birch_planks", + "whiteplankw": "birch_planks", + "whiteplank": "birch_planks", + "wwoodenplank": "birch_planks", + "wwoodplank": "birch_planks", + "wwplank": "birch_planks", + "wplankwooden": "birch_planks", + "wplankwood": "birch_planks", + "wplankw": "birch_planks", + "wplank": "oak_planks", + "birch_pressure_plate": { + "material": "BIRCH_PRESSURE_PLATE" + }, + "birchpressureplate": "birch_pressure_plate", + "birch_sapling": { + "material": "BIRCH_SAPLING" + }, + "birchsapling": "potted_birch_sapling", + "birchtreesapling": "potted_birch_sapling", + "birchlogsapling": "potted_birch_sapling", + "birchtrunksapling": "potted_birch_sapling", + "birchwoodsapling": "potted_birch_sapling", + "bsapling": "potted_birch_sapling", + "btreesapling": "potted_birch_sapling", + "blogsapling": "potted_birch_sapling", + "btrunksapling": "potted_birch_sapling", + "bwoodsapling": "potted_birch_sapling", + "lightsapling": "potted_birch_sapling", + "lighttreesapling": "potted_birch_sapling", + "lightlogsapling": "potted_birch_sapling", + "lighttrunksapling": "potted_birch_sapling", + "lightwoodsapling": "potted_birch_sapling", + "lsapling": "potted_birch_sapling", + "ltreesapling": "potted_birch_sapling", + "llogsapling": "potted_birch_sapling", + "ltrunksapling": "potted_birch_sapling", + "lwoodsapling": "potted_birch_sapling", + "whitesapling": "potted_birch_sapling", + "whitetreesapling": "potted_birch_sapling", + "whitelogsapling": "potted_birch_sapling", + "whitetrunksapling": "potted_birch_sapling", + "whitewoodsapling": "potted_birch_sapling", + "wsapling": "potted_birch_sapling", + "wtreesapling": "potted_birch_sapling", + "wlogsapling": "potted_birch_sapling", + "wtrunksapling": "potted_birch_sapling", + "wwoodsapling": "potted_birch_sapling", + "birch_slab": { + "material": "BIRCH_SLAB" + }, + "birchslab": "birch_slab", + "birchwoodenstep": "birch_slab", + "birchwoodstep": "birch_slab", + "birchwstep": "birch_slab", + "birchstep": "birch_slab", + "birchwoodenslab": "birch_slab", + "birchwoodslab": "birch_slab", + "birchwslab": "birch_slab", + "birchwoodenhalfblock": "birch_slab", + "birchwoodhalfblock": "birch_slab", + "birchwhalfblock": "birch_slab", + "birchhalfblock": "birch_slab", + "bwoodenstep": "birch_slab", + "bwoodstep": "birch_slab", + "bwstep": "birch_slab", + "bstep": "birch_slab", + "bwoodenslab": "birch_slab", + "bwoodslab": "birch_slab", + "bwslab": "birch_slab", + "bwoodenhalfblock": "birch_slab", + "bwoodhalfblock": "birch_slab", + "bwhalfblock": "birch_slab", + "bhalfblock": "birch_slab", + "lightwoodenstep": "birch_slab", + "lightwoodstep": "birch_slab", + "lightwstep": "birch_slab", + "lightstep": "birch_slab", + "lightwoodenslab": "birch_slab", + "lightwoodslab": "birch_slab", + "lightwslab": "birch_slab", + "lightwoodenhalfblock": "birch_slab", + "lightwoodhalfblock": "birch_slab", + "lightwhalfblock": "birch_slab", + "lighthalfblock": "birch_slab", + "lwoodenstep": "birch_slab", + "lwoodstep": "birch_slab", + "lwstep": "birch_slab", + "lstep": "birch_slab", + "lwoodenslab": "birch_slab", + "lwoodslab": "birch_slab", + "lwslab": "birch_slab", + "lwoodenhalfblock": "birch_slab", + "lwoodhalfblock": "birch_slab", + "lwhalfblock": "birch_slab", + "lhalfblock": "birch_slab", + "whitewoodenstep": "birch_slab", + "whitewoodstep": "birch_slab", + "whitewstep": "birch_slab", + "whitestep": "birch_slab", + "whitewoodenslab": "birch_slab", + "whitewoodslab": "birch_slab", + "whitewslab": "birch_slab", + "whitewoodenhalfblock": "birch_slab", + "whitewoodhalfblock": "birch_slab", + "whitewhalfblock": "birch_slab", + "whitehalfblock": "birch_slab", + "wwoodenstep": "birch_slab", + "wwoodstep": "birch_slab", + "wwstep": "birch_slab", + "wstep": "petrified_oak_slab", + "wwoodenslab": "birch_slab", + "wwoodslab": "birch_slab", + "wwslab": "birch_slab", + "wwoodenhalfblock": "birch_slab", + "wwoodhalfblock": "birch_slab", + "wwhalfblock": "birch_slab", + "whalfblock": "petrified_oak_slab", + "birch_stairs": { + "material": "BIRCH_STAIRS" + }, + "birchstairs": "birch_stairs", + "birchwoodenstairs": "birch_stairs", + "birchwoodstairs": "birch_stairs", + "birchwstairs": "birch_stairs", + "birchwoodenstair": "birch_stairs", + "birchwoodstair": "birch_stairs", + "birchwstair": "birch_stairs", + "birchstair": "birch_stairs", + "bwoodenstairs": "birch_stairs", + "bwoodstairs": "birch_stairs", + "bwstairs": "birch_stairs", + "bwoodenstair": "birch_stairs", + "bwoodstair": "birch_stairs", + "bwstair": "birch_stairs", + "bstair": "birch_stairs", + "lightwoodenstairs": "birch_stairs", + "lightwoodstairs": "birch_stairs", + "lightwstairs": "birch_stairs", + "lightwoodenstair": "birch_stairs", + "lightwoodstair": "birch_stairs", + "lightwstair": "birch_stairs", + "lightstair": "birch_stairs", + "lwoodenstairs": "birch_stairs", + "lwoodstairs": "birch_stairs", + "lwstairs": "birch_stairs", + "lwoodenstair": "birch_stairs", + "lwoodstair": "birch_stairs", + "lwstair": "birch_stairs", + "lstair": "birch_stairs", + "whitewoodenstairs": "birch_stairs", + "whitewoodstairs": "birch_stairs", + "whitewstairs": "birch_stairs", + "whitewoodenstair": "birch_stairs", + "whitewoodstair": "birch_stairs", + "whitewstair": "birch_stairs", + "whitestair": "birch_stairs", + "wwoodenstairs": "birch_stairs", + "wwoodstairs": "birch_stairs", + "wwstairs": "birch_stairs", + "wwoodenstair": "birch_stairs", + "wwoodstair": "birch_stairs", + "wwstair": "birch_stairs", + "wstair": "oak_stairs", + "birch_trapdoor": { + "material": "BIRCH_TRAPDOOR" + }, + "birchtrapdoor": "birch_trapdoor", + "birch_wood": { + "material": "BIRCH_WOOD" + }, + "birchwood": "stripped_birch_wood", + "birchlogall": "stripped_birch_wood", + "birchtrunkall": "stripped_birch_wood", + "birchtreeall": "stripped_birch_wood", + "bwood": "stripped_birch_wood", + "blogall": "stripped_birch_wood", + "btrunkall": "stripped_birch_wood", + "btreeall": "stripped_birch_wood", + "lightwood": "stripped_birch_wood", + "lightlogall": "stripped_birch_wood", + "lighttrunkall": "stripped_birch_wood", + "lighttreeall": "stripped_birch_wood", + "lwood": "stripped_birch_wood", + "llogall": "stripped_birch_wood", + "ltrunkall": "stripped_birch_wood", + "ltreeall": "stripped_birch_wood", + "whitewood": "stripped_birch_wood", + "whitelogall": "stripped_birch_wood", + "whitetrunkall": "stripped_birch_wood", + "whitetreeall": "stripped_birch_wood", + "wwood": "stripped_birch_wood", + "wlogall": "stripped_birch_wood", + "wtrunkall": "stripped_birch_wood", + "wtreeall": "stripped_birch_wood", + "black_banner": { + "material": "BLACK_BANNER" + }, + "blackbanner": "black_banner", + "bkstandingbanner": "black_banner", + "bkbanner": "black_banner", + "blastandingbanner": "black_banner", + "blabanner": "black_banner", + "blackstandingbanner": "black_banner", + "black_bed": { + "material": "BLACK_BED" + }, + "blackbed": "black_bed", + "bkbed": "black_bed", + "blabed": "black_bed", + "black_carpet": { + "material": "BLACK_CARPET" + }, + "blackcarpet": "black_carpet", + "bkcarpet": "black_carpet", + "bkfloor": "black_carpet", + "blacarpet": "black_carpet", + "blafloor": "black_carpet", + "blackfloor": "black_carpet", + "black_concrete": { + "material": "BLACK_CONCRETE" + }, + "blackconcrete": "black_concrete", + "bkconcrete": "black_concrete", + "blaconcrete": "black_concrete", + "black_concrete_powder": { + "material": "BLACK_CONCRETE_POWDER" + }, + "blackconcretepowder": "black_concrete_powder", + "bkconcretepowder": "black_concrete_powder", + "bkconcretesand": "black_concrete_powder", + "blaconcretepowder": "black_concrete_powder", + "blaconcretesand": "black_concrete_powder", + "blackconcretesand": "black_concrete_powder", + "black_glazed_terracotta": { + "material": "BLACK_GLAZED_TERRACOTTA" + }, + "blackglazedterracotta": "black_glazed_terracotta", + "bkglazedtcota": "black_glazed_terracotta", + "bkglazedterra": "black_glazed_terracotta", + "bkglazedterracotta": "black_glazed_terracotta", + "bkglazedterracota": "black_glazed_terracotta", + "blaglazedtcota": "black_glazed_terracotta", + "blaglazedterra": "black_glazed_terracotta", + "blaglazedterracotta": "black_glazed_terracotta", + "blaglazedterracota": "black_glazed_terracotta", + "blackglazedtcota": "black_glazed_terracotta", + "blackglazedterra": "black_glazed_terracotta", + "blackglazedterracota": "black_glazed_terracotta", + "black_shulker_box": { + "material": "BLACK_SHULKER_BOX" + }, + "blackshulkerbox": "black_shulker_box", + "bkshulkerbox": "black_shulker_box", + "bkchest": "black_shulker_box", + "blashulkerbox": "black_shulker_box", + "blachest": "black_shulker_box", + "blackchest": "black_shulker_box", + "black_stained_glass": { + "material": "BLACK_STAINED_GLASS" + }, + "blackstainedglass": "black_stained_glass", + "bkglass": "black_stained_glass", + "bksglass": "black_stained_glass", + "bkstainedglass": "black_stained_glass", + "blaglass": "black_stained_glass", + "blasglass": "black_stained_glass", + "blastainedglass": "black_stained_glass", + "blackglass": "black_stained_glass", + "blacksglass": "black_stained_glass", + "black_stained_glass_pane": { + "material": "BLACK_STAINED_GLASS_PANE" + }, + "blackstainedglasspane": "black_stained_glass_pane", + "bkglasspane": "black_stained_glass_pane", + "bksglasspane": "black_stained_glass_pane", + "bkstainedglasspane": "black_stained_glass_pane", + "blaglasspane": "black_stained_glass_pane", + "blasglasspane": "black_stained_glass_pane", + "blastainedglasspane": "black_stained_glass_pane", + "blackglasspane": "black_stained_glass_pane", + "blacksglasspane": "black_stained_glass_pane", + "black_terracotta": { + "material": "BLACK_TERRACOTTA" + }, + "blackterracotta": "black_terracotta", + "bkclay": "black_terracotta", + "bksclay": "black_terracotta", + "bkstainedclay": "black_terracotta", + "bkterra": "black_terracotta", + "bktcota": "black_terracotta", + "bkterracota": "black_terracotta", + "bkterracotta": "black_terracotta", + "blaclay": "black_terracotta", + "blasclay": "black_terracotta", + "blastainedclay": "black_terracotta", + "blaterra": "black_terracotta", + "blatcota": "black_terracotta", + "blaterracota": "black_terracotta", + "blaterracotta": "black_terracotta", + "blackclay": "black_terracotta", + "blacksclay": "black_terracotta", + "blackstainedclay": "black_terracotta", + "blackterra": "black_terracotta", + "blacktcota": "black_terracotta", + "blackterracota": "black_terracotta", + "black_wall_banner": { + "material": "BLACK_WALL_BANNER" + }, + "blackwallbanner": "black_wall_banner", + "bkwallbanner": "black_wall_banner", + "blawallbanner": "black_wall_banner", + "black_wool": { + "material": "BLACK_WOOL" + }, + "blackwool": "black_wool", + "bkwool": "black_wool", + "bkcloth": "black_wool", + "bkcotton": "black_wool", + "blawool": "black_wool", + "blacloth": "black_wool", + "blacotton": "black_wool", + "blackcloth": "black_wool", + "blackcotton": "black_wool", + "blaze_powder": { + "material": "BLAZE_POWDER" + }, + "blazepowder": "blaze_powder", + "blaze_rod": { + "material": "BLAZE_ROD" + }, + "blazerod": "blaze_rod", + "blaze_spawn_egg": { + "material": "BLAZE_SPAWN_EGG" + }, + "blazespawnegg": "blaze_spawn_egg", + "blue_banner": { + "material": "BLUE_BANNER" + }, + "bluebanner": "blue_banner", + "blustandingbanner": "blue_banner", + "blubanner": "blue_banner", + "bluestandingbanner": "blue_banner", + "blue_bed": { + "material": "BLUE_BED" + }, + "bluebed": "blue_bed", + "blubed": "blue_bed", + "blue_carpet": { + "material": "BLUE_CARPET" + }, + "bluecarpet": "blue_carpet", + "blucarpet": "blue_carpet", + "blufloor": "blue_carpet", + "bluefloor": "blue_carpet", + "blue_concrete": { + "material": "BLUE_CONCRETE" + }, + "blueconcrete": "blue_concrete", + "bluconcrete": "blue_concrete", + "blue_concrete_powder": { + "material": "BLUE_CONCRETE_POWDER" + }, + "blueconcretepowder": "blue_concrete_powder", + "bluconcretepowder": "blue_concrete_powder", + "bluconcretesand": "blue_concrete_powder", + "blueconcretesand": "blue_concrete_powder", + "blue_glazed_terracotta": { + "material": "BLUE_GLAZED_TERRACOTTA" + }, + "blueglazedterracotta": "blue_glazed_terracotta", + "bluglazedtcota": "blue_glazed_terracotta", + "bluglazedterra": "blue_glazed_terracotta", + "bluglazedterracotta": "blue_glazed_terracotta", + "bluglazedterracota": "blue_glazed_terracotta", + "blueglazedtcota": "blue_glazed_terracotta", + "blueglazedterra": "blue_glazed_terracotta", + "blueglazedterracota": "blue_glazed_terracotta", + "blue_ice": { + "material": "BLUE_ICE" + }, + "blueice": "blue_ice", + "blue_orchid": { + "material": "BLUE_ORCHID" + }, + "blueorchid": "blue_orchid", + "blue_shulker_box": { + "material": "BLUE_SHULKER_BOX" + }, + "blueshulkerbox": "blue_shulker_box", + "blushulkerbox": "blue_shulker_box", + "bluchest": "blue_shulker_box", + "bluechest": "blue_shulker_box", + "blue_stained_glass": { + "material": "BLUE_STAINED_GLASS" + }, + "bluestainedglass": "blue_stained_glass", + "bluglass": "blue_stained_glass", + "blusglass": "blue_stained_glass", + "blustainedglass": "blue_stained_glass", + "blueglass": "blue_stained_glass", + "bluesglass": "blue_stained_glass", + "blue_stained_glass_pane": { + "material": "BLUE_STAINED_GLASS_PANE" + }, + "bluestainedglasspane": "blue_stained_glass_pane", + "bluglasspane": "blue_stained_glass_pane", + "blusglasspane": "blue_stained_glass_pane", + "blustainedglasspane": "blue_stained_glass_pane", + "blueglasspane": "blue_stained_glass_pane", + "bluesglasspane": "blue_stained_glass_pane", + "blue_terracotta": { + "material": "BLUE_TERRACOTTA" + }, + "blueterracotta": "blue_terracotta", + "bluclay": "blue_terracotta", + "blusclay": "blue_terracotta", + "blustainedclay": "blue_terracotta", + "bluterra": "blue_terracotta", + "blutcota": "blue_terracotta", + "bluterracota": "blue_terracotta", + "bluterracotta": "blue_terracotta", + "blueclay": "blue_terracotta", + "bluesclay": "blue_terracotta", + "bluestainedclay": "blue_terracotta", + "blueterra": "blue_terracotta", + "bluetcota": "blue_terracotta", + "blueterracota": "blue_terracotta", + "blue_wall_banner": { + "material": "BLUE_WALL_BANNER" + }, + "bluewallbanner": "blue_wall_banner", + "bluwallbanner": "blue_wall_banner", + "blue_wool": { + "material": "BLUE_WOOL" + }, + "bluewool": "blue_wool", + "bluwool": "blue_wool", + "blucloth": "blue_wool", + "blucotton": "blue_wool", + "bluecloth": "blue_wool", + "bluecotton": "blue_wool", + "bone": { + "material": "BONE" + }, + "bone_block": { + "material": "BONE_BLOCK" + }, + "boneblock": "bone_block", + "bone_meal": { + "material": "BONE_MEAL" + }, + "bonemeal": "bone_meal", + "book": { + "material": "BOOK" + }, + "bookshelf": { + "material": "BOOKSHELF" + }, + "bow": { + "material": "BOW" + }, + "bowl": { + "material": "BOWL" + }, + "brain_coral": { + "material": "BRAIN_CORAL" + }, + "braincoral": "brain_coral", + "brain_coral_block": { + "material": "BRAIN_CORAL_BLOCK" + }, + "braincoralblock": "brain_coral_block", + "brain_coral_fan": { + "material": "BRAIN_CORAL_FAN" + }, + "braincoralfan": "brain_coral_fan", + "brain_coral_wall_fan": { + "material": "BRAIN_CORAL_WALL_FAN" + }, + "braincoralwallfan": "brain_coral_wall_fan", + "bread": { + "material": "BREAD" + }, + "brewing_stand": { + "material": "BREWING_STAND" + }, + "brewingstand": "brewing_stand", + "brick": { + "material": "BRICK" + }, + "bricks": { + "material": "BRICKS" + }, + "brick_slab": { + "material": "BRICK_SLAB" + }, + "brickslab": "brick_slab", + "brick_stairs": { + "material": "BRICK_STAIRS" + }, + "brickstairs": "brick_stairs", + "brown_banner": { + "material": "BROWN_BANNER" + }, + "brownbanner": "brown_banner", + "brostandingbanner": "brown_banner", + "brobanner": "brown_banner", + "brownstandingbanner": "brown_banner", + "brown_bed": { + "material": "BROWN_BED" + }, + "brownbed": "brown_bed", + "brobed": "brown_bed", + "brown_carpet": { + "material": "BROWN_CARPET" + }, + "browncarpet": "brown_carpet", + "brocarpet": "brown_carpet", + "brofloor": "brown_carpet", + "brownfloor": "brown_carpet", + "brown_concrete": { + "material": "BROWN_CONCRETE" + }, + "brownconcrete": "brown_concrete", + "broconcrete": "brown_concrete", + "brown_concrete_powder": { + "material": "BROWN_CONCRETE_POWDER" + }, + "brownconcretepowder": "brown_concrete_powder", + "broconcretepowder": "brown_concrete_powder", + "broconcretesand": "brown_concrete_powder", + "brownconcretesand": "brown_concrete_powder", + "brown_glazed_terracotta": { + "material": "BROWN_GLAZED_TERRACOTTA" + }, + "brownglazedterracotta": "brown_glazed_terracotta", + "broglazedtcota": "brown_glazed_terracotta", + "broglazedterra": "brown_glazed_terracotta", + "broglazedterracotta": "brown_glazed_terracotta", + "broglazedterracota": "brown_glazed_terracotta", + "brownglazedtcota": "brown_glazed_terracotta", + "brownglazedterra": "brown_glazed_terracotta", + "brownglazedterracota": "brown_glazed_terracotta", + "brown_mushroom": { + "material": "BROWN_MUSHROOM" + }, + "brownmushroom": "potted_brown_mushroom", + "brownmush": "potted_brown_mushroom", + "brownshroom": "potted_brown_mushroom", + "bmushroom": "potted_brown_mushroom", + "bmush": "potted_brown_mushroom", + "bshroom": "potted_brown_mushroom", + "brown_mushroom_block": { + "material": "BROWN_MUSHROOM_BLOCK" + }, + "brownmushroomblock": "brown_mushroom_block", + "giantbrownmushroom": "brown_mushroom_block", + "giantbrownmush": "brown_mushroom_block", + "gbrownmushroom": "brown_mushroom_block", + "gbrownmush": "brown_mushroom_block", + "hugebrownmushroom": "brown_mushroom_block", + "hugebrownmush": "brown_mushroom_block", + "hbrownmushroom": "brown_mushroom_block", + "hbrownmush": "brown_mushroom_block", + "bigbrownmushroom": "brown_mushroom_block", + "bigbrownmush": "brown_mushroom_block", + "bbrownmushroom": "brown_mushroom_block", + "bbrownmush": "brown_mushroom_block", + "giantbmushroom": "brown_mushroom_block", + "giantbmush": "brown_mushroom_block", + "gbmushroom": "brown_mushroom_block", + "gbmush": "brown_mushroom_block", + "hugebmushroom": "brown_mushroom_block", + "hugebmush": "brown_mushroom_block", + "hbmushroom": "brown_mushroom_block", + "hbmush": "brown_mushroom_block", + "bigbmushroom": "brown_mushroom_block", + "bigbmush": "brown_mushroom_block", + "bbmushroom": "brown_mushroom_block", + "bbmush": "brown_mushroom_block", + "brown_shulker_box": { + "material": "BROWN_SHULKER_BOX" + }, + "brownshulkerbox": "brown_shulker_box", + "broshulkerbox": "brown_shulker_box", + "brochest": "brown_shulker_box", + "brownchest": "brown_shulker_box", + "brown_stained_glass": { + "material": "BROWN_STAINED_GLASS" + }, + "brownstainedglass": "brown_stained_glass", + "broglass": "brown_stained_glass", + "brosglass": "brown_stained_glass", + "brostainedglass": "brown_stained_glass", + "brownglass": "brown_stained_glass", + "brownsglass": "brown_stained_glass", + "brown_stained_glass_pane": { + "material": "BROWN_STAINED_GLASS_PANE" + }, + "brownstainedglasspane": "brown_stained_glass_pane", + "broglasspane": "brown_stained_glass_pane", + "brosglasspane": "brown_stained_glass_pane", + "brostainedglasspane": "brown_stained_glass_pane", + "brownglasspane": "brown_stained_glass_pane", + "brownsglasspane": "brown_stained_glass_pane", + "brown_terracotta": { + "material": "BROWN_TERRACOTTA" + }, + "brownterracotta": "brown_terracotta", + "broclay": "brown_terracotta", + "brosclay": "brown_terracotta", + "brostainedclay": "brown_terracotta", + "broterra": "brown_terracotta", + "brotcota": "brown_terracotta", + "broterracota": "brown_terracotta", + "broterracotta": "brown_terracotta", + "brownclay": "brown_terracotta", + "brownsclay": "brown_terracotta", + "brownstainedclay": "brown_terracotta", + "brownterra": "brown_terracotta", + "browntcota": "brown_terracotta", + "brownterracota": "brown_terracotta", + "brown_wall_banner": { + "material": "BROWN_WALL_BANNER" + }, + "brownwallbanner": "brown_wall_banner", + "browallbanner": "brown_wall_banner", + "brown_wool": { + "material": "BROWN_WOOL" + }, + "brownwool": "brown_wool", + "browool": "brown_wool", + "brocloth": "brown_wool", + "brocotton": "brown_wool", + "browncloth": "brown_wool", + "browncotton": "brown_wool", + "bubble_column": { + "material": "BUBBLE_COLUMN" + }, + "bubblecolumn": "bubble_column", + "bubble_coral": { + "material": "BUBBLE_CORAL" + }, + "bubblecoral": "bubble_coral", + "bubble_coral_block": { + "material": "BUBBLE_CORAL_BLOCK" + }, + "bubblecoralblock": "bubble_coral_block", + "bubble_coral_fan": { + "material": "BUBBLE_CORAL_FAN" + }, + "bubblecoralfan": "bubble_coral_fan", + "bubble_coral_wall_fan": { + "material": "BUBBLE_CORAL_WALL_FAN" + }, + "bubblecoralwallfan": "bubble_coral_wall_fan", + "bucket": { + "material": "BUCKET" + }, + "cactus": { + "material": "CACTUS" + }, + "cactus_green": { + "material": "CACTUS_GREEN" + }, + "cactusgreen": "cactus_green", + "cake": { + "material": "CAKE" + }, + "carrot": { + "material": "CARROT" + }, + "carrots": { + "material": "CARROTS" + }, + "carrot_on_a_stick": { + "material": "CARROT_ON_A_STICK" + }, + "carrotonastick": "carrot_on_a_stick", + "carved_pumpkin": { + "material": "CARVED_PUMPKIN" + }, + "carvedpumpkin": "carved_pumpkin", + "cauldron": { + "material": "CAULDRON" + }, + "cave_air": { + "material": "CAVE_AIR" + }, + "caveair": "cave_air", + "cave_spider_spawn_egg": { + "material": "CAVE_SPIDER_SPAWN_EGG" + }, + "cavespiderspawnegg": "cave_spider_spawn_egg", + "chainmail_boots": { + "material": "CHAINMAIL_BOOTS" + }, + "chainmailboots": "chainmail_boots", + "chainmailshoes": "chainmail_boots", + "chainmboots": "chainmail_boots", + "chainmshoes": "chainmail_boots", + "cmailboots": "chainmail_boots", + "cmailshoes": "chainmail_boots", + "chainboots": "chainmail_boots", + "chainshoes": "chainmail_boots", + "cmboots": "chainmail_boots", + "cmshoes": "chainmail_boots", + "chainmail_chestplate": { + "material": "CHAINMAIL_CHESTPLATE" + }, + "chainmailchestplate": "chainmail_chestplate", + "chainmailplatebody": "chainmail_chestplate", + "chainmailplate": "chainmail_chestplate", + "chainmailshirt": "chainmail_chestplate", + "chainmailtunic": "chainmail_chestplate", + "chainmchestplate": "chainmail_chestplate", + "chainmplatebody": "chainmail_chestplate", + "chainmplate": "chainmail_chestplate", + "chainmshirt": "chainmail_chestplate", + "chainmtunic": "chainmail_chestplate", + "cmailchestplate": "chainmail_chestplate", + "cmailplatebody": "chainmail_chestplate", + "cmailplate": "chainmail_chestplate", + "cmailshirt": "chainmail_chestplate", + "cmailtunic": "chainmail_chestplate", + "chainchestplate": "chainmail_chestplate", + "chainplatebody": "chainmail_chestplate", + "chainplate": "chainmail_chestplate", + "chainshirt": "chainmail_chestplate", + "chaintunic": "chainmail_chestplate", + "cmchestplate": "chainmail_chestplate", + "cmplatebody": "chainmail_chestplate", + "cmplate": "chainmail_chestplate", + "cmshirt": "chainmail_chestplate", + "cmtunic": "chainmail_chestplate", + "chainmail_helmet": { + "material": "CHAINMAIL_HELMET" + }, + "chainmailhelmet": "chainmail_helmet", + "chainmailhelm": "chainmail_helmet", + "chainmailhat": "chainmail_helmet", + "chainmailcoif": "chainmail_helmet", + "chainmhelmet": "chainmail_helmet", + "chainmhelm": "chainmail_helmet", + "chainmhat": "chainmail_helmet", + "chainmcoif": "chainmail_helmet", + "cmailhelmet": "chainmail_helmet", + "cmailhelm": "chainmail_helmet", + "cmailhat": "chainmail_helmet", + "cmailcoif": "chainmail_helmet", + "chainhelmet": "chainmail_helmet", + "chainhelm": "chainmail_helmet", + "chainhat": "chainmail_helmet", + "chaincoif": "chainmail_helmet", + "cmhelmet": "chainmail_helmet", + "cmhelm": "chainmail_helmet", + "cmhat": "chainmail_helmet", + "cmcoif": "chainmail_helmet", + "chainmail_leggings": { + "material": "CHAINMAIL_LEGGINGS" + }, + "chainmailleggings": "chainmail_leggings", + "chainmaillegs": "chainmail_leggings", + "chainmailpants": "chainmail_leggings", + "chainmleggings": "chainmail_leggings", + "chainmlegs": "chainmail_leggings", + "chainmpants": "chainmail_leggings", + "cmailleggings": "chainmail_leggings", + "cmaillegs": "chainmail_leggings", + "cmailpants": "chainmail_leggings", + "chainleggings": "chainmail_leggings", + "chainlegs": "chainmail_leggings", + "chainpants": "chainmail_leggings", + "cmleggings": "chainmail_leggings", + "cmlegs": "chainmail_leggings", + "cmpants": "chainmail_leggings", + "chain_command_block": { + "material": "CHAIN_COMMAND_BLOCK" + }, + "chaincommandblock": "chain_command_block", + "charcoal": { + "material": "CHARCOAL" + }, + "chest": { + "material": "CHEST" + }, + "chest_minecart": { + "material": "CHEST_MINECART" + }, + "chestminecart": "chest_minecart", + "chicken": { + "material": "CHICKEN" + }, + "chicken_spawn_egg": { + "material": "CHICKEN_SPAWN_EGG" + }, + "chickenspawnegg": "chicken_spawn_egg", + "chipped_anvil": { + "material": "CHIPPED_ANVIL" + }, + "chippedanvil": "chipped_anvil", + "chiseled_quartz_block": { + "material": "CHISELED_QUARTZ_BLOCK" + }, + "chiseledquartzblock": "chiseled_quartz_block", + "chiseled_red_sandstone": { + "material": "CHISELED_RED_SANDSTONE" + }, + "chiseledredsandstone": "chiseled_red_sandstone", + "crstone": "chiseled_red_sandstone", + "redsandstonechiseled": "chiseled_red_sandstone", + "chiseled_sandstone": { + "material": "CHISELED_SANDSTONE" + }, + "chiseledsandstone": "chiseled_sandstone", + "cpstone": "chiseled_sandstone", + "creepersandstone": "chiseled_sandstone", + "creepersastone": "chiseled_sandstone", + "creepsandstone": "chiseled_sandstone", + "creepsastone": "chiseled_sandstone", + "csandstone": "chiseled_sandstone", + "csastone": "chiseled_sandstone", + "hieroglyphicsandstone": "chiseled_sandstone", + "hieroglyphicsastone": "chiseled_sandstone", + "hieroglyphsandstone": "chiseled_sandstone", + "hieroglyphsastone": "chiseled_sandstone", + "hsandstone": "chiseled_sandstone", + "hsastone": "chiseled_sandstone", + "pyramidsandstone": "chiseled_sandstone", + "pyramidsastone": "chiseled_sandstone", + "psandstone": "chiseled_sandstone", + "psastone": "chiseled_sandstone", + "chiseledsastone": "chiseled_sandstone", + "chiselsandstone": "chiseled_sandstone", + "chiselsastone": "chiseled_sandstone", + "chiseled_stone_bricks": { + "material": "CHISELED_STONE_BRICKS" + }, + "chiseledstonebricks": "chiseled_stone_bricks", + "chorus_flower": { + "material": "CHORUS_FLOWER" + }, + "chorusflower": "chorus_flower", + "chorus_fruit": { + "material": "CHORUS_FRUIT" + }, + "chorusfruit": "chorus_fruit", + "chorus_plant": { + "material": "CHORUS_PLANT" + }, + "chorusplant": "chorus_plant", + "clay": { + "material": "CLAY" + }, + "clay_ball": { + "material": "CLAY_BALL" + }, + "clayball": "clay_ball", + "clock": { + "material": "CLOCK" + }, + "coal": { + "material": "COAL" + }, + "coal_block": { + "material": "COAL_BLOCK" + }, + "coalblock": "coal_block", + "blockcoal": "coal_block", + "cblock": "coal_block", + "blockc": "coal_block", + "coal_ore": { + "material": "COAL_ORE" + }, + "coalore": "coal_ore", + "coalo": "coal_ore", + "orecoal": "coal_ore", + "ocoal": "coal_ore", + "core": "coal_ore", + "co": "coal_ore", + "orec": "coal_ore", + "oc": "coal_ore", + "coarse_dirt": { + "material": "COARSE_DIRT" + }, + "coarsedirt": "coarse_dirt", + "cdirt": "coarse_dirt", + "grasslessdirt": "coarse_dirt", + "grasslessearth": "coarse_dirt", + "grasslessland": "coarse_dirt", + "coarseland": "coarse_dirt", + "coarseearth": "coarse_dirt", + "cobblestone": { + "material": "COBBLESTONE" + }, + "cstone": "cobblestone", + "cobble": "cobblestone", + "cobblestone_slab": { + "material": "COBBLESTONE_SLAB" + }, + "cobblestoneslab": "cobblestone_slab", + "cobblestone_stairs": { + "material": "COBBLESTONE_STAIRS" + }, + "cobblestonestairs": "cobblestone_stairs", + "cobblestone_wall": { + "material": "COBBLESTONE_WALL" + }, + "cobblestonewall": "cobblestone_wall", + "cobweb": { + "material": "COBWEB" + }, + "spiderweb": "cobweb", + "sweb": "cobweb", + "cweb": "cobweb", + "web": "cobweb", + "cocoa": { + "material": "COCOA" + }, + "cocoa_beans": { + "material": "COCOA_BEANS" + }, + "cocoabeans": "cocoa_beans", + "cod": { + "material": "COD" + }, + "cod_bucket": { + "material": "COD_BUCKET" + }, + "codbucket": "cod_bucket", + "cod_spawn_egg": { + "material": "COD_SPAWN_EGG" + }, + "codspawnegg": "cod_spawn_egg", + "command_block": { + "material": "COMMAND_BLOCK" + }, + "commandblock": "command_block", + "command_block_minecart": { + "material": "COMMAND_BLOCK_MINECART" + }, + "commandblockminecart": "command_block_minecart", + "comparator": { + "material": "COMPARATOR" + }, + "compass": { + "material": "COMPASS" + }, + "conduit": { + "material": "CONDUIT" + }, + "cooked_beef": { + "material": "COOKED_BEEF" + }, + "cookedbeef": "cooked_beef", + "cooked_chicken": { + "material": "COOKED_CHICKEN" + }, + "cookedchicken": "cooked_chicken", + "cooked_cod": { + "material": "COOKED_COD" + }, + "cookedcod": "cooked_cod", + "cooked_mutton": { + "material": "COOKED_MUTTON" + }, + "cookedmutton": "cooked_mutton", + "cooked_porkchop": { + "material": "COOKED_PORKCHOP" + }, + "cookedporkchop": "cooked_porkchop", + "cooked_rabbit": { + "material": "COOKED_RABBIT" + }, + "cookedrabbit": "cooked_rabbit", + "cooked_salmon": { + "material": "COOKED_SALMON" + }, + "cookedsalmon": "cooked_salmon", + "cookie": { + "material": "COOKIE" + }, + "cow_spawn_egg": { + "material": "COW_SPAWN_EGG" + }, + "cowspawnegg": "cow_spawn_egg", + "cracked_stone_bricks": { + "material": "CRACKED_STONE_BRICKS" + }, + "crackedstonebricks": "cracked_stone_bricks", + "crafting_table": { + "material": "CRAFTING_TABLE" + }, + "craftingtable": "crafting_table", + "creeper_head": { + "material": "CREEPER_HEAD" + }, + "creeperhead": "creeper_head", + "creeper_spawn_egg": { + "material": "CREEPER_SPAWN_EGG" + }, + "creeperspawnegg": "creeper_spawn_egg", + "creeper_wall_head": { + "material": "CREEPER_WALL_HEAD" + }, + "creeperwallhead": "creeper_wall_head", + "cut_red_sandstone": { + "material": "CUT_RED_SANDSTONE" + }, + "cutredsandstone": "cut_red_sandstone", + "srstone": "cut_red_sandstone", + "redsandstonesmooth": "cut_red_sandstone", + "smoothredsandstone": "smooth_red_sandstone", + "cut_sandstone": { + "material": "CUT_SANDSTONE" + }, + "cutsandstone": "cut_sandstone", + "smstone": "cut_sandstone", + "smoothsastone": "cut_sandstone", + "ssandstone": "cut_sandstone", + "smsastone": "cut_sandstone", + "ssastone": "cut_sandstone", + "cyan_banner": { + "material": "CYAN_BANNER" + }, + "cyanbanner": "cyan_banner", + "cstandingbanner": "cyan_banner", + "cbanner": "cyan_banner", + "cyanstandingbanner": "cyan_banner", + "cyan_bed": { + "material": "CYAN_BED" + }, + "cyanbed": "cyan_bed", + "cbed": "cyan_bed", + "cyan_carpet": { + "material": "CYAN_CARPET" + }, + "cyancarpet": "cyan_carpet", + "ccarpet": "cyan_carpet", + "cfloor": "cyan_carpet", + "cyanfloor": "cyan_carpet", + "cyan_concrete": { + "material": "CYAN_CONCRETE" + }, + "cyanconcrete": "cyan_concrete", + "cconcrete": "cyan_concrete", + "cyan_concrete_powder": { + "material": "CYAN_CONCRETE_POWDER" + }, + "cyanconcretepowder": "cyan_concrete_powder", + "cconcretepowder": "cyan_concrete_powder", + "cconcretesand": "cyan_concrete_powder", + "cyanconcretesand": "cyan_concrete_powder", + "cyan_dye": { + "material": "CYAN_DYE" + }, + "cyandye": "cyan_dye", + "cyan_glazed_terracotta": { + "material": "CYAN_GLAZED_TERRACOTTA" + }, + "cyanglazedterracotta": "cyan_glazed_terracotta", + "cglazedtcota": "cyan_glazed_terracotta", + "cglazedterra": "cyan_glazed_terracotta", + "cglazedterracotta": "cyan_glazed_terracotta", + "cglazedterracota": "cyan_glazed_terracotta", + "cyanglazedtcota": "cyan_glazed_terracotta", + "cyanglazedterra": "cyan_glazed_terracotta", + "cyanglazedterracota": "cyan_glazed_terracotta", + "cyan_shulker_box": { + "material": "CYAN_SHULKER_BOX" + }, + "cyanshulkerbox": "cyan_shulker_box", + "cshulkerbox": "cyan_shulker_box", + "cchest": "cyan_shulker_box", + "cyanchest": "cyan_shulker_box", + "cyan_stained_glass": { + "material": "CYAN_STAINED_GLASS" + }, + "cyanstainedglass": "cyan_stained_glass", + "cglass": "cyan_stained_glass", + "csglass": "cyan_stained_glass", + "cstainedglass": "cyan_stained_glass", + "cyanglass": "cyan_stained_glass", + "cyansglass": "cyan_stained_glass", + "cyan_stained_glass_pane": { + "material": "CYAN_STAINED_GLASS_PANE" + }, + "cyanstainedglasspane": "cyan_stained_glass_pane", + "cglasspane": "cyan_stained_glass_pane", + "csglasspane": "cyan_stained_glass_pane", + "cstainedglasspane": "cyan_stained_glass_pane", + "cyanglasspane": "cyan_stained_glass_pane", + "cyansglasspane": "cyan_stained_glass_pane", + "cyan_terracotta": { + "material": "CYAN_TERRACOTTA" + }, + "cyanterracotta": "cyan_terracotta", + "cclay": "cyan_terracotta", + "csclay": "cyan_terracotta", + "cstainedclay": "cyan_terracotta", + "cterra": "cyan_terracotta", + "ctcota": "cyan_terracotta", + "cterracota": "cyan_terracotta", + "cterracotta": "cyan_terracotta", + "cyanclay": "cyan_terracotta", + "cyansclay": "cyan_terracotta", + "cyanstainedclay": "cyan_terracotta", + "cyanterra": "cyan_terracotta", + "cyantcota": "cyan_terracotta", + "cyanterracota": "cyan_terracotta", + "cyan_wall_banner": { + "material": "CYAN_WALL_BANNER" + }, + "cyanwallbanner": "cyan_wall_banner", + "cwallbanner": "cyan_wall_banner", + "cyan_wool": { + "material": "CYAN_WOOL" + }, + "cyanwool": "cyan_wool", + "cwool": "cyan_wool", + "ccloth": "cyan_wool", + "ccotton": "cyan_wool", + "cyancloth": "cyan_wool", + "cyancotton": "cyan_wool", + "damaged_anvil": { + "material": "DAMAGED_ANVIL" + }, + "damagedanvil": "damaged_anvil", + "dandelion": { + "material": "DANDELION" + }, + "dandelion_yellow": { + "material": "DANDELION_YELLOW" + }, + "dandelionyellow": "dandelion_yellow", + "dark_oak_boat": { + "material": "DARK_OAK_BOAT" + }, + "darkoakboat": "dark_oak_boat", + "doakboat": "dark_oak_boat", + "doboat": "dark_oak_boat", + "dark_oak_button": { + "material": "DARK_OAK_BUTTON" + }, + "darkoakbutton": "dark_oak_button", + "dark_oak_door": { + "material": "DARK_OAK_DOOR" + }, + "darkoakdoor": "dark_oak_door", + "dark_oak_fence": { + "material": "DARK_OAK_FENCE" + }, + "darkoakfence": "dark_oak_fence", + "doakfence": "dark_oak_fence", + "dofence": "dark_oak_fence", + "dark_oak_fence_gate": { + "material": "DARK_OAK_FENCE_GATE" + }, + "darkoakfencegate": "dark_oak_fence_gate", + "darkoakgate": "dark_oak_fence_gate", + "doakfencegate": "dark_oak_fence_gate", + "doakgate": "dark_oak_fence_gate", + "dofencegate": "dark_oak_fence_gate", + "dogate": "dark_oak_fence_gate", + "dark_oak_leaves": { + "material": "DARK_OAK_LEAVES" + }, + "darkoakleaves": "dark_oak_leaves", + "darkoaktreeleaves": "dark_oak_leaves", + "darkoaklogleaves": "dark_oak_leaves", + "darkoaktrunkleaves": "dark_oak_leaves", + "darkoakwoodleaves": "dark_oak_leaves", + "darkoaktreeleaf": "dark_oak_leaves", + "darkoaklogleaf": "dark_oak_leaves", + "darkoaktrunkleaf": "dark_oak_leaves", + "darkoakwoodleaf": "dark_oak_leaves", + "darkoakleaf": "dark_oak_leaves", + "darkoaktreeleave": "dark_oak_leaves", + "darkoaklogleave": "dark_oak_leaves", + "darkoaktrunkleave": "dark_oak_leaves", + "darkoakwoodleave": "dark_oak_leaves", + "darkoakleave": "dark_oak_leaves", + "doaktreeleaves": "dark_oak_leaves", + "doaklogleaves": "dark_oak_leaves", + "doaktrunkleaves": "dark_oak_leaves", + "doakwoodleaves": "dark_oak_leaves", + "doakleaves": "dark_oak_leaves", + "doaktreeleaf": "dark_oak_leaves", + "doaklogleaf": "dark_oak_leaves", + "doaktrunkleaf": "dark_oak_leaves", + "doakwoodleaf": "dark_oak_leaves", + "doakleaf": "dark_oak_leaves", + "doaktreeleave": "dark_oak_leaves", + "doaklogleave": "dark_oak_leaves", + "doaktrunkleave": "dark_oak_leaves", + "doakwoodleave": "dark_oak_leaves", + "doakleave": "dark_oak_leaves", + "dotreeleaves": "dark_oak_leaves", + "dologleaves": "dark_oak_leaves", + "dotrunkleaves": "dark_oak_leaves", + "dowoodleaves": "dark_oak_leaves", + "doleaves": "dark_oak_leaves", + "dotreeleaf": "dark_oak_leaves", + "dologleaf": "dark_oak_leaves", + "dotrunkleaf": "dark_oak_leaves", + "dowoodleaf": "dark_oak_leaves", + "doleaf": "dark_oak_leaves", + "dotreeleave": "dark_oak_leaves", + "dologleave": "dark_oak_leaves", + "dotrunkleave": "dark_oak_leaves", + "dowoodleave": "dark_oak_leaves", + "doleave": "dark_oak_leaves", + "dark_oak_log": { + "material": "DARK_OAK_LOG" + }, + "darkoaklog": "stripped_dark_oak_log", + "darkoak": "stripped_dark_oak_log", + "logdarkoak": "stripped_dark_oak_log", + "darkoaktrunk": "stripped_dark_oak_log", + "darkoaktree": "stripped_dark_oak_log", + "doak": "stripped_dark_oak_log", + "logdoak": "stripped_dark_oak_log", + "doaktrunk": "stripped_dark_oak_log", + "doaklog": "stripped_dark_oak_log", + "doaktree": "stripped_dark_oak_log", + "do": "stripped_dark_oak_log", + "logdo": "stripped_dark_oak_log", + "dotrunk": "stripped_dark_oak_log", + "dolog": "stripped_dark_oak_log", + "dotree": "stripped_dark_oak_log", + "dark_oak_planks": { + "material": "DARK_OAK_PLANKS" + }, + "darkoakplanks": "dark_oak_planks", + "darkoakwoodenplank": "dark_oak_planks", + "darkoakwoodplank": "dark_oak_planks", + "darkoakwplank": "dark_oak_planks", + "darkoakplankwooden": "dark_oak_planks", + "darkoakplankwood": "dark_oak_planks", + "darkoakplankw": "dark_oak_planks", + "darkoakplank": "dark_oak_planks", + "doakwoodenplank": "dark_oak_planks", + "doakwoodplank": "dark_oak_planks", + "doakwplank": "dark_oak_planks", + "doakplankwooden": "dark_oak_planks", + "doakplankwood": "dark_oak_planks", + "doakplankw": "dark_oak_planks", + "doakplank": "dark_oak_planks", + "dowoodenplank": "dark_oak_planks", + "dowoodplank": "dark_oak_planks", + "dowplank": "dark_oak_planks", + "doplankwooden": "dark_oak_planks", + "doplankwood": "dark_oak_planks", + "doplankw": "dark_oak_planks", + "doplank": "dark_oak_planks", + "dark_oak_pressure_plate": { + "material": "DARK_OAK_PRESSURE_PLATE" + }, + "darkoakpressureplate": "dark_oak_pressure_plate", + "dark_oak_sapling": { + "material": "DARK_OAK_SAPLING" + }, + "darkoaksapling": "potted_dark_oak_sapling", + "darkoaktreesapling": "potted_dark_oak_sapling", + "darkoaklogsapling": "potted_dark_oak_sapling", + "darkoaktrunksapling": "potted_dark_oak_sapling", + "darkoakwoodsapling": "potted_dark_oak_sapling", + "doaksapling": "potted_dark_oak_sapling", + "doaktreesapling": "potted_dark_oak_sapling", + "doaklogsapling": "potted_dark_oak_sapling", + "doaktrunksapling": "potted_dark_oak_sapling", + "doakwoodsapling": "potted_dark_oak_sapling", + "dosapling": "potted_dark_oak_sapling", + "dotreesapling": "potted_dark_oak_sapling", + "dologsapling": "potted_dark_oak_sapling", + "dotrunksapling": "potted_dark_oak_sapling", + "dowoodsapling": "potted_dark_oak_sapling", + "dark_oak_slab": { + "material": "DARK_OAK_SLAB" + }, + "darkoakslab": "dark_oak_slab", + "darkoakwoodenstep": "dark_oak_slab", + "darkoakwoodstep": "dark_oak_slab", + "darkoakwstep": "dark_oak_slab", + "darkoakstep": "dark_oak_slab", + "darkoakwoodenslab": "dark_oak_slab", + "darkoakwoodslab": "dark_oak_slab", + "darkoakwslab": "dark_oak_slab", + "darkoakwoodenhalfblock": "dark_oak_slab", + "darkoakwoodhalfblock": "dark_oak_slab", + "darkoakwhalfblock": "dark_oak_slab", + "darkoakhalfblock": "dark_oak_slab", + "doakwoodenstep": "dark_oak_slab", + "doakwoodstep": "dark_oak_slab", + "doakwstep": "dark_oak_slab", + "doakstep": "dark_oak_slab", + "doakwoodenslab": "dark_oak_slab", + "doakwoodslab": "dark_oak_slab", + "doakwslab": "dark_oak_slab", + "doakwoodenhalfblock": "dark_oak_slab", + "doakwoodhalfblock": "dark_oak_slab", + "doakwhalfblock": "dark_oak_slab", + "doakhalfblock": "dark_oak_slab", + "dowoodenstep": "dark_oak_slab", + "dowoodstep": "dark_oak_slab", + "dowstep": "dark_oak_slab", + "dostep": "dark_oak_slab", + "dowoodenslab": "dark_oak_slab", + "dowoodslab": "dark_oak_slab", + "dowslab": "dark_oak_slab", + "dowoodenhalfblock": "dark_oak_slab", + "dowoodhalfblock": "dark_oak_slab", + "dowhalfblock": "dark_oak_slab", + "dohalfblock": "dark_oak_slab", + "dark_oak_stairs": { + "material": "DARK_OAK_STAIRS" + }, + "darkoakstairs": "dark_oak_stairs", + "darkoakwoodenstairs": "dark_oak_stairs", + "darkoakwoodstairs": "dark_oak_stairs", + "darkoakwstairs": "dark_oak_stairs", + "darkoakwoodenstair": "dark_oak_stairs", + "darkoakwoodstair": "dark_oak_stairs", + "darkoakwstair": "dark_oak_stairs", + "darkoakstair": "dark_oak_stairs", + "doakwoodenstairs": "dark_oak_stairs", + "doakwoodstairs": "dark_oak_stairs", + "doakwstairs": "dark_oak_stairs", + "doakwoodenstair": "dark_oak_stairs", + "doakwoodstair": "dark_oak_stairs", + "doakwstair": "dark_oak_stairs", + "doakstair": "dark_oak_stairs", + "dowoodenstairs": "dark_oak_stairs", + "dowoodstairs": "dark_oak_stairs", + "dowstairs": "dark_oak_stairs", + "dowoodenstair": "dark_oak_stairs", + "dowoodstair": "dark_oak_stairs", + "dowstair": "dark_oak_stairs", + "dostair": "dark_oak_stairs", + "dark_oak_trapdoor": { + "material": "DARK_OAK_TRAPDOOR" + }, + "darkoaktrapdoor": "dark_oak_trapdoor", + "dark_oak_wood": { + "material": "DARK_OAK_WOOD" + }, + "darkoakwood": "stripped_dark_oak_wood", + "darkoaklogall": "stripped_dark_oak_wood", + "darkoaktrunkall": "stripped_dark_oak_wood", + "darkoaktreeall": "stripped_dark_oak_wood", + "doakwood": "stripped_dark_oak_wood", + "doaklogall": "stripped_dark_oak_wood", + "doaktrunkall": "stripped_dark_oak_wood", + "doaktreeall": "stripped_dark_oak_wood", + "dowood": "stripped_dark_oak_wood", + "dologall": "stripped_dark_oak_wood", + "dotrunkall": "stripped_dark_oak_wood", + "dotreeall": "stripped_dark_oak_wood", + "dark_prismarine": { + "material": "DARK_PRISMARINE" + }, + "darkprismarine": "dark_prismarine", + "dark_prismarine_slab": { + "material": "DARK_PRISMARINE_SLAB" + }, + "darkprismarineslab": "dark_prismarine_slab", + "dark_prismarine_stairs": { + "material": "DARK_PRISMARINE_STAIRS" + }, + "darkprismarinestairs": "dark_prismarine_stairs", + "daylight_detector": { + "material": "DAYLIGHT_DETECTOR" + }, + "daylightdetector": "daylight_detector", + "dead_brain_coral_block": { + "material": "DEAD_BRAIN_CORAL_BLOCK" + }, + "deadbraincoralblock": "dead_brain_coral_block", + "dead_brain_coral_fan": { + "material": "DEAD_BRAIN_CORAL_FAN" + }, + "deadbraincoralfan": "dead_brain_coral_fan", + "dead_brain_coral_wall_fan": { + "material": "DEAD_BRAIN_CORAL_WALL_FAN" + }, + "deadbraincoralwallfan": "dead_brain_coral_wall_fan", + "dead_bubble_coral_block": { + "material": "DEAD_BUBBLE_CORAL_BLOCK" + }, + "deadbubblecoralblock": "dead_bubble_coral_block", + "dead_bubble_coral_fan": { + "material": "DEAD_BUBBLE_CORAL_FAN" + }, + "deadbubblecoralfan": "dead_bubble_coral_fan", + "dead_bubble_coral_wall_fan": { + "material": "DEAD_BUBBLE_CORAL_WALL_FAN" + }, + "deadbubblecoralwallfan": "dead_bubble_coral_wall_fan", + "dead_bush": { + "material": "DEAD_BUSH" + }, + "deadbush": "dead_bush", + "dead_fire_coral_block": { + "material": "DEAD_FIRE_CORAL_BLOCK" + }, + "deadfirecoralblock": "dead_fire_coral_block", + "dead_fire_coral_fan": { + "material": "DEAD_FIRE_CORAL_FAN" + }, + "deadfirecoralfan": "dead_fire_coral_fan", + "dead_fire_coral_wall_fan": { + "material": "DEAD_FIRE_CORAL_WALL_FAN" + }, + "deadfirecoralwallfan": "dead_fire_coral_wall_fan", + "dead_horn_coral_block": { + "material": "DEAD_HORN_CORAL_BLOCK" + }, + "deadhorncoralblock": "dead_horn_coral_block", + "dead_horn_coral_fan": { + "material": "DEAD_HORN_CORAL_FAN" + }, + "deadhorncoralfan": "dead_horn_coral_fan", + "dead_horn_coral_wall_fan": { + "material": "DEAD_HORN_CORAL_WALL_FAN" + }, + "deadhorncoralwallfan": "dead_horn_coral_wall_fan", + "dead_tube_coral_block": { + "material": "DEAD_TUBE_CORAL_BLOCK" + }, + "deadtubecoralblock": "dead_tube_coral_block", + "dead_tube_coral_fan": { + "material": "DEAD_TUBE_CORAL_FAN" + }, + "deadtubecoralfan": "dead_tube_coral_fan", + "dead_tube_coral_wall_fan": { + "material": "DEAD_TUBE_CORAL_WALL_FAN" + }, + "deadtubecoralwallfan": "dead_tube_coral_wall_fan", + "debug_stick": { + "material": "DEBUG_STICK" + }, + "debugstick": "debug_stick", + "detector_rail": { + "material": "DETECTOR_RAIL" + }, + "detectorrail": "detector_rail", + "detectorrails": "detector_rail", + "detectortrack": "detector_rail", + "detectingrails": "detector_rail", + "detectingrail": "detector_rail", + "detectingtrack": "detector_rail", + "detectrails": "detector_rail", + "detectrail": "detector_rail", + "detecttrack": "detector_rail", + "drails": "detector_rail", + "drail": "detector_rail", + "dtrack": "detector_rail", + "diamond": { + "material": "DIAMOND" + }, + "diamond_axe": { + "material": "DIAMOND_AXE" + }, + "diamondaxe": "diamond_axe", + "crystalaxe": "diamond_axe", + "daxe": "diamond_axe", + "diamond_block": { + "material": "DIAMOND_BLOCK" + }, + "diamondblock": "diamond_block", + "crystalblock": "diamond_block", + "blockcrystal": "diamond_block", + "blockdiamond": "diamond_block", + "dblock": "diamond_block", + "blockd": "diamond_block", + "diamond_boots": { + "material": "DIAMOND_BOOTS" + }, + "diamondboots": "diamond_boots", + "crystalboots": "diamond_boots", + "crystalshoes": "diamond_boots", + "diamondshoes": "diamond_boots", + "dboots": "diamond_boots", + "dshoes": "diamond_boots", + "diamond_chestplate": { + "material": "DIAMOND_CHESTPLATE" + }, + "diamondchestplate": "diamond_chestplate", + "crystalchestplate": "diamond_chestplate", + "crystalplatebody": "diamond_chestplate", + "crystalplate": "diamond_chestplate", + "crystalshirt": "diamond_chestplate", + "crystaltunic": "diamond_chestplate", + "diamondplatebody": "diamond_chestplate", + "diamondplate": "diamond_chestplate", + "diamondshirt": "diamond_chestplate", + "diamondtunic": "diamond_chestplate", + "dchestplate": "diamond_chestplate", + "dplatebody": "diamond_chestplate", + "dplate": "diamond_chestplate", + "dshirt": "diamond_chestplate", + "dtunic": "diamond_chestplate", + "diamond_helmet": { + "material": "DIAMOND_HELMET" + }, + "diamondhelmet": "diamond_helmet", + "crystalhelmet": "diamond_helmet", + "crystalhelm": "diamond_helmet", + "crystalhat": "diamond_helmet", + "crystalcoif": "diamond_helmet", + "diamondhelm": "diamond_helmet", + "diamondhat": "diamond_helmet", + "diamondcoif": "diamond_helmet", + "dhelmet": "diamond_helmet", + "dhelm": "diamond_helmet", + "dhat": "diamond_helmet", + "dcoif": "diamond_helmet", + "diamond_hoe": { + "material": "DIAMOND_HOE" + }, + "diamondhoe": "diamond_hoe", + "crystalhoe": "diamond_hoe", + "dhoe": "diamond_hoe", + "diamond_horse_armor": { + "material": "DIAMOND_HORSE_ARMOR" + }, + "diamondhorsearmor": "diamond_horse_armor", + "diamond_leggings": { + "material": "DIAMOND_LEGGINGS" + }, + "diamondleggings": "diamond_leggings", + "crystalleggings": "diamond_leggings", + "crystallegs": "diamond_leggings", + "crystalpants": "diamond_leggings", + "diamondlegs": "diamond_leggings", + "diamondpants": "diamond_leggings", + "dleggings": "diamond_leggings", + "dlegs": "diamond_leggings", + "dpants": "diamond_leggings", + "diamond_ore": { + "material": "DIAMOND_ORE" + }, + "diamondore": "diamond_ore", + "crystalore": "diamond_ore", + "crystalo": "diamond_ore", + "orecrystal": "diamond_ore", + "ocrystal": "diamond_ore", + "diamondo": "diamond_ore", + "orediamond": "diamond_ore", + "odiamond": "diamond_ore", + "dore": "diamond_ore", + "ored": "redstone_ore", + "od": "diamond_ore", + "diamond_pickaxe": { + "material": "DIAMOND_PICKAXE" + }, + "diamondpickaxe": "diamond_pickaxe", + "crystalpickaxe": "diamond_pickaxe", + "crystalpick": "diamond_pickaxe", + "diamondpick": "diamond_pickaxe", + "dpickaxe": "diamond_pickaxe", + "dpick": "diamond_pickaxe", + "diamond_shovel": { + "material": "DIAMOND_SHOVEL" + }, + "diamondshovel": "diamond_shovel", + "crystalshovel": "diamond_shovel", + "crystalspade": "diamond_shovel", + "diamondspade": "diamond_shovel", + "dshovel": "diamond_shovel", + "dspade": "diamond_shovel", + "diamond_sword": { + "material": "DIAMOND_SWORD" + }, + "diamondsword": "diamond_sword", + "crystalsword": "diamond_sword", + "dsword": "diamond_sword", + "diorite": { + "material": "DIORITE" + }, + "dstone": "diorite", + "dirt": { + "material": "DIRT" + }, + "earth": "dirt", + "land": "dirt", + "dispenser": { + "material": "DISPENSER" + }, + "dispense": "dispenser", + "dolphin_spawn_egg": { + "material": "DOLPHIN_SPAWN_EGG" + }, + "dolphinspawnegg": "dolphin_spawn_egg", + "donkey_spawn_egg": { + "material": "DONKEY_SPAWN_EGG" + }, + "donkeyspawnegg": "donkey_spawn_egg", + "dragon_breath": { + "material": "DRAGON_BREATH" + }, + "dragonbreath": "dragon_breath", + "dragon_egg": { + "material": "DRAGON_EGG" + }, + "dragonegg": "dragon_egg", + "dragon_head": { + "material": "DRAGON_HEAD" + }, + "dragonhead": "dragon_head", + "dragon_wall_head": { + "material": "DRAGON_WALL_HEAD" + }, + "dragonwallhead": "dragon_wall_head", + "dried_kelp": { + "material": "DRIED_KELP" + }, + "driedkelp": "dried_kelp", + "dried_kelp_block": { + "material": "DRIED_KELP_BLOCK" + }, + "driedkelpblock": "dried_kelp_block", + "dropper": { + "material": "DROPPER" + }, + "drowned_spawn_egg": { + "material": "DROWNED_SPAWN_EGG" + }, + "drownedspawnegg": "drowned_spawn_egg", + "egg": { + "material": "EGG" + }, + "elder_guardian_spawn_egg": { + "material": "ELDER_GUARDIAN_SPAWN_EGG" + }, + "elderguardianspawnegg": "elder_guardian_spawn_egg", + "elytra": { + "material": "ELYTRA" + }, + "emerald": { + "material": "EMERALD" + }, + "emerald_block": { + "material": "EMERALD_BLOCK" + }, + "emeraldblock": "emerald_block", + "blockemerald": "emerald_block", + "eblock": "emerald_block", + "blocke": "emerald_block", + "emerald_ore": { + "material": "EMERALD_ORE" + }, + "emeraldore": "emerald_ore", + "emeraldo": "emerald_ore", + "oreemerald": "emerald_ore", + "oemerald": "emerald_ore", + "eore": "emerald_ore", + "eo": "emerald_ore", + "oree": "emerald_ore", + "oe": "emerald_ore", + "enchanted_book": { + "material": "ENCHANTED_BOOK" + }, + "enchantedbook": "enchanted_book", + "enchanted_golden_apple": { + "material": "ENCHANTED_GOLDEN_APPLE" + }, + "enchantedgoldenapple": "enchanted_golden_apple", + "enchanting_table": { + "material": "ENCHANTING_TABLE" + }, + "enchantingtable": "enchanting_table", + "enderman_spawn_egg": { + "material": "ENDERMAN_SPAWN_EGG" + }, + "endermanspawnegg": "enderman_spawn_egg", + "endermite_spawn_egg": { + "material": "ENDERMITE_SPAWN_EGG" + }, + "endermitespawnegg": "endermite_spawn_egg", + "ender_chest": { + "material": "ENDER_CHEST" + }, + "enderchest": "ender_chest", + "ender_eye": { + "material": "ENDER_EYE" + }, + "endereye": "ender_eye", + "ender_pearl": { + "material": "ENDER_PEARL" + }, + "enderpearl": "ender_pearl", + "end_crystal": { + "material": "END_CRYSTAL" + }, + "endcrystal": "end_crystal", + "end_gateway": { + "material": "END_GATEWAY" + }, + "endgateway": "end_gateway", + "end_portal": { + "material": "END_PORTAL" + }, + "endportal": "end_portal", + "end_portal_frame": { + "material": "END_PORTAL_FRAME" + }, + "endportalframe": "end_portal_frame", + "end_rod": { + "material": "END_ROD" + }, + "endrod": "end_rod", + "end_stone": { + "material": "END_STONE" + }, + "endstone": "end_stone", + "end_stone_bricks": { + "material": "END_STONE_BRICKS" + }, + "endstonebricks": "end_stone_bricks", + "evoker_spawn_egg": { + "material": "EVOKER_SPAWN_EGG" + }, + "evokerspawnegg": "evoker_spawn_egg", + "experience_bottle": { + "material": "EXPERIENCE_BOTTLE" + }, + "experiencebottle": "experience_bottle", + "farmland": { + "material": "FARMLAND" + }, + "feather": { + "material": "FEATHER" + }, + "fermented_spider_eye": { + "material": "FERMENTED_SPIDER_EYE" + }, + "fermentedspidereye": "fermented_spider_eye", + "fern": { + "material": "FERN" + }, + "filled_map": { + "material": "FILLED_MAP" + }, + "filledmap": "filled_map", + "fire": { + "material": "FIRE" + }, + "firework_rocket": { + "material": "FIREWORK_ROCKET" + }, + "fireworkrocket": "firework_rocket", + "firework_star": { + "material": "FIREWORK_STAR" + }, + "fireworkstar": "firework_star", + "fire_charge": { + "material": "FIRE_CHARGE" + }, + "firecharge": "fire_charge", + "fire_coral": { + "material": "FIRE_CORAL" + }, + "firecoral": "fire_coral", + "fire_coral_block": { + "material": "FIRE_CORAL_BLOCK" + }, + "firecoralblock": "fire_coral_block", + "fire_coral_fan": { + "material": "FIRE_CORAL_FAN" + }, + "firecoralfan": "fire_coral_fan", + "fire_coral_wall_fan": { + "material": "FIRE_CORAL_WALL_FAN" + }, + "firecoralwallfan": "fire_coral_wall_fan", + "fishing_rod": { + "material": "FISHING_ROD" + }, + "fishingrod": "fishing_rod", + "flint": { + "material": "FLINT" + }, + "flint_and_steel": { + "material": "FLINT_AND_STEEL" + }, + "flintandsteel": "flint_and_steel", + "flower_pot": { + "material": "FLOWER_POT" + }, + "flowerpot": "flower_pot", + "frosted_ice": { + "material": "FROSTED_ICE" + }, + "frostedice": "frosted_ice", + "furnace": { + "material": "FURNACE" + }, + "furnace_minecart": { + "material": "FURNACE_MINECART" + }, + "furnaceminecart": "furnace_minecart", + "ghast_spawn_egg": { + "material": "GHAST_SPAWN_EGG" + }, + "ghastspawnegg": "ghast_spawn_egg", + "ghast_tear": { + "material": "GHAST_TEAR" + }, + "ghasttear": "ghast_tear", + "glass": { + "material": "GLASS" + }, + "blockglass": "glass", + "glassblock": "glass", + "glass_bottle": { + "material": "GLASS_BOTTLE" + }, + "glassbottle": "glass_bottle", + "glass_pane": { + "material": "GLASS_PANE" + }, + "glasspane": "glass_pane", + "glistering_melon_slice": { + "material": "GLISTERING_MELON_SLICE" + }, + "glisteringmelonslice": "glistering_melon_slice", + "glowstone": { + "material": "GLOWSTONE" + }, + "glowstone_dust": { + "material": "GLOWSTONE_DUST" + }, + "glowstonedust": "glowstone_dust", + "golden_apple": { + "material": "GOLDEN_APPLE" + }, + "goldenapple": "golden_apple", + "golden_axe": { + "material": "GOLDEN_AXE" + }, + "goldenaxe": "golden_axe", + "goldaxe": "golden_axe", + "gaxe": "golden_axe", + "golden_boots": { + "material": "GOLDEN_BOOTS" + }, + "goldenboots": "golden_boots", + "goldboots": "golden_boots", + "goldshoes": "golden_boots", + "gboots": "golden_boots", + "gshoes": "golden_boots", + "golden_carrot": { + "material": "GOLDEN_CARROT" + }, + "goldencarrot": "golden_carrot", + "golden_chestplate": { + "material": "GOLDEN_CHESTPLATE" + }, + "goldenchestplate": "golden_chestplate", + "goldchestplate": "golden_chestplate", + "goldplatebody": "golden_chestplate", + "goldplate": "golden_chestplate", + "goldshirt": "golden_chestplate", + "goldtunic": "golden_chestplate", + "gchestplate": "golden_chestplate", + "gplatebody": "golden_chestplate", + "gplate": "golden_chestplate", + "gshirt": "golden_chestplate", + "gtunic": "golden_chestplate", + "golden_helmet": { + "material": "GOLDEN_HELMET" + }, + "goldenhelmet": "golden_helmet", + "goldhelmet": "golden_helmet", + "goldhelm": "golden_helmet", + "goldhat": "golden_helmet", + "goldcoif": "golden_helmet", + "ghelmet": "golden_helmet", + "ghelm": "golden_helmet", + "ghat": "golden_helmet", + "gcoif": "golden_helmet", + "golden_hoe": { + "material": "GOLDEN_HOE" + }, + "goldenhoe": "golden_hoe", + "goldhoe": "golden_hoe", + "ghoe": "golden_hoe", + "golden_horse_armor": { + "material": "GOLDEN_HORSE_ARMOR" + }, + "goldenhorsearmor": "golden_horse_armor", + "golden_leggings": { + "material": "GOLDEN_LEGGINGS" + }, + "goldenleggings": "golden_leggings", + "goldleggings": "golden_leggings", + "goldlegs": "golden_leggings", + "goldpants": "golden_leggings", + "gleggings": "golden_leggings", + "glegs": "golden_leggings", + "gpants": "golden_leggings", + "golden_pickaxe": { + "material": "GOLDEN_PICKAXE" + }, + "goldenpickaxe": "golden_pickaxe", + "goldpickaxe": "golden_pickaxe", + "goldpick": "golden_pickaxe", + "gpickaxe": "golden_pickaxe", + "gpick": "golden_pickaxe", + "golden_shovel": { + "material": "GOLDEN_SHOVEL" + }, + "goldenshovel": "golden_shovel", + "goldshovel": "golden_shovel", + "goldspade": "golden_shovel", + "gshovel": "golden_shovel", + "gspade": "golden_shovel", + "golden_sword": { + "material": "GOLDEN_SWORD" + }, + "goldensword": "golden_sword", + "goldsword": "golden_sword", + "gsword": "golden_sword", + "gold_block": { + "material": "GOLD_BLOCK" + }, + "goldblock": "gold_block", + "blockgold": "gold_block", + "gblock": "gold_block", + "blockg": "gold_block", + "gold_ingot": { + "material": "GOLD_INGOT" + }, + "goldingot": "gold_ingot", + "goldbar": "gold_ingot", + "goldi": "gold_ingot", + "ingotgold": "gold_ingot", + "bargold": "gold_ingot", + "igold": "gold_ingot", + "gingot": "gold_ingot", + "gbar": "gold_ingot", + "gi": "gold_ingot", + "ingotg": "gold_ingot", + "barg": "gold_ingot", + "ig": "gold_ingot", + "gold_nugget": { + "material": "GOLD_NUGGET" + }, + "goldnugget": "gold_nugget", + "gold_ore": { + "material": "GOLD_ORE" + }, + "goldore": "gold_ore", + "goldo": "gold_ore", + "oregold": "gold_ore", + "ogold": "gold_ore", + "gore": "gold_ore", + "go": "gold_ore", + "oreg": "gold_ore", + "og": "gold_ore", + "granite": { + "material": "GRANITE" + }, + "gstone": "granite", + "grass": { + "material": "GRASS" + }, + "grass_block": { + "material": "GRASS_BLOCK" + }, + "grassblock": "grass_block", + "greendirt": "grass_block", + "greenearth": "grass_block", + "greenland": "grass_block", + "grass_path": { + "material": "GRASS_PATH" + }, + "grasspath": "grass_path", + "gravel": { + "material": "GRAVEL" + }, + "gray_banner": { + "material": "GRAY_BANNER" + }, + "graybanner": "gray_banner", + "grastandingbanner": "gray_banner", + "grabanner": "gray_banner", + "greystandingbanner": "gray_banner", + "greybanner": "gray_banner", + "graystandingbanner": "gray_banner", + "dgrastandingbanner": "gray_banner", + "dgrabanner": "gray_banner", + "darkgrastandingbanner": "gray_banner", + "darkgrabanner": "gray_banner", + "dgreystandingbanner": "gray_banner", + "dgreybanner": "gray_banner", + "dgraystandingbanner": "gray_banner", + "dgraybanner": "gray_banner", + "darkgreystandingbanner": "gray_banner", + "darkgreybanner": "gray_banner", + "darkgraystandingbanner": "gray_banner", + "darkgraybanner": "gray_banner", + "gray_bed": { + "material": "GRAY_BED" + }, + "graybed": "gray_bed", + "grabed": "gray_bed", + "greybed": "gray_bed", + "dgrabed": "gray_bed", + "darkgrabed": "gray_bed", + "dgreybed": "gray_bed", + "dgraybed": "gray_bed", + "darkgreybed": "gray_bed", + "darkgraybed": "gray_bed", + "gray_carpet": { + "material": "GRAY_CARPET" + }, + "graycarpet": "gray_carpet", + "gracarpet": "gray_carpet", + "grafloor": "gray_carpet", + "greycarpet": "gray_carpet", + "greyfloor": "gray_carpet", + "grayfloor": "gray_carpet", + "dgracarpet": "gray_carpet", + "dgrafloor": "gray_carpet", + "darkgracarpet": "gray_carpet", + "darkgrafloor": "gray_carpet", + "dgreycarpet": "gray_carpet", + "dgreyfloor": "gray_carpet", + "dgraycarpet": "gray_carpet", + "dgrayfloor": "gray_carpet", + "darkgreycarpet": "gray_carpet", + "darkgreyfloor": "gray_carpet", + "darkgraycarpet": "gray_carpet", + "darkgrayfloor": "gray_carpet", + "gray_concrete": { + "material": "GRAY_CONCRETE" + }, + "grayconcrete": "gray_concrete", + "graconcrete": "gray_concrete", + "greyconcrete": "gray_concrete", + "dgraconcrete": "gray_concrete", + "darkgraconcrete": "gray_concrete", + "dgreyconcrete": "gray_concrete", + "dgrayconcrete": "gray_concrete", + "darkgreyconcrete": "gray_concrete", + "darkgrayconcrete": "gray_concrete", + "gray_concrete_powder": { + "material": "GRAY_CONCRETE_POWDER" + }, + "grayconcretepowder": "gray_concrete_powder", + "graconcretepowder": "gray_concrete_powder", + "graconcretesand": "gray_concrete_powder", + "greyconcretepowder": "gray_concrete_powder", + "greyconcretesand": "gray_concrete_powder", + "grayconcretesand": "gray_concrete_powder", + "dgraconcretepowder": "gray_concrete_powder", + "dgraconcretesand": "gray_concrete_powder", + "darkgraconcretepowder": "gray_concrete_powder", + "darkgraconcretesand": "gray_concrete_powder", + "dgreyconcretepowder": "gray_concrete_powder", + "dgreyconcretesand": "gray_concrete_powder", + "dgrayconcretepowder": "gray_concrete_powder", + "dgrayconcretesand": "gray_concrete_powder", + "darkgreyconcretepowder": "gray_concrete_powder", + "darkgreyconcretesand": "gray_concrete_powder", + "darkgrayconcretepowder": "gray_concrete_powder", + "darkgrayconcretesand": "gray_concrete_powder", + "gray_dye": { + "material": "GRAY_DYE" + }, + "graydye": "gray_dye", + "gray_glazed_terracotta": { + "material": "GRAY_GLAZED_TERRACOTTA" + }, + "grayglazedterracotta": "gray_glazed_terracotta", + "graglazedtcota": "gray_glazed_terracotta", + "graglazedterra": "gray_glazed_terracotta", + "graglazedterracotta": "gray_glazed_terracotta", + "graglazedterracota": "gray_glazed_terracotta", + "greyglazedtcota": "gray_glazed_terracotta", + "greyglazedterra": "gray_glazed_terracotta", + "greyglazedterracotta": "gray_glazed_terracotta", + "greyglazedterracota": "gray_glazed_terracotta", + "grayglazedtcota": "gray_glazed_terracotta", + "grayglazedterra": "gray_glazed_terracotta", + "grayglazedterracota": "gray_glazed_terracotta", + "dgraglazedtcota": "gray_glazed_terracotta", + "dgraglazedterra": "gray_glazed_terracotta", + "dgraglazedterracotta": "gray_glazed_terracotta", + "dgraglazedterracota": "gray_glazed_terracotta", + "darkgraglazedtcota": "gray_glazed_terracotta", + "darkgraglazedterra": "gray_glazed_terracotta", + "darkgraglazedterracotta": "gray_glazed_terracotta", + "darkgraglazedterracota": "gray_glazed_terracotta", + "dgreyglazedtcota": "gray_glazed_terracotta", + "dgreyglazedterra": "gray_glazed_terracotta", + "dgreyglazedterracotta": "gray_glazed_terracotta", + "dgreyglazedterracota": "gray_glazed_terracotta", + "dgrayglazedtcota": "gray_glazed_terracotta", + "dgrayglazedterra": "gray_glazed_terracotta", + "dgrayglazedterracotta": "gray_glazed_terracotta", + "dgrayglazedterracota": "gray_glazed_terracotta", + "darkgreyglazedtcota": "gray_glazed_terracotta", + "darkgreyglazedterra": "gray_glazed_terracotta", + "darkgreyglazedterracotta": "gray_glazed_terracotta", + "darkgreyglazedterracota": "gray_glazed_terracotta", + "darkgrayglazedtcota": "gray_glazed_terracotta", + "darkgrayglazedterra": "gray_glazed_terracotta", + "darkgrayglazedterracotta": "gray_glazed_terracotta", + "darkgrayglazedterracota": "gray_glazed_terracotta", + "gray_shulker_box": { + "material": "GRAY_SHULKER_BOX" + }, + "grayshulkerbox": "gray_shulker_box", + "grashulkerbox": "gray_shulker_box", + "grachest": "gray_shulker_box", + "greyshulkerbox": "gray_shulker_box", + "greychest": "gray_shulker_box", + "graychest": "gray_shulker_box", + "dgrashulkerbox": "gray_shulker_box", + "dgrachest": "gray_shulker_box", + "darkgrashulkerbox": "gray_shulker_box", + "darkgrachest": "gray_shulker_box", + "dgreyshulkerbox": "gray_shulker_box", + "dgreychest": "gray_shulker_box", + "dgrayshulkerbox": "gray_shulker_box", + "dgraychest": "gray_shulker_box", + "darkgreyshulkerbox": "gray_shulker_box", + "darkgreychest": "gray_shulker_box", + "darkgrayshulkerbox": "gray_shulker_box", + "darkgraychest": "gray_shulker_box", + "gray_stained_glass": { + "material": "GRAY_STAINED_GLASS" + }, + "graystainedglass": "gray_stained_glass", + "graglass": "gray_stained_glass", + "grasglass": "gray_stained_glass", + "grastainedglass": "gray_stained_glass", + "greyglass": "gray_stained_glass", + "greysglass": "gray_stained_glass", + "greystainedglass": "gray_stained_glass", + "grayglass": "gray_stained_glass", + "graysglass": "gray_stained_glass", + "dgraglass": "gray_stained_glass", + "dgrasglass": "gray_stained_glass", + "dgrastainedglass": "gray_stained_glass", + "darkgraglass": "gray_stained_glass", + "darkgrasglass": "gray_stained_glass", + "darkgrastainedglass": "gray_stained_glass", + "dgreyglass": "gray_stained_glass", + "dgreysglass": "gray_stained_glass", + "dgreystainedglass": "gray_stained_glass", + "dgrayglass": "gray_stained_glass", + "dgraysglass": "gray_stained_glass", + "dgraystainedglass": "gray_stained_glass", + "darkgreyglass": "gray_stained_glass", + "darkgreysglass": "gray_stained_glass", + "darkgreystainedglass": "gray_stained_glass", + "darkgrayglass": "gray_stained_glass", + "darkgraysglass": "gray_stained_glass", + "darkgraystainedglass": "gray_stained_glass", + "gray_stained_glass_pane": { + "material": "GRAY_STAINED_GLASS_PANE" + }, + "graystainedglasspane": "gray_stained_glass_pane", + "graglasspane": "gray_stained_glass_pane", + "grasglasspane": "gray_stained_glass_pane", + "grastainedglasspane": "gray_stained_glass_pane", + "greyglasspane": "gray_stained_glass_pane", + "greysglasspane": "gray_stained_glass_pane", + "greystainedglasspane": "gray_stained_glass_pane", + "grayglasspane": "gray_stained_glass_pane", + "graysglasspane": "gray_stained_glass_pane", + "dgraglasspane": "gray_stained_glass_pane", + "dgrasglasspane": "gray_stained_glass_pane", + "dgrastainedglasspane": "gray_stained_glass_pane", + "darkgraglasspane": "gray_stained_glass_pane", + "darkgrasglasspane": "gray_stained_glass_pane", + "darkgrastainedglasspane": "gray_stained_glass_pane", + "dgreyglasspane": "gray_stained_glass_pane", + "dgreysglasspane": "gray_stained_glass_pane", + "dgreystainedglasspane": "gray_stained_glass_pane", + "dgrayglasspane": "gray_stained_glass_pane", + "dgraysglasspane": "gray_stained_glass_pane", + "dgraystainedglasspane": "gray_stained_glass_pane", + "darkgreyglasspane": "gray_stained_glass_pane", + "darkgreysglasspane": "gray_stained_glass_pane", + "darkgreystainedglasspane": "gray_stained_glass_pane", + "darkgrayglasspane": "gray_stained_glass_pane", + "darkgraysglasspane": "gray_stained_glass_pane", + "darkgraystainedglasspane": "gray_stained_glass_pane", + "gray_terracotta": { + "material": "GRAY_TERRACOTTA" + }, + "grayterracotta": "gray_terracotta", + "graclay": "gray_terracotta", + "grasclay": "gray_terracotta", + "grastainedclay": "gray_terracotta", + "graterra": "gray_terracotta", + "gratcota": "gray_terracotta", + "graterracota": "gray_terracotta", + "graterracotta": "gray_terracotta", + "greyclay": "gray_terracotta", + "greysclay": "gray_terracotta", + "greystainedclay": "gray_terracotta", + "greyterra": "gray_terracotta", + "greytcota": "gray_terracotta", + "greyterracota": "gray_terracotta", + "greyterracotta": "gray_terracotta", + "grayclay": "gray_terracotta", + "graysclay": "gray_terracotta", + "graystainedclay": "gray_terracotta", + "grayterra": "gray_terracotta", + "graytcota": "gray_terracotta", + "grayterracota": "gray_terracotta", + "dgraclay": "gray_terracotta", + "dgrasclay": "gray_terracotta", + "dgrastainedclay": "gray_terracotta", + "dgraterra": "gray_terracotta", + "dgratcota": "gray_terracotta", + "dgraterracota": "gray_terracotta", + "dgraterracotta": "gray_terracotta", + "darkgraclay": "gray_terracotta", + "darkgrasclay": "gray_terracotta", + "darkgrastainedclay": "gray_terracotta", + "darkgraterra": "gray_terracotta", + "darkgratcota": "gray_terracotta", + "darkgraterracota": "gray_terracotta", + "darkgraterracotta": "gray_terracotta", + "dgreyclay": "gray_terracotta", + "dgreysclay": "gray_terracotta", + "dgreystainedclay": "gray_terracotta", + "dgreyterra": "gray_terracotta", + "dgreytcota": "gray_terracotta", + "dgreyterracota": "gray_terracotta", + "dgreyterracotta": "gray_terracotta", + "dgrayclay": "gray_terracotta", + "dgraysclay": "gray_terracotta", + "dgraystainedclay": "gray_terracotta", + "dgrayterra": "gray_terracotta", + "dgraytcota": "gray_terracotta", + "dgrayterracota": "gray_terracotta", + "dgrayterracotta": "gray_terracotta", + "darkgreyclay": "gray_terracotta", + "darkgreysclay": "gray_terracotta", + "darkgreystainedclay": "gray_terracotta", + "darkgreyterra": "gray_terracotta", + "darkgreytcota": "gray_terracotta", + "darkgreyterracota": "gray_terracotta", + "darkgreyterracotta": "gray_terracotta", + "darkgrayclay": "gray_terracotta", + "darkgraysclay": "gray_terracotta", + "darkgraystainedclay": "gray_terracotta", + "darkgrayterra": "gray_terracotta", + "darkgraytcota": "gray_terracotta", + "darkgrayterracota": "gray_terracotta", + "darkgrayterracotta": "gray_terracotta", + "gray_wall_banner": { + "material": "GRAY_WALL_BANNER" + }, + "graywallbanner": "gray_wall_banner", + "grawallbanner": "gray_wall_banner", + "greywallbanner": "gray_wall_banner", + "dgrawallbanner": "gray_wall_banner", + "darkgrawallbanner": "gray_wall_banner", + "dgreywallbanner": "gray_wall_banner", + "dgraywallbanner": "gray_wall_banner", + "darkgreywallbanner": "gray_wall_banner", + "darkgraywallbanner": "gray_wall_banner", + "gray_wool": { + "material": "GRAY_WOOL" + }, + "graywool": "gray_wool", + "grawool": "gray_wool", + "gracloth": "gray_wool", + "gracotton": "gray_wool", + "greywool": "gray_wool", + "greycloth": "gray_wool", + "greycotton": "gray_wool", + "graycloth": "gray_wool", + "graycotton": "gray_wool", + "dgrawool": "gray_wool", + "dgracloth": "gray_wool", + "dgracotton": "gray_wool", + "darkgrawool": "gray_wool", + "darkgracloth": "gray_wool", + "darkgracotton": "gray_wool", + "dgreywool": "gray_wool", + "dgreycloth": "gray_wool", + "dgreycotton": "gray_wool", + "dgraywool": "gray_wool", + "dgraycloth": "gray_wool", + "dgraycotton": "gray_wool", + "darkgreywool": "gray_wool", + "darkgreycloth": "gray_wool", + "darkgreycotton": "gray_wool", + "darkgraywool": "gray_wool", + "darkgraycloth": "gray_wool", + "darkgraycotton": "gray_wool", + "green_banner": { + "material": "GREEN_BANNER" + }, + "greenbanner": "green_banner", + "grestandingbanner": "green_banner", + "grebanner": "green_banner", + "dgrestandingbanner": "green_banner", + "dgrebanner": "green_banner", + "darkgrestandingbanner": "green_banner", + "darkgrebanner": "green_banner", + "greenstandingbanner": "green_banner", + "dgreenstandingbanner": "green_banner", + "dgreenbanner": "green_banner", + "darkgreenstandingbanner": "green_banner", + "darkgreenbanner": "green_banner", + "green_bed": { + "material": "GREEN_BED" + }, + "greenbed": "green_bed", + "grebed": "green_bed", + "dgrebed": "green_bed", + "darkgrebed": "green_bed", + "dgreenbed": "green_bed", + "darkgreenbed": "green_bed", + "green_carpet": { + "material": "GREEN_CARPET" + }, + "greencarpet": "green_carpet", + "grecarpet": "green_carpet", + "grefloor": "green_carpet", + "dgrecarpet": "green_carpet", + "dgrefloor": "green_carpet", + "darkgrecarpet": "green_carpet", + "darkgrefloor": "green_carpet", + "greenfloor": "green_carpet", + "dgreencarpet": "green_carpet", + "dgreenfloor": "green_carpet", + "darkgreencarpet": "green_carpet", + "darkgreenfloor": "green_carpet", + "green_concrete": { + "material": "GREEN_CONCRETE" + }, + "greenconcrete": "green_concrete", + "greconcrete": "green_concrete", + "dgreconcrete": "green_concrete", + "darkgreconcrete": "green_concrete", + "dgreenconcrete": "green_concrete", + "darkgreenconcrete": "green_concrete", + "green_concrete_powder": { + "material": "GREEN_CONCRETE_POWDER" + }, + "greenconcretepowder": "green_concrete_powder", + "greconcretepowder": "green_concrete_powder", + "greconcretesand": "green_concrete_powder", + "dgreconcretepowder": "green_concrete_powder", + "dgreconcretesand": "green_concrete_powder", + "darkgreconcretepowder": "green_concrete_powder", + "darkgreconcretesand": "green_concrete_powder", + "greenconcretesand": "green_concrete_powder", + "dgreenconcretepowder": "green_concrete_powder", + "dgreenconcretesand": "green_concrete_powder", + "darkgreenconcretepowder": "green_concrete_powder", + "darkgreenconcretesand": "green_concrete_powder", + "green_glazed_terracotta": { + "material": "GREEN_GLAZED_TERRACOTTA" + }, + "greenglazedterracotta": "green_glazed_terracotta", + "greglazedtcota": "green_glazed_terracotta", + "greglazedterra": "green_glazed_terracotta", + "greglazedterracotta": "green_glazed_terracotta", + "greglazedterracota": "green_glazed_terracotta", + "dgreglazedtcota": "green_glazed_terracotta", + "dgreglazedterra": "green_glazed_terracotta", + "dgreglazedterracotta": "green_glazed_terracotta", + "dgreglazedterracota": "green_glazed_terracotta", + "darkgreglazedtcota": "green_glazed_terracotta", + "darkgreglazedterra": "green_glazed_terracotta", + "darkgreglazedterracotta": "green_glazed_terracotta", + "darkgreglazedterracota": "green_glazed_terracotta", + "greenglazedtcota": "green_glazed_terracotta", + "greenglazedterra": "green_glazed_terracotta", + "greenglazedterracota": "green_glazed_terracotta", + "dgreenglazedtcota": "green_glazed_terracotta", + "dgreenglazedterra": "green_glazed_terracotta", + "dgreenglazedterracotta": "green_glazed_terracotta", + "dgreenglazedterracota": "green_glazed_terracotta", + "darkgreenglazedtcota": "green_glazed_terracotta", + "darkgreenglazedterra": "green_glazed_terracotta", + "darkgreenglazedterracotta": "green_glazed_terracotta", + "darkgreenglazedterracota": "green_glazed_terracotta", + "green_shulker_box": { + "material": "GREEN_SHULKER_BOX" + }, + "greenshulkerbox": "green_shulker_box", + "greshulkerbox": "green_shulker_box", + "grechest": "green_shulker_box", + "dgreshulkerbox": "green_shulker_box", + "dgrechest": "green_shulker_box", + "darkgreshulkerbox": "green_shulker_box", + "darkgrechest": "green_shulker_box", + "greenchest": "green_shulker_box", + "dgreenshulkerbox": "green_shulker_box", + "dgreenchest": "green_shulker_box", + "darkgreenshulkerbox": "green_shulker_box", + "darkgreenchest": "green_shulker_box", + "green_stained_glass": { + "material": "GREEN_STAINED_GLASS" + }, + "greenstainedglass": "green_stained_glass", + "greglass": "green_stained_glass", + "gresglass": "green_stained_glass", + "grestainedglass": "green_stained_glass", + "dgreglass": "green_stained_glass", + "dgresglass": "green_stained_glass", + "dgrestainedglass": "green_stained_glass", + "darkgreglass": "green_stained_glass", + "darkgresglass": "green_stained_glass", + "darkgrestainedglass": "green_stained_glass", + "greenglass": "green_stained_glass", + "greensglass": "green_stained_glass", + "dgreenglass": "green_stained_glass", + "dgreensglass": "green_stained_glass", + "dgreenstainedglass": "green_stained_glass", + "darkgreenglass": "green_stained_glass", + "darkgreensglass": "green_stained_glass", + "darkgreenstainedglass": "green_stained_glass", + "green_stained_glass_pane": { + "material": "GREEN_STAINED_GLASS_PANE" + }, + "greenstainedglasspane": "green_stained_glass_pane", + "greglasspane": "green_stained_glass_pane", + "gresglasspane": "green_stained_glass_pane", + "grestainedglasspane": "green_stained_glass_pane", + "dgreglasspane": "green_stained_glass_pane", + "dgresglasspane": "green_stained_glass_pane", + "dgrestainedglasspane": "green_stained_glass_pane", + "darkgreglasspane": "green_stained_glass_pane", + "darkgresglasspane": "green_stained_glass_pane", + "darkgrestainedglasspane": "green_stained_glass_pane", + "greenglasspane": "green_stained_glass_pane", + "greensglasspane": "green_stained_glass_pane", + "dgreenglasspane": "green_stained_glass_pane", + "dgreensglasspane": "green_stained_glass_pane", + "dgreenstainedglasspane": "green_stained_glass_pane", + "darkgreenglasspane": "green_stained_glass_pane", + "darkgreensglasspane": "green_stained_glass_pane", + "darkgreenstainedglasspane": "green_stained_glass_pane", + "green_terracotta": { + "material": "GREEN_TERRACOTTA" + }, + "greenterracotta": "green_terracotta", + "greclay": "green_terracotta", + "gresclay": "green_terracotta", + "grestainedclay": "green_terracotta", + "greterra": "green_terracotta", + "gretcota": "green_terracotta", + "greterracota": "green_terracotta", + "greterracotta": "green_terracotta", + "dgreclay": "green_terracotta", + "dgresclay": "green_terracotta", + "dgrestainedclay": "green_terracotta", + "dgreterra": "green_terracotta", + "dgretcota": "green_terracotta", + "dgreterracota": "green_terracotta", + "dgreterracotta": "green_terracotta", + "darkgreclay": "green_terracotta", + "darkgresclay": "green_terracotta", + "darkgrestainedclay": "green_terracotta", + "darkgreterra": "green_terracotta", + "darkgretcota": "green_terracotta", + "darkgreterracota": "green_terracotta", + "darkgreterracotta": "green_terracotta", + "greenclay": "green_terracotta", + "greensclay": "green_terracotta", + "greenstainedclay": "green_terracotta", + "greenterra": "green_terracotta", + "greentcota": "green_terracotta", + "greenterracota": "green_terracotta", + "dgreenclay": "green_terracotta", + "dgreensclay": "green_terracotta", + "dgreenstainedclay": "green_terracotta", + "dgreenterra": "green_terracotta", + "dgreentcota": "green_terracotta", + "dgreenterracota": "green_terracotta", + "dgreenterracotta": "green_terracotta", + "darkgreenclay": "green_terracotta", + "darkgreensclay": "green_terracotta", + "darkgreenstainedclay": "green_terracotta", + "darkgreenterra": "green_terracotta", + "darkgreentcota": "green_terracotta", + "darkgreenterracota": "green_terracotta", + "darkgreenterracotta": "green_terracotta", + "green_wall_banner": { + "material": "GREEN_WALL_BANNER" + }, + "greenwallbanner": "green_wall_banner", + "grewallbanner": "green_wall_banner", + "dgrewallbanner": "green_wall_banner", + "darkgrewallbanner": "green_wall_banner", + "dgreenwallbanner": "green_wall_banner", + "darkgreenwallbanner": "green_wall_banner", + "green_wool": { + "material": "GREEN_WOOL" + }, + "greenwool": "green_wool", + "grewool": "green_wool", + "grecloth": "green_wool", + "grecotton": "green_wool", + "dgrewool": "green_wool", + "dgrecloth": "green_wool", + "dgrecotton": "green_wool", + "darkgrewool": "green_wool", + "darkgrecloth": "green_wool", + "darkgrecotton": "green_wool", + "greencloth": "green_wool", + "greencotton": "green_wool", + "dgreenwool": "green_wool", + "dgreencloth": "green_wool", + "dgreencotton": "green_wool", + "darkgreenwool": "green_wool", + "darkgreencloth": "green_wool", + "darkgreencotton": "green_wool", + "guardian_spawn_egg": { + "material": "GUARDIAN_SPAWN_EGG" + }, + "guardianspawnegg": "guardian_spawn_egg", + "gunpowder": { + "material": "GUNPOWDER" + }, + "hay_block": { + "material": "HAY_BLOCK" + }, + "hayblock": "hay_block", + "heart_of_the_sea": { + "material": "HEART_OF_THE_SEA" + }, + "heartofthesea": "heart_of_the_sea", + "heavy_weighted_pressure_plate": { + "material": "HEAVY_WEIGHTED_PRESSURE_PLATE" + }, + "heavyweightedpressureplate": "heavy_weighted_pressure_plate", + "hopper": { + "material": "HOPPER" + }, + "hopper_minecart": { + "material": "HOPPER_MINECART" + }, + "hopperminecart": "hopper_minecart", + "horn_coral": { + "material": "HORN_CORAL" + }, + "horncoral": "horn_coral", + "horn_coral_block": { + "material": "HORN_CORAL_BLOCK" + }, + "horncoralblock": "horn_coral_block", + "horn_coral_fan": { + "material": "HORN_CORAL_FAN" + }, + "horncoralfan": "horn_coral_fan", + "horn_coral_wall_fan": { + "material": "HORN_CORAL_WALL_FAN" + }, + "horncoralwallfan": "horn_coral_wall_fan", + "horse_spawn_egg": { + "material": "HORSE_SPAWN_EGG" + }, + "horsespawnegg": "horse_spawn_egg", + "husk_spawn_egg": { + "material": "HUSK_SPAWN_EGG" + }, + "huskspawnegg": "husk_spawn_egg", + "ice": { + "material": "ICE" + }, + "infested_chiseled_stone_bricks": { + "material": "INFESTED_CHISELED_STONE_BRICKS" + }, + "infestedchiseledstonebricks": "infested_chiseled_stone_bricks", + "infested_cobblestone": { + "material": "INFESTED_COBBLESTONE" + }, + "infestedcobblestone": "infested_cobblestone", + "infested_cracked_stone_bricks": { + "material": "INFESTED_CRACKED_STONE_BRICKS" + }, + "infestedcrackedstonebricks": "infested_cracked_stone_bricks", + "infested_mossy_stone_bricks": { + "material": "INFESTED_MOSSY_STONE_BRICKS" + }, + "infestedmossystonebricks": "infested_mossy_stone_bricks", + "infested_stone": { + "material": "INFESTED_STONE" + }, + "infestedstone": "infested_stone", + "infested_stone_bricks": { + "material": "INFESTED_STONE_BRICKS" + }, + "infestedstonebricks": "infested_stone_bricks", + "ink_sac": { + "material": "INK_SAC" + }, + "inksac": "ink_sac", + "iron_axe": { + "material": "IRON_AXE" + }, + "ironaxe": "iron_axe", + "iaxe": "iron_axe", + "steelaxe": "iron_axe", + "saxe": "stone_axe", + "iron_bars": { + "material": "IRON_BARS" + }, + "ironbars": "iron_bars", + "iron_block": { + "material": "IRON_BLOCK" + }, + "ironblock": "iron_block", + "blockiron": "iron_block", + "iblock": "iron_block", + "blocki": "iron_block", + "steelblock": "iron_block", + "blocksteel": "iron_block", + "sblock": "iron_block", + "blocks": "iron_block", + "iron_boots": { + "material": "IRON_BOOTS" + }, + "ironboots": "iron_boots", + "ironshoes": "iron_boots", + "iboots": "iron_boots", + "ishoes": "iron_boots", + "steelboots": "iron_boots", + "steelshoes": "iron_boots", + "sboots": "iron_boots", + "sshoes": "iron_boots", + "iron_chestplate": { + "material": "IRON_CHESTPLATE" + }, + "ironchestplate": "iron_chestplate", + "ironplatebody": "iron_chestplate", + "ironplate": "iron_chestplate", + "ironshirt": "iron_chestplate", + "irontunic": "iron_chestplate", + "ichestplate": "iron_chestplate", + "iplatebody": "iron_chestplate", + "iplate": "iron_chestplate", + "ishirt": "iron_chestplate", + "itunic": "iron_chestplate", + "steelchestplate": "iron_chestplate", + "steelplatebody": "iron_chestplate", + "steelplate": "iron_chestplate", + "steelshirt": "iron_chestplate", + "steeltunic": "iron_chestplate", + "schestplate": "iron_chestplate", + "splatebody": "iron_chestplate", + "splate": "stone_pressure_plate", + "sshirt": "iron_chestplate", + "stunic": "iron_chestplate", + "iron_door": { + "material": "IRON_DOOR" + }, + "irondoor": "iron_door", + "iron_helmet": { + "material": "IRON_HELMET" + }, + "ironhelmet": "iron_helmet", + "ironhelm": "iron_helmet", + "ironhat": "iron_helmet", + "ironcoif": "iron_helmet", + "ihelmet": "iron_helmet", + "ihelm": "iron_helmet", + "ihat": "iron_helmet", + "icoif": "iron_helmet", + "steelhelmet": "iron_helmet", + "steelhelm": "iron_helmet", + "steelhat": "iron_helmet", + "steelcoif": "iron_helmet", + "shelmet": "iron_helmet", + "shelm": "iron_helmet", + "shat": "iron_helmet", + "scoif": "iron_helmet", + "iron_hoe": { + "material": "IRON_HOE" + }, + "ironhoe": "iron_hoe", + "ihoe": "iron_hoe", + "steelhoe": "iron_hoe", + "shoe": "stone_hoe", + "iron_horse_armor": { + "material": "IRON_HORSE_ARMOR" + }, + "ironhorsearmor": "iron_horse_armor", + "iron_ingot": { + "material": "IRON_INGOT" + }, + "ironingot": "iron_ingot", + "ironbar": "iron_ingot", + "ironi": "iron_ingot", + "ingotiron": "iron_ingot", + "bariron": "iron_ingot", + "iiron": "iron_ingot", + "iingot": "iron_ingot", + "ibar": "iron_ingot", + "ingoti": "iron_ingot", + "bari": "iron_ingot", + "steelingot": "iron_ingot", + "steelbar": "iron_ingot", + "steeli": "iron_ingot", + "ingotsteel": "iron_ingot", + "barsteel": "iron_ingot", + "isteel": "iron_ingot", + "singot": "iron_ingot", + "sbar": "iron_ingot", + "iron_leggings": { + "material": "IRON_LEGGINGS" + }, + "ironleggings": "iron_leggings", + "ironlegs": "iron_leggings", + "ironpants": "iron_leggings", + "ileggings": "iron_leggings", + "ilegs": "iron_leggings", + "ipants": "iron_leggings", + "steelleggings": "iron_leggings", + "steellegs": "iron_leggings", + "steelpants": "iron_leggings", + "sleggings": "iron_leggings", + "slegs": "iron_leggings", + "spants": "iron_leggings", + "iron_nugget": { + "material": "IRON_NUGGET" + }, + "ironnugget": "iron_nugget", + "iron_ore": { + "material": "IRON_ORE" + }, + "ironore": "iron_ore", + "irono": "iron_ore", + "oreiron": "iron_ore", + "oiron": "iron_ore", + "iore": "iron_ore", + "orei": "iron_ore", + "steelore": "iron_ore", + "steelo": "iron_ore", + "oresteel": "iron_ore", + "osteel": "iron_ore", + "sore": "iron_ore", + "ores": "iron_ore", + "iron_pickaxe": { + "material": "IRON_PICKAXE" + }, + "ironpickaxe": "iron_pickaxe", + "ironpick": "iron_pickaxe", + "ipickaxe": "iron_pickaxe", + "ipick": "iron_pickaxe", + "steelpickaxe": "iron_pickaxe", + "steelpick": "iron_pickaxe", + "spickaxe": "stone_pickaxe", + "spick": "stone_pickaxe", + "iron_shovel": { + "material": "IRON_SHOVEL" + }, + "ironshovel": "iron_shovel", + "ironspade": "iron_shovel", + "ishovel": "iron_shovel", + "ispade": "iron_shovel", + "steelshovel": "iron_shovel", + "steelspade": "iron_shovel", + "sshovel": "stone_shovel", + "sspade": "stone_shovel", + "iron_sword": { + "material": "IRON_SWORD" + }, + "ironsword": "iron_sword", + "isword": "iron_sword", + "steelsword": "iron_sword", + "ssword": "stone_sword", + "iron_trapdoor": { + "material": "IRON_TRAPDOOR" + }, + "irontrapdoor": "iron_trapdoor", + "item_frame": { + "material": "ITEM_FRAME" + }, + "itemframe": "item_frame", + "jack_o_lantern": { + "material": "JACK_O_LANTERN" + }, + "jackolantern": "jack_o_lantern", + "jukebox": { + "material": "JUKEBOX" + }, + "jbox": "jukebox", + "jungle_boat": { + "material": "JUNGLE_BOAT" + }, + "jungleboat": "jungle_boat", + "jboat": "jungle_boat", + "forestboat": "jungle_boat", + "fboat": "jungle_boat", + "jungle_button": { + "material": "JUNGLE_BUTTON" + }, + "junglebutton": "jungle_button", + "jungle_door": { + "material": "JUNGLE_DOOR" + }, + "jungledoor": "jungle_door", + "jungle_fence": { + "material": "JUNGLE_FENCE" + }, + "junglefence": "jungle_fence", + "jfence": "jungle_fence", + "forestfence": "jungle_fence", + "ffence": "jungle_fence", + "jungle_fence_gate": { + "material": "JUNGLE_FENCE_GATE" + }, + "junglefencegate": "jungle_fence_gate", + "junglegate": "jungle_fence_gate", + "jfencegate": "jungle_fence_gate", + "jgate": "jungle_fence_gate", + "forestfencegate": "jungle_fence_gate", + "forestgate": "jungle_fence_gate", + "ffencegate": "jungle_fence_gate", + "fgate": "jungle_fence_gate", + "jungle_leaves": { + "material": "JUNGLE_LEAVES" + }, + "jungleleaves": "jungle_leaves", + "jungletreeleaves": "jungle_leaves", + "junglelogleaves": "jungle_leaves", + "jungletrunkleaves": "jungle_leaves", + "junglewoodleaves": "jungle_leaves", + "jungletreeleaf": "jungle_leaves", + "junglelogleaf": "jungle_leaves", + "jungletrunkleaf": "jungle_leaves", + "junglewoodleaf": "jungle_leaves", + "jungleleaf": "jungle_leaves", + "jungletreeleave": "jungle_leaves", + "junglelogleave": "jungle_leaves", + "jungletrunkleave": "jungle_leaves", + "junglewoodleave": "jungle_leaves", + "jungleleave": "jungle_leaves", + "jtreeleaves": "jungle_leaves", + "jlogleaves": "jungle_leaves", + "jtrunkleaves": "jungle_leaves", + "jwoodleaves": "jungle_leaves", + "jleaves": "jungle_leaves", + "jtreeleaf": "jungle_leaves", + "jlogleaf": "jungle_leaves", + "jtrunkleaf": "jungle_leaves", + "jwoodleaf": "jungle_leaves", + "jleaf": "jungle_leaves", + "jtreeleave": "jungle_leaves", + "jlogleave": "jungle_leaves", + "jtrunkleave": "jungle_leaves", + "jwoodleave": "jungle_leaves", + "jleave": "jungle_leaves", + "foresttreeleaves": "jungle_leaves", + "forestlogleaves": "jungle_leaves", + "foresttrunkleaves": "jungle_leaves", + "forestwoodleaves": "jungle_leaves", + "forestleaves": "jungle_leaves", + "foresttreeleaf": "jungle_leaves", + "forestlogleaf": "jungle_leaves", + "foresttrunkleaf": "jungle_leaves", + "forestwoodleaf": "jungle_leaves", + "forestleaf": "jungle_leaves", + "foresttreeleave": "jungle_leaves", + "forestlogleave": "jungle_leaves", + "foresttrunkleave": "jungle_leaves", + "forestwoodleave": "jungle_leaves", + "forestleave": "jungle_leaves", + "ftreeleaves": "jungle_leaves", + "flogleaves": "jungle_leaves", + "ftrunkleaves": "jungle_leaves", + "fwoodleaves": "jungle_leaves", + "fleaves": "jungle_leaves", + "ftreeleaf": "jungle_leaves", + "flogleaf": "jungle_leaves", + "ftrunkleaf": "jungle_leaves", + "fwoodleaf": "jungle_leaves", + "fleaf": "jungle_leaves", + "ftreeleave": "jungle_leaves", + "flogleave": "jungle_leaves", + "ftrunkleave": "jungle_leaves", + "fwoodleave": "jungle_leaves", + "fleave": "jungle_leaves", + "jungle_log": { + "material": "JUNGLE_LOG" + }, + "junglelog": "stripped_jungle_log", + "jungle": "stripped_jungle_log", + "logjungle": "stripped_jungle_log", + "jungletrunk": "stripped_jungle_log", + "jungletree": "stripped_jungle_log", + "j": "stripped_jungle_log", + "logj": "stripped_jungle_log", + "jtrunk": "stripped_jungle_log", + "jlog": "stripped_jungle_log", + "jtree": "stripped_jungle_log", + "forest": "stripped_jungle_log", + "logforest": "stripped_jungle_log", + "foresttrunk": "stripped_jungle_log", + "forestlog": "stripped_jungle_log", + "foresttree": "stripped_jungle_log", + "f": "stripped_jungle_log", + "logf": "stripped_jungle_log", + "ftrunk": "stripped_jungle_log", + "flog": "stripped_jungle_log", + "ftree": "stripped_jungle_log", + "jungle_planks": { + "material": "JUNGLE_PLANKS" + }, + "jungleplanks": "jungle_planks", + "junglewoodenplank": "jungle_planks", + "junglewoodplank": "jungle_planks", + "junglewplank": "jungle_planks", + "jungleplankwooden": "jungle_planks", + "jungleplankwood": "jungle_planks", + "jungleplankw": "jungle_planks", + "jungleplank": "jungle_planks", + "jwoodenplank": "jungle_planks", + "jwoodplank": "jungle_planks", + "jwplank": "jungle_planks", + "jplankwooden": "jungle_planks", + "jplankwood": "jungle_planks", + "jplankw": "jungle_planks", + "jplank": "jungle_planks", + "forestwoodenplank": "jungle_planks", + "forestwoodplank": "jungle_planks", + "forestwplank": "jungle_planks", + "forestplankwooden": "jungle_planks", + "forestplankwood": "jungle_planks", + "forestplankw": "jungle_planks", + "forestplank": "jungle_planks", + "fwoodenplank": "jungle_planks", + "fwoodplank": "jungle_planks", + "fwplank": "jungle_planks", + "fplankwooden": "jungle_planks", + "fplankwood": "jungle_planks", + "fplankw": "jungle_planks", + "fplank": "jungle_planks", + "jungle_pressure_plate": { + "material": "JUNGLE_PRESSURE_PLATE" + }, + "junglepressureplate": "jungle_pressure_plate", + "jungle_sapling": { + "material": "JUNGLE_SAPLING" + }, + "junglesapling": "potted_jungle_sapling", + "jungletreesapling": "potted_jungle_sapling", + "junglelogsapling": "potted_jungle_sapling", + "jungletrunksapling": "potted_jungle_sapling", + "junglewoodsapling": "potted_jungle_sapling", + "jsapling": "potted_jungle_sapling", + "jtreesapling": "potted_jungle_sapling", + "jlogsapling": "potted_jungle_sapling", + "jtrunksapling": "potted_jungle_sapling", + "jwoodsapling": "potted_jungle_sapling", + "forestsapling": "potted_jungle_sapling", + "foresttreesapling": "potted_jungle_sapling", + "forestlogsapling": "potted_jungle_sapling", + "foresttrunksapling": "potted_jungle_sapling", + "forestwoodsapling": "potted_jungle_sapling", + "fsapling": "potted_jungle_sapling", + "ftreesapling": "potted_jungle_sapling", + "flogsapling": "potted_jungle_sapling", + "ftrunksapling": "potted_jungle_sapling", + "fwoodsapling": "potted_jungle_sapling", + "jungle_slab": { + "material": "JUNGLE_SLAB" + }, + "jungleslab": "jungle_slab", + "junglewoodenstep": "jungle_slab", + "junglewoodstep": "jungle_slab", + "junglewstep": "jungle_slab", + "junglestep": "jungle_slab", + "junglewoodenslab": "jungle_slab", + "junglewoodslab": "jungle_slab", + "junglewslab": "jungle_slab", + "junglewoodenhalfblock": "jungle_slab", + "junglewoodhalfblock": "jungle_slab", + "junglewhalfblock": "jungle_slab", + "junglehalfblock": "jungle_slab", + "jwoodenstep": "jungle_slab", + "jwoodstep": "jungle_slab", + "jwstep": "jungle_slab", + "jstep": "jungle_slab", + "jwoodenslab": "jungle_slab", + "jwoodslab": "jungle_slab", + "jwslab": "jungle_slab", + "jwoodenhalfblock": "jungle_slab", + "jwoodhalfblock": "jungle_slab", + "jwhalfblock": "jungle_slab", + "jhalfblock": "jungle_slab", + "forestwoodenstep": "jungle_slab", + "forestwoodstep": "jungle_slab", + "forestwstep": "jungle_slab", + "foreststep": "jungle_slab", + "forestwoodenslab": "jungle_slab", + "forestwoodslab": "jungle_slab", + "forestwslab": "jungle_slab", + "forestwoodenhalfblock": "jungle_slab", + "forestwoodhalfblock": "jungle_slab", + "forestwhalfblock": "jungle_slab", + "foresthalfblock": "jungle_slab", + "fwoodenstep": "jungle_slab", + "fwoodstep": "jungle_slab", + "fwstep": "jungle_slab", + "fstep": "jungle_slab", + "fwoodenslab": "jungle_slab", + "fwoodslab": "jungle_slab", + "fwslab": "jungle_slab", + "fwoodenhalfblock": "jungle_slab", + "fwoodhalfblock": "jungle_slab", + "fwhalfblock": "jungle_slab", + "fhalfblock": "jungle_slab", + "jungle_stairs": { + "material": "JUNGLE_STAIRS" + }, + "junglestairs": "jungle_stairs", + "junglewoodenstairs": "jungle_stairs", + "junglewoodstairs": "jungle_stairs", + "junglewstairs": "jungle_stairs", + "junglewoodenstair": "jungle_stairs", + "junglewoodstair": "jungle_stairs", + "junglewstair": "jungle_stairs", + "junglestair": "jungle_stairs", + "jwoodenstairs": "jungle_stairs", + "jwoodstairs": "jungle_stairs", + "jwstairs": "jungle_stairs", + "jwoodenstair": "jungle_stairs", + "jwoodstair": "jungle_stairs", + "jwstair": "jungle_stairs", + "jstair": "jungle_stairs", + "forestwoodenstairs": "jungle_stairs", + "forestwoodstairs": "jungle_stairs", + "forestwstairs": "jungle_stairs", + "forestwoodenstair": "jungle_stairs", + "forestwoodstair": "jungle_stairs", + "forestwstair": "jungle_stairs", + "foreststair": "jungle_stairs", + "fwoodenstairs": "jungle_stairs", + "fwoodstairs": "jungle_stairs", + "fwstairs": "jungle_stairs", + "fwoodenstair": "jungle_stairs", + "fwoodstair": "jungle_stairs", + "fwstair": "jungle_stairs", + "fstair": "jungle_stairs", + "jungle_trapdoor": { + "material": "JUNGLE_TRAPDOOR" + }, + "jungletrapdoor": "jungle_trapdoor", + "jungle_wood": { + "material": "JUNGLE_WOOD" + }, + "junglewood": "stripped_jungle_wood", + "junglelogall": "stripped_jungle_wood", + "jungletrunkall": "stripped_jungle_wood", + "jungletreeall": "stripped_jungle_wood", + "jwood": "stripped_jungle_wood", + "jlogall": "stripped_jungle_wood", + "jtrunkall": "stripped_jungle_wood", + "jtreeall": "stripped_jungle_wood", + "forestwood": "stripped_jungle_wood", + "forestlogall": "stripped_jungle_wood", + "foresttrunkall": "stripped_jungle_wood", + "foresttreeall": "stripped_jungle_wood", + "fwood": "stripped_jungle_wood", + "flogall": "stripped_jungle_wood", + "ftrunkall": "stripped_jungle_wood", + "ftreeall": "stripped_jungle_wood", + "kelp": { + "material": "KELP" + }, + "kelp_plant": { + "material": "KELP_PLANT" + }, + "kelpplant": "kelp_plant", + "knowledge_book": { + "material": "KNOWLEDGE_BOOK" + }, + "knowledgebook": "knowledge_book", + "ladder": { + "material": "LADDER" + }, + "lapis_block": { + "material": "LAPIS_BLOCK" + }, + "lapisblock": "lapis_block", + "lapislazuliblock": "lapis_block", + "blocklapislazuli": "lapis_block", + "blocklapis": "lapis_block", + "lblock": "lapis_block", + "blockl": "lapis_block", + "lapis_lazuli": { + "material": "LAPIS_LAZULI" + }, + "lapislazuli": "lapis_lazuli", + "lapis_ore": { + "material": "LAPIS_ORE" + }, + "lapisore": "lapis_ore", + "lapislazuliore": "lapis_ore", + "lapislazulio": "lapis_ore", + "orelapislazuli": "lapis_ore", + "olapislazuli": "lapis_ore", + "lapiso": "lapis_ore", + "orelapis": "lapis_ore", + "olapis": "lapis_ore", + "lore": "lapis_ore", + "lo": "lapis_ore", + "orel": "lapis_ore", + "ol": "lapis_ore", + "large_fern": { + "material": "LARGE_FERN" + }, + "largefern": "large_fern", + "lava": { + "material": "LAVA" + }, + "stationarylava": "lava", + "stilllava": "lava", + "slava": "lava", + "lava_bucket": { + "material": "LAVA_BUCKET" + }, + "lavabucket": "lava_bucket", + "lead": { + "material": "LEAD" + }, + "leather": { + "material": "LEATHER" + }, + "leather_boots": { + "material": "LEATHER_BOOTS" + }, + "leatherboots": "leather_boots", + "leathershoes": "leather_boots", + "lboots": "leather_boots", + "lshoes": "leather_boots", + "leather_chestplate": { + "material": "LEATHER_CHESTPLATE" + }, + "leatherchestplate": "leather_chestplate", + "leatherplatebody": "leather_chestplate", + "leatherplate": "leather_chestplate", + "leathershirt": "leather_chestplate", + "leathertunic": "leather_chestplate", + "lchestplate": "leather_chestplate", + "lplatebody": "leather_chestplate", + "lplate": "leather_chestplate", + "lshirt": "leather_chestplate", + "ltunic": "leather_chestplate", + "leather_helmet": { + "material": "LEATHER_HELMET" + }, + "leatherhelmet": "leather_helmet", + "leatherhelm": "leather_helmet", + "leatherhat": "leather_helmet", + "leathercoif": "leather_helmet", + "lhelmet": "leather_helmet", + "lhelm": "leather_helmet", + "lhat": "leather_helmet", + "lcoif": "leather_helmet", + "leather_leggings": { + "material": "LEATHER_LEGGINGS" + }, + "leatherleggings": "leather_leggings", + "leatherlegs": "leather_leggings", + "leatherpants": "leather_leggings", + "lleggings": "leather_leggings", + "llegs": "leather_leggings", + "lpants": "leather_leggings", + "lever": { + "material": "LEVER" + }, + "light_blue_banner": { + "material": "LIGHT_BLUE_BANNER" + }, + "lightbluebanner": "light_blue_banner", + "lbstandingbanner": "light_blue_banner", + "lbbanner": "light_blue_banner", + "lblustandingbanner": "light_blue_banner", + "lblubanner": "light_blue_banner", + "lightblustandingbanner": "light_blue_banner", + "lightblubanner": "light_blue_banner", + "lbluestandingbanner": "light_blue_banner", + "lbluebanner": "light_blue_banner", + "lightbluestandingbanner": "light_blue_banner", + "light_blue_bed": { + "material": "LIGHT_BLUE_BED" + }, + "lightbluebed": "light_blue_bed", + "lbbed": "light_blue_bed", + "lblubed": "light_blue_bed", + "lightblubed": "light_blue_bed", + "lbluebed": "light_blue_bed", + "light_blue_carpet": { + "material": "LIGHT_BLUE_CARPET" + }, + "lightbluecarpet": "light_blue_carpet", + "lbcarpet": "light_blue_carpet", + "lbfloor": "light_blue_carpet", + "lblucarpet": "light_blue_carpet", + "lblufloor": "light_blue_carpet", + "lightblucarpet": "light_blue_carpet", + "lightblufloor": "light_blue_carpet", + "lbluecarpet": "light_blue_carpet", + "lbluefloor": "light_blue_carpet", + "lightbluefloor": "light_blue_carpet", + "light_blue_concrete": { + "material": "LIGHT_BLUE_CONCRETE" + }, + "lightblueconcrete": "light_blue_concrete", + "lbconcrete": "light_blue_concrete", + "lbluconcrete": "light_blue_concrete", + "lightbluconcrete": "light_blue_concrete", + "lblueconcrete": "light_blue_concrete", + "light_blue_concrete_powder": { + "material": "LIGHT_BLUE_CONCRETE_POWDER" + }, + "lightblueconcretepowder": "light_blue_concrete_powder", + "lbconcretepowder": "light_blue_concrete_powder", + "lbconcretesand": "light_blue_concrete_powder", + "lbluconcretepowder": "light_blue_concrete_powder", + "lbluconcretesand": "light_blue_concrete_powder", + "lightbluconcretepowder": "light_blue_concrete_powder", + "lightbluconcretesand": "light_blue_concrete_powder", + "lblueconcretepowder": "light_blue_concrete_powder", + "lblueconcretesand": "light_blue_concrete_powder", + "lightblueconcretesand": "light_blue_concrete_powder", + "light_blue_dye": { + "material": "LIGHT_BLUE_DYE" + }, + "lightbluedye": "light_blue_dye", + "light_blue_glazed_terracotta": { + "material": "LIGHT_BLUE_GLAZED_TERRACOTTA" + }, + "lightblueglazedterracotta": "light_blue_glazed_terracotta", + "lbglazedtcota": "light_blue_glazed_terracotta", + "lbglazedterra": "light_blue_glazed_terracotta", + "lbglazedterracotta": "light_blue_glazed_terracotta", + "lbglazedterracota": "light_blue_glazed_terracotta", + "lbluglazedtcota": "light_blue_glazed_terracotta", + "lbluglazedterra": "light_blue_glazed_terracotta", + "lbluglazedterracotta": "light_blue_glazed_terracotta", + "lbluglazedterracota": "light_blue_glazed_terracotta", + "lightbluglazedtcota": "light_blue_glazed_terracotta", + "lightbluglazedterra": "light_blue_glazed_terracotta", + "lightbluglazedterracotta": "light_blue_glazed_terracotta", + "lightbluglazedterracota": "light_blue_glazed_terracotta", + "lblueglazedtcota": "light_blue_glazed_terracotta", + "lblueglazedterra": "light_blue_glazed_terracotta", + "lblueglazedterracotta": "light_blue_glazed_terracotta", + "lblueglazedterracota": "light_blue_glazed_terracotta", + "lightblueglazedtcota": "light_blue_glazed_terracotta", + "lightblueglazedterra": "light_blue_glazed_terracotta", + "lightblueglazedterracota": "light_blue_glazed_terracotta", + "light_blue_shulker_box": { + "material": "LIGHT_BLUE_SHULKER_BOX" + }, + "lightblueshulkerbox": "light_blue_shulker_box", + "lbshulkerbox": "light_blue_shulker_box", + "lbchest": "light_blue_shulker_box", + "lblushulkerbox": "light_blue_shulker_box", + "lbluchest": "light_blue_shulker_box", + "lightblushulkerbox": "light_blue_shulker_box", + "lightbluchest": "light_blue_shulker_box", + "lblueshulkerbox": "light_blue_shulker_box", + "lbluechest": "light_blue_shulker_box", + "lightbluechest": "light_blue_shulker_box", + "light_blue_stained_glass": { + "material": "LIGHT_BLUE_STAINED_GLASS" + }, + "lightbluestainedglass": "light_blue_stained_glass", + "lbglass": "light_blue_stained_glass", + "lbsglass": "light_blue_stained_glass", + "lbstainedglass": "light_blue_stained_glass", + "lbluglass": "light_blue_stained_glass", + "lblusglass": "light_blue_stained_glass", + "lblustainedglass": "light_blue_stained_glass", + "lightbluglass": "light_blue_stained_glass", + "lightblusglass": "light_blue_stained_glass", + "lightblustainedglass": "light_blue_stained_glass", + "lblueglass": "light_blue_stained_glass", + "lbluesglass": "light_blue_stained_glass", + "lbluestainedglass": "light_blue_stained_glass", + "lightblueglass": "light_blue_stained_glass", + "lightbluesglass": "light_blue_stained_glass", + "light_blue_stained_glass_pane": { + "material": "LIGHT_BLUE_STAINED_GLASS_PANE" + }, + "lightbluestainedglasspane": "light_blue_stained_glass_pane", + "lbglasspane": "light_blue_stained_glass_pane", + "lbsglasspane": "light_blue_stained_glass_pane", + "lbstainedglasspane": "light_blue_stained_glass_pane", + "lbluglasspane": "light_blue_stained_glass_pane", + "lblusglasspane": "light_blue_stained_glass_pane", + "lblustainedglasspane": "light_blue_stained_glass_pane", + "lightbluglasspane": "light_blue_stained_glass_pane", + "lightblusglasspane": "light_blue_stained_glass_pane", + "lightblustainedglasspane": "light_blue_stained_glass_pane", + "lblueglasspane": "light_blue_stained_glass_pane", + "lbluesglasspane": "light_blue_stained_glass_pane", + "lbluestainedglasspane": "light_blue_stained_glass_pane", + "lightblueglasspane": "light_blue_stained_glass_pane", + "lightbluesglasspane": "light_blue_stained_glass_pane", + "light_blue_terracotta": { + "material": "LIGHT_BLUE_TERRACOTTA" + }, + "lightblueterracotta": "light_blue_terracotta", + "lbclay": "light_blue_terracotta", + "lbsclay": "light_blue_terracotta", + "lbstainedclay": "light_blue_terracotta", + "lbterra": "light_blue_terracotta", + "lbtcota": "light_blue_terracotta", + "lbterracota": "light_blue_terracotta", + "lbterracotta": "light_blue_terracotta", + "lbluclay": "light_blue_terracotta", + "lblusclay": "light_blue_terracotta", + "lblustainedclay": "light_blue_terracotta", + "lbluterra": "light_blue_terracotta", + "lblutcota": "light_blue_terracotta", + "lbluterracota": "light_blue_terracotta", + "lbluterracotta": "light_blue_terracotta", + "lightbluclay": "light_blue_terracotta", + "lightblusclay": "light_blue_terracotta", + "lightblustainedclay": "light_blue_terracotta", + "lightbluterra": "light_blue_terracotta", + "lightblutcota": "light_blue_terracotta", + "lightbluterracota": "light_blue_terracotta", + "lightbluterracotta": "light_blue_terracotta", + "lblueclay": "light_blue_terracotta", + "lbluesclay": "light_blue_terracotta", + "lbluestainedclay": "light_blue_terracotta", + "lblueterra": "light_blue_terracotta", + "lbluetcota": "light_blue_terracotta", + "lblueterracota": "light_blue_terracotta", + "lblueterracotta": "light_blue_terracotta", + "lightblueclay": "light_blue_terracotta", + "lightbluesclay": "light_blue_terracotta", + "lightbluestainedclay": "light_blue_terracotta", + "lightblueterra": "light_blue_terracotta", + "lightbluetcota": "light_blue_terracotta", + "lightblueterracota": "light_blue_terracotta", + "light_blue_wall_banner": { + "material": "LIGHT_BLUE_WALL_BANNER" + }, + "lightbluewallbanner": "light_blue_wall_banner", + "lbwallbanner": "light_blue_wall_banner", + "lbluwallbanner": "light_blue_wall_banner", + "lightbluwallbanner": "light_blue_wall_banner", + "lbluewallbanner": "light_blue_wall_banner", + "light_blue_wool": { + "material": "LIGHT_BLUE_WOOL" + }, + "lightbluewool": "light_blue_wool", + "lbwool": "light_blue_wool", + "lbcloth": "light_blue_wool", + "lbcotton": "light_blue_wool", + "lbluwool": "light_blue_wool", + "lblucloth": "light_blue_wool", + "lblucotton": "light_blue_wool", + "lightbluwool": "light_blue_wool", + "lightblucloth": "light_blue_wool", + "lightblucotton": "light_blue_wool", + "lbluewool": "light_blue_wool", + "lbluecloth": "light_blue_wool", + "lbluecotton": "light_blue_wool", + "lightbluecloth": "light_blue_wool", + "lightbluecotton": "light_blue_wool", + "light_gray_banner": { + "material": "LIGHT_GRAY_BANNER" + }, + "lightgraybanner": "light_gray_banner", + "lgstandingbanner": "light_gray_banner", + "lgbanner": "light_gray_banner", + "lgrastandingbanner": "light_gray_banner", + "lgrabanner": "light_gray_banner", + "lgreystandingbanner": "light_gray_banner", + "lgreybanner": "light_gray_banner", + "lgraystandingbanner": "light_gray_banner", + "lgraybanner": "light_gray_banner", + "lightgrastandingbanner": "light_gray_banner", + "lightgrabanner": "light_gray_banner", + "lightgreystandingbanner": "light_gray_banner", + "lightgreybanner": "light_gray_banner", + "lightgraystandingbanner": "light_gray_banner", + "sistandingbanner": "light_gray_banner", + "sibanner": "light_gray_banner", + "siastandingbanner": "light_gray_banner", + "siabanner": "light_gray_banner", + "silverstandingbanner": "light_gray_banner", + "silverbanner": "light_gray_banner", + "light_gray_bed": { + "material": "LIGHT_GRAY_BED" + }, + "lightgraybed": "light_gray_bed", + "lgbed": "light_gray_bed", + "lgrabed": "light_gray_bed", + "lgreybed": "light_gray_bed", + "lgraybed": "light_gray_bed", + "lightgrabed": "light_gray_bed", + "lightgreybed": "light_gray_bed", + "sibed": "light_gray_bed", + "siabed": "light_gray_bed", + "silverbed": "light_gray_bed", + "light_gray_carpet": { + "material": "LIGHT_GRAY_CARPET" + }, + "lightgraycarpet": "light_gray_carpet", + "lgcarpet": "light_gray_carpet", + "lgfloor": "light_gray_carpet", + "lgracarpet": "light_gray_carpet", + "lgrafloor": "light_gray_carpet", + "lgreycarpet": "light_gray_carpet", + "lgreyfloor": "light_gray_carpet", + "lgraycarpet": "light_gray_carpet", + "lgrayfloor": "light_gray_carpet", + "lightgracarpet": "light_gray_carpet", + "lightgrafloor": "light_gray_carpet", + "lightgreycarpet": "light_gray_carpet", + "lightgreyfloor": "light_gray_carpet", + "lightgrayfloor": "light_gray_carpet", + "sicarpet": "light_gray_carpet", + "sifloor": "light_gray_carpet", + "siacarpet": "light_gray_carpet", + "siafloor": "light_gray_carpet", + "silvercarpet": "light_gray_carpet", + "silverfloor": "light_gray_carpet", + "light_gray_concrete": { + "material": "LIGHT_GRAY_CONCRETE" + }, + "lightgrayconcrete": "light_gray_concrete", + "lgconcrete": "light_gray_concrete", + "lgraconcrete": "light_gray_concrete", + "lgreyconcrete": "light_gray_concrete", + "lgrayconcrete": "light_gray_concrete", + "lightgraconcrete": "light_gray_concrete", + "lightgreyconcrete": "light_gray_concrete", + "siconcrete": "light_gray_concrete", + "siaconcrete": "light_gray_concrete", + "silverconcrete": "light_gray_concrete", + "light_gray_concrete_powder": { + "material": "LIGHT_GRAY_CONCRETE_POWDER" + }, + "lightgrayconcretepowder": "light_gray_concrete_powder", + "lgconcretepowder": "light_gray_concrete_powder", + "lgconcretesand": "light_gray_concrete_powder", + "lgraconcretepowder": "light_gray_concrete_powder", + "lgraconcretesand": "light_gray_concrete_powder", + "lgreyconcretepowder": "light_gray_concrete_powder", + "lgreyconcretesand": "light_gray_concrete_powder", + "lgrayconcretepowder": "light_gray_concrete_powder", + "lgrayconcretesand": "light_gray_concrete_powder", + "lightgraconcretepowder": "light_gray_concrete_powder", + "lightgraconcretesand": "light_gray_concrete_powder", + "lightgreyconcretepowder": "light_gray_concrete_powder", + "lightgreyconcretesand": "light_gray_concrete_powder", + "lightgrayconcretesand": "light_gray_concrete_powder", + "siconcretepowder": "light_gray_concrete_powder", + "siconcretesand": "light_gray_concrete_powder", + "siaconcretepowder": "light_gray_concrete_powder", + "siaconcretesand": "light_gray_concrete_powder", + "silverconcretepowder": "light_gray_concrete_powder", + "silverconcretesand": "light_gray_concrete_powder", + "light_gray_dye": { + "material": "LIGHT_GRAY_DYE" + }, + "lightgraydye": "light_gray_dye", + "light_gray_glazed_terracotta": { + "material": "LIGHT_GRAY_GLAZED_TERRACOTTA" + }, + "lightgrayglazedterracotta": "light_gray_glazed_terracotta", + "lgglazedtcota": "light_gray_glazed_terracotta", + "lgglazedterra": "light_gray_glazed_terracotta", + "lgglazedterracotta": "light_gray_glazed_terracotta", + "lgglazedterracota": "light_gray_glazed_terracotta", + "lgraglazedtcota": "light_gray_glazed_terracotta", + "lgraglazedterra": "light_gray_glazed_terracotta", + "lgraglazedterracotta": "light_gray_glazed_terracotta", + "lgraglazedterracota": "light_gray_glazed_terracotta", + "lgreyglazedtcota": "light_gray_glazed_terracotta", + "lgreyglazedterra": "light_gray_glazed_terracotta", + "lgreyglazedterracotta": "light_gray_glazed_terracotta", + "lgreyglazedterracota": "light_gray_glazed_terracotta", + "lgrayglazedtcota": "light_gray_glazed_terracotta", + "lgrayglazedterra": "light_gray_glazed_terracotta", + "lgrayglazedterracotta": "light_gray_glazed_terracotta", + "lgrayglazedterracota": "light_gray_glazed_terracotta", + "lightgraglazedtcota": "light_gray_glazed_terracotta", + "lightgraglazedterra": "light_gray_glazed_terracotta", + "lightgraglazedterracotta": "light_gray_glazed_terracotta", + "lightgraglazedterracota": "light_gray_glazed_terracotta", + "lightgreyglazedtcota": "light_gray_glazed_terracotta", + "lightgreyglazedterra": "light_gray_glazed_terracotta", + "lightgreyglazedterracotta": "light_gray_glazed_terracotta", + "lightgreyglazedterracota": "light_gray_glazed_terracotta", + "lightgrayglazedtcota": "light_gray_glazed_terracotta", + "lightgrayglazedterra": "light_gray_glazed_terracotta", + "lightgrayglazedterracota": "light_gray_glazed_terracotta", + "siglazedtcota": "light_gray_glazed_terracotta", + "siglazedterra": "light_gray_glazed_terracotta", + "siglazedterracotta": "light_gray_glazed_terracotta", + "siglazedterracota": "light_gray_glazed_terracotta", + "siaglazedtcota": "light_gray_glazed_terracotta", + "siaglazedterra": "light_gray_glazed_terracotta", + "siaglazedterracotta": "light_gray_glazed_terracotta", + "siaglazedterracota": "light_gray_glazed_terracotta", + "silverglazedtcota": "light_gray_glazed_terracotta", + "silverglazedterra": "light_gray_glazed_terracotta", + "silverglazedterracotta": "light_gray_glazed_terracotta", + "silverglazedterracota": "light_gray_glazed_terracotta", + "light_gray_shulker_box": { + "material": "LIGHT_GRAY_SHULKER_BOX" + }, + "lightgrayshulkerbox": "light_gray_shulker_box", + "lgshulkerbox": "light_gray_shulker_box", + "lgchest": "light_gray_shulker_box", + "lgrashulkerbox": "light_gray_shulker_box", + "lgrachest": "light_gray_shulker_box", + "lgreyshulkerbox": "light_gray_shulker_box", + "lgreychest": "light_gray_shulker_box", + "lgrayshulkerbox": "light_gray_shulker_box", + "lgraychest": "light_gray_shulker_box", + "lightgrashulkerbox": "light_gray_shulker_box", + "lightgrachest": "light_gray_shulker_box", + "lightgreyshulkerbox": "light_gray_shulker_box", + "lightgreychest": "light_gray_shulker_box", + "lightgraychest": "light_gray_shulker_box", + "sishulkerbox": "light_gray_shulker_box", + "sichest": "light_gray_shulker_box", + "siashulkerbox": "light_gray_shulker_box", + "siachest": "light_gray_shulker_box", + "silvershulkerbox": "light_gray_shulker_box", + "silverchest": "light_gray_shulker_box", + "light_gray_stained_glass": { + "material": "LIGHT_GRAY_STAINED_GLASS" + }, + "lightgraystainedglass": "light_gray_stained_glass", + "lgglass": "light_gray_stained_glass", + "lgsglass": "light_gray_stained_glass", + "lgstainedglass": "light_gray_stained_glass", + "lgraglass": "light_gray_stained_glass", + "lgrasglass": "light_gray_stained_glass", + "lgrastainedglass": "light_gray_stained_glass", + "lgreyglass": "light_gray_stained_glass", + "lgreysglass": "light_gray_stained_glass", + "lgreystainedglass": "light_gray_stained_glass", + "lgrayglass": "light_gray_stained_glass", + "lgraysglass": "light_gray_stained_glass", + "lgraystainedglass": "light_gray_stained_glass", + "lightgraglass": "light_gray_stained_glass", + "lightgrasglass": "light_gray_stained_glass", + "lightgrastainedglass": "light_gray_stained_glass", + "lightgreyglass": "light_gray_stained_glass", + "lightgreysglass": "light_gray_stained_glass", + "lightgreystainedglass": "light_gray_stained_glass", + "lightgrayglass": "light_gray_stained_glass", + "lightgraysglass": "light_gray_stained_glass", + "siglass": "light_gray_stained_glass", + "sisglass": "light_gray_stained_glass", + "sistainedglass": "light_gray_stained_glass", + "siaglass": "light_gray_stained_glass", + "siasglass": "light_gray_stained_glass", + "siastainedglass": "light_gray_stained_glass", + "silverglass": "light_gray_stained_glass", + "silversglass": "light_gray_stained_glass", + "silverstainedglass": "light_gray_stained_glass", + "light_gray_stained_glass_pane": { + "material": "LIGHT_GRAY_STAINED_GLASS_PANE" + }, + "lightgraystainedglasspane": "light_gray_stained_glass_pane", + "lgglasspane": "light_gray_stained_glass_pane", + "lgsglasspane": "light_gray_stained_glass_pane", + "lgstainedglasspane": "light_gray_stained_glass_pane", + "lgraglasspane": "light_gray_stained_glass_pane", + "lgrasglasspane": "light_gray_stained_glass_pane", + "lgrastainedglasspane": "light_gray_stained_glass_pane", + "lgreyglasspane": "light_gray_stained_glass_pane", + "lgreysglasspane": "light_gray_stained_glass_pane", + "lgreystainedglasspane": "light_gray_stained_glass_pane", + "lgrayglasspane": "light_gray_stained_glass_pane", + "lgraysglasspane": "light_gray_stained_glass_pane", + "lgraystainedglasspane": "light_gray_stained_glass_pane", + "lightgraglasspane": "light_gray_stained_glass_pane", + "lightgrasglasspane": "light_gray_stained_glass_pane", + "lightgrastainedglasspane": "light_gray_stained_glass_pane", + "lightgreyglasspane": "light_gray_stained_glass_pane", + "lightgreysglasspane": "light_gray_stained_glass_pane", + "lightgreystainedglasspane": "light_gray_stained_glass_pane", + "lightgrayglasspane": "light_gray_stained_glass_pane", + "lightgraysglasspane": "light_gray_stained_glass_pane", + "siglasspane": "light_gray_stained_glass_pane", + "sisglasspane": "light_gray_stained_glass_pane", + "sistainedglasspane": "light_gray_stained_glass_pane", + "siaglasspane": "light_gray_stained_glass_pane", + "siasglasspane": "light_gray_stained_glass_pane", + "siastainedglasspane": "light_gray_stained_glass_pane", + "silverglasspane": "light_gray_stained_glass_pane", + "silversglasspane": "light_gray_stained_glass_pane", + "silverstainedglasspane": "light_gray_stained_glass_pane", + "light_gray_terracotta": { + "material": "LIGHT_GRAY_TERRACOTTA" + }, + "lightgrayterracotta": "light_gray_terracotta", + "lgclay": "light_gray_terracotta", + "lgsclay": "light_gray_terracotta", + "lgstainedclay": "light_gray_terracotta", + "lgterra": "light_gray_terracotta", + "lgtcota": "light_gray_terracotta", + "lgterracota": "light_gray_terracotta", + "lgterracotta": "light_gray_terracotta", + "lgraclay": "light_gray_terracotta", + "lgrasclay": "light_gray_terracotta", + "lgrastainedclay": "light_gray_terracotta", + "lgraterra": "light_gray_terracotta", + "lgratcota": "light_gray_terracotta", + "lgraterracota": "light_gray_terracotta", + "lgraterracotta": "light_gray_terracotta", + "lgreyclay": "light_gray_terracotta", + "lgreysclay": "light_gray_terracotta", + "lgreystainedclay": "light_gray_terracotta", + "lgreyterra": "light_gray_terracotta", + "lgreytcota": "light_gray_terracotta", + "lgreyterracota": "light_gray_terracotta", + "lgreyterracotta": "light_gray_terracotta", + "lgrayclay": "light_gray_terracotta", + "lgraysclay": "light_gray_terracotta", + "lgraystainedclay": "light_gray_terracotta", + "lgrayterra": "light_gray_terracotta", + "lgraytcota": "light_gray_terracotta", + "lgrayterracota": "light_gray_terracotta", + "lgrayterracotta": "light_gray_terracotta", + "lightgraclay": "light_gray_terracotta", + "lightgrasclay": "light_gray_terracotta", + "lightgrastainedclay": "light_gray_terracotta", + "lightgraterra": "light_gray_terracotta", + "lightgratcota": "light_gray_terracotta", + "lightgraterracota": "light_gray_terracotta", + "lightgraterracotta": "light_gray_terracotta", + "lightgreyclay": "light_gray_terracotta", + "lightgreysclay": "light_gray_terracotta", + "lightgreystainedclay": "light_gray_terracotta", + "lightgreyterra": "light_gray_terracotta", + "lightgreytcota": "light_gray_terracotta", + "lightgreyterracota": "light_gray_terracotta", + "lightgreyterracotta": "light_gray_terracotta", + "lightgrayclay": "light_gray_terracotta", + "lightgraysclay": "light_gray_terracotta", + "lightgraystainedclay": "light_gray_terracotta", + "lightgrayterra": "light_gray_terracotta", + "lightgraytcota": "light_gray_terracotta", + "lightgrayterracota": "light_gray_terracotta", + "siclay": "light_gray_terracotta", + "sisclay": "light_gray_terracotta", + "sistainedclay": "light_gray_terracotta", + "siterra": "light_gray_terracotta", + "sitcota": "light_gray_terracotta", + "siterracota": "light_gray_terracotta", + "siterracotta": "light_gray_terracotta", + "siaclay": "light_gray_terracotta", + "siasclay": "light_gray_terracotta", + "siastainedclay": "light_gray_terracotta", + "siaterra": "light_gray_terracotta", + "siatcota": "light_gray_terracotta", + "siaterracota": "light_gray_terracotta", + "siaterracotta": "light_gray_terracotta", + "silverclay": "light_gray_terracotta", + "silversclay": "light_gray_terracotta", + "silverstainedclay": "light_gray_terracotta", + "silverterra": "light_gray_terracotta", + "silvertcota": "light_gray_terracotta", + "silverterracota": "light_gray_terracotta", + "silverterracotta": "light_gray_terracotta", + "light_gray_wall_banner": { + "material": "LIGHT_GRAY_WALL_BANNER" + }, + "lightgraywallbanner": "light_gray_wall_banner", + "lgwallbanner": "light_gray_wall_banner", + "lgrawallbanner": "light_gray_wall_banner", + "lgreywallbanner": "light_gray_wall_banner", + "lgraywallbanner": "light_gray_wall_banner", + "lightgrawallbanner": "light_gray_wall_banner", + "lightgreywallbanner": "light_gray_wall_banner", + "siwallbanner": "light_gray_wall_banner", + "siawallbanner": "light_gray_wall_banner", + "silverwallbanner": "light_gray_wall_banner", + "light_gray_wool": { + "material": "LIGHT_GRAY_WOOL" + }, + "lightgraywool": "light_gray_wool", + "lgwool": "light_gray_wool", + "lgcloth": "light_gray_wool", + "lgcotton": "light_gray_wool", + "lgrawool": "light_gray_wool", + "lgracloth": "light_gray_wool", + "lgracotton": "light_gray_wool", + "lgreywool": "light_gray_wool", + "lgreycloth": "light_gray_wool", + "lgreycotton": "light_gray_wool", + "lgraywool": "light_gray_wool", + "lgraycloth": "light_gray_wool", + "lgraycotton": "light_gray_wool", + "lightgrawool": "light_gray_wool", + "lightgracloth": "light_gray_wool", + "lightgracotton": "light_gray_wool", + "lightgreywool": "light_gray_wool", + "lightgreycloth": "light_gray_wool", + "lightgreycotton": "light_gray_wool", + "lightgraycloth": "light_gray_wool", + "lightgraycotton": "light_gray_wool", + "siwool": "light_gray_wool", + "sicloth": "light_gray_wool", + "sicotton": "light_gray_wool", + "siawool": "light_gray_wool", + "siacloth": "light_gray_wool", + "siacotton": "light_gray_wool", + "silverwool": "light_gray_wool", + "silvercloth": "light_gray_wool", + "silvercotton": "light_gray_wool", + "light_weighted_pressure_plate": { + "material": "LIGHT_WEIGHTED_PRESSURE_PLATE" + }, + "lightweightedpressureplate": "light_weighted_pressure_plate", + "lilac": { + "material": "LILAC" + }, + "lily_pad": { + "material": "LILY_PAD" + }, + "lilypad": "lily_pad", + "lime_banner": { + "material": "LIME_BANNER" + }, + "limebanner": "lime_banner", + "lstandingbanner": "lime_banner", + "lbanner": "lime_banner", + "limestandingbanner": "lime_banner", + "lgrestandingbanner": "lime_banner", + "lgrebanner": "lime_banner", + "lightgrestandingbanner": "lime_banner", + "lightgrebanner": "lime_banner", + "lgreenstandingbanner": "lime_banner", + "lgreenbanner": "lime_banner", + "lightgreenstandingbanner": "lime_banner", + "lightgreenbanner": "lime_banner", + "lime_bed": { + "material": "LIME_BED" + }, + "limebed": "lime_bed", + "lbed": "lime_bed", + "lgrebed": "lime_bed", + "lightgrebed": "lime_bed", + "lgreenbed": "lime_bed", + "lightgreenbed": "lime_bed", + "lime_carpet": { + "material": "LIME_CARPET" + }, + "limecarpet": "lime_carpet", + "lcarpet": "lime_carpet", + "lfloor": "lime_carpet", + "limefloor": "lime_carpet", + "lgrecarpet": "lime_carpet", + "lgrefloor": "lime_carpet", + "lightgrecarpet": "lime_carpet", + "lightgrefloor": "lime_carpet", + "lgreencarpet": "lime_carpet", + "lgreenfloor": "lime_carpet", + "lightgreencarpet": "lime_carpet", + "lightgreenfloor": "lime_carpet", + "lime_concrete": { + "material": "LIME_CONCRETE" + }, + "limeconcrete": "lime_concrete", + "lconcrete": "lime_concrete", + "lgreconcrete": "lime_concrete", + "lightgreconcrete": "lime_concrete", + "lgreenconcrete": "lime_concrete", + "lightgreenconcrete": "lime_concrete", + "lime_concrete_powder": { + "material": "LIME_CONCRETE_POWDER" + }, + "limeconcretepowder": "lime_concrete_powder", + "lconcretepowder": "lime_concrete_powder", + "lconcretesand": "lime_concrete_powder", + "limeconcretesand": "lime_concrete_powder", + "lgreconcretepowder": "lime_concrete_powder", + "lgreconcretesand": "lime_concrete_powder", + "lightgreconcretepowder": "lime_concrete_powder", + "lightgreconcretesand": "lime_concrete_powder", + "lgreenconcretepowder": "lime_concrete_powder", + "lgreenconcretesand": "lime_concrete_powder", + "lightgreenconcretepowder": "lime_concrete_powder", + "lightgreenconcretesand": "lime_concrete_powder", + "lime_dye": { + "material": "LIME_DYE" + }, + "limedye": "lime_dye", + "lime_glazed_terracotta": { + "material": "LIME_GLAZED_TERRACOTTA" + }, + "limeglazedterracotta": "lime_glazed_terracotta", + "lglazedtcota": "lime_glazed_terracotta", + "lglazedterra": "lime_glazed_terracotta", + "lglazedterracotta": "lime_glazed_terracotta", + "lglazedterracota": "lime_glazed_terracotta", + "limeglazedtcota": "lime_glazed_terracotta", + "limeglazedterra": "lime_glazed_terracotta", + "limeglazedterracota": "lime_glazed_terracotta", + "lgreglazedtcota": "lime_glazed_terracotta", + "lgreglazedterra": "lime_glazed_terracotta", + "lgreglazedterracotta": "lime_glazed_terracotta", + "lgreglazedterracota": "lime_glazed_terracotta", + "lightgreglazedtcota": "lime_glazed_terracotta", + "lightgreglazedterra": "lime_glazed_terracotta", + "lightgreglazedterracotta": "lime_glazed_terracotta", + "lightgreglazedterracota": "lime_glazed_terracotta", + "lgreenglazedtcota": "lime_glazed_terracotta", + "lgreenglazedterra": "lime_glazed_terracotta", + "lgreenglazedterracotta": "lime_glazed_terracotta", + "lgreenglazedterracota": "lime_glazed_terracotta", + "lightgreenglazedtcota": "lime_glazed_terracotta", + "lightgreenglazedterra": "lime_glazed_terracotta", + "lightgreenglazedterracotta": "lime_glazed_terracotta", + "lightgreenglazedterracota": "lime_glazed_terracotta", + "lime_shulker_box": { + "material": "LIME_SHULKER_BOX" + }, + "limeshulkerbox": "lime_shulker_box", + "lshulkerbox": "lime_shulker_box", + "lchest": "lime_shulker_box", + "limechest": "lime_shulker_box", + "lgreshulkerbox": "lime_shulker_box", + "lgrechest": "lime_shulker_box", + "lightgreshulkerbox": "lime_shulker_box", + "lightgrechest": "lime_shulker_box", + "lgreenshulkerbox": "lime_shulker_box", + "lgreenchest": "lime_shulker_box", + "lightgreenshulkerbox": "lime_shulker_box", + "lightgreenchest": "lime_shulker_box", + "lime_stained_glass": { + "material": "LIME_STAINED_GLASS" + }, + "limestainedglass": "lime_stained_glass", + "lglass": "lime_stained_glass", + "lsglass": "lime_stained_glass", + "lstainedglass": "lime_stained_glass", + "limeglass": "lime_stained_glass", + "limesglass": "lime_stained_glass", + "lgreglass": "lime_stained_glass", + "lgresglass": "lime_stained_glass", + "lgrestainedglass": "lime_stained_glass", + "lightgreglass": "lime_stained_glass", + "lightgresglass": "lime_stained_glass", + "lightgrestainedglass": "lime_stained_glass", + "lgreenglass": "lime_stained_glass", + "lgreensglass": "lime_stained_glass", + "lgreenstainedglass": "lime_stained_glass", + "lightgreenglass": "lime_stained_glass", + "lightgreensglass": "lime_stained_glass", + "lightgreenstainedglass": "lime_stained_glass", + "lime_stained_glass_pane": { + "material": "LIME_STAINED_GLASS_PANE" + }, + "limestainedglasspane": "lime_stained_glass_pane", + "lglasspane": "lime_stained_glass_pane", + "lsglasspane": "lime_stained_glass_pane", + "lstainedglasspane": "lime_stained_glass_pane", + "limeglasspane": "lime_stained_glass_pane", + "limesglasspane": "lime_stained_glass_pane", + "lgreglasspane": "lime_stained_glass_pane", + "lgresglasspane": "lime_stained_glass_pane", + "lgrestainedglasspane": "lime_stained_glass_pane", + "lightgreglasspane": "lime_stained_glass_pane", + "lightgresglasspane": "lime_stained_glass_pane", + "lightgrestainedglasspane": "lime_stained_glass_pane", + "lgreenglasspane": "lime_stained_glass_pane", + "lgreensglasspane": "lime_stained_glass_pane", + "lgreenstainedglasspane": "lime_stained_glass_pane", + "lightgreenglasspane": "lime_stained_glass_pane", + "lightgreensglasspane": "lime_stained_glass_pane", + "lightgreenstainedglasspane": "lime_stained_glass_pane", + "lime_terracotta": { + "material": "LIME_TERRACOTTA" + }, + "limeterracotta": "lime_terracotta", + "lclay": "lime_terracotta", + "lsclay": "lime_terracotta", + "lstainedclay": "lime_terracotta", + "lterra": "lime_terracotta", + "ltcota": "lime_terracotta", + "lterracota": "lime_terracotta", + "lterracotta": "lime_terracotta", + "limeclay": "lime_terracotta", + "limesclay": "lime_terracotta", + "limestainedclay": "lime_terracotta", + "limeterra": "lime_terracotta", + "limetcota": "lime_terracotta", + "limeterracota": "lime_terracotta", + "lgreclay": "lime_terracotta", + "lgresclay": "lime_terracotta", + "lgrestainedclay": "lime_terracotta", + "lgreterra": "lime_terracotta", + "lgretcota": "lime_terracotta", + "lgreterracota": "lime_terracotta", + "lgreterracotta": "lime_terracotta", + "lightgreclay": "lime_terracotta", + "lightgresclay": "lime_terracotta", + "lightgrestainedclay": "lime_terracotta", + "lightgreterra": "lime_terracotta", + "lightgretcota": "lime_terracotta", + "lightgreterracota": "lime_terracotta", + "lightgreterracotta": "lime_terracotta", + "lgreenclay": "lime_terracotta", + "lgreensclay": "lime_terracotta", + "lgreenstainedclay": "lime_terracotta", + "lgreenterra": "lime_terracotta", + "lgreentcota": "lime_terracotta", + "lgreenterracota": "lime_terracotta", + "lgreenterracotta": "lime_terracotta", + "lightgreenclay": "lime_terracotta", + "lightgreensclay": "lime_terracotta", + "lightgreenstainedclay": "lime_terracotta", + "lightgreenterra": "lime_terracotta", + "lightgreentcota": "lime_terracotta", + "lightgreenterracota": "lime_terracotta", + "lightgreenterracotta": "lime_terracotta", + "lime_wall_banner": { + "material": "LIME_WALL_BANNER" + }, + "limewallbanner": "lime_wall_banner", + "lwallbanner": "lime_wall_banner", + "lgrewallbanner": "lime_wall_banner", + "lightgrewallbanner": "lime_wall_banner", + "lgreenwallbanner": "lime_wall_banner", + "lightgreenwallbanner": "lime_wall_banner", + "lime_wool": { + "material": "LIME_WOOL" + }, + "limewool": "lime_wool", + "lwool": "lime_wool", + "lcloth": "lime_wool", + "lcotton": "lime_wool", + "limecloth": "lime_wool", + "limecotton": "lime_wool", + "lgrewool": "lime_wool", + "lgrecloth": "lime_wool", + "lgrecotton": "lime_wool", + "lightgrewool": "lime_wool", + "lightgrecloth": "lime_wool", + "lightgrecotton": "lime_wool", + "lgreenwool": "lime_wool", + "lgreencloth": "lime_wool", + "lgreencotton": "lime_wool", + "lightgreenwool": "lime_wool", + "lightgreencloth": "lime_wool", + "lightgreencotton": "lime_wool", + "lingering_potion": { + "material": "LINGERING_POTION" + }, + "lingeringpotion": "lingering_potion", + "llama_spawn_egg": { + "material": "LLAMA_SPAWN_EGG" + }, + "llamaspawnegg": "llama_spawn_egg", + "magenta_banner": { + "material": "MAGENTA_BANNER" + }, + "magentabanner": "magenta_banner", + "mstandingbanner": "magenta_banner", + "mbanner": "magenta_banner", + "magentastandingbanner": "magenta_banner", + "magenta_bed": { + "material": "MAGENTA_BED" + }, + "magentabed": "magenta_bed", + "mbed": "magenta_bed", + "magenta_carpet": { + "material": "MAGENTA_CARPET" + }, + "magentacarpet": "magenta_carpet", + "mcarpet": "magenta_carpet", + "mfloor": "magenta_carpet", + "magentafloor": "magenta_carpet", + "magenta_concrete": { + "material": "MAGENTA_CONCRETE" + }, + "magentaconcrete": "magenta_concrete", + "mconcrete": "magenta_concrete", + "magenta_concrete_powder": { + "material": "MAGENTA_CONCRETE_POWDER" + }, + "magentaconcretepowder": "magenta_concrete_powder", + "mconcretepowder": "magenta_concrete_powder", + "mconcretesand": "magenta_concrete_powder", + "magentaconcretesand": "magenta_concrete_powder", + "magenta_dye": { + "material": "MAGENTA_DYE" + }, + "magentadye": "magenta_dye", + "magenta_glazed_terracotta": { + "material": "MAGENTA_GLAZED_TERRACOTTA" + }, + "magentaglazedterracotta": "magenta_glazed_terracotta", + "mglazedtcota": "magenta_glazed_terracotta", + "mglazedterra": "magenta_glazed_terracotta", + "mglazedterracotta": "magenta_glazed_terracotta", + "mglazedterracota": "magenta_glazed_terracotta", + "magentaglazedtcota": "magenta_glazed_terracotta", + "magentaglazedterra": "magenta_glazed_terracotta", + "magentaglazedterracota": "magenta_glazed_terracotta", + "magenta_shulker_box": { + "material": "MAGENTA_SHULKER_BOX" + }, + "magentashulkerbox": "magenta_shulker_box", + "mshulkerbox": "magenta_shulker_box", + "mchest": "magenta_shulker_box", + "magentachest": "magenta_shulker_box", + "magenta_stained_glass": { + "material": "MAGENTA_STAINED_GLASS" + }, + "magentastainedglass": "magenta_stained_glass", + "mglass": "magenta_stained_glass", + "msglass": "magenta_stained_glass", + "mstainedglass": "magenta_stained_glass", + "magentaglass": "magenta_stained_glass", + "magentasglass": "magenta_stained_glass", + "magenta_stained_glass_pane": { + "material": "MAGENTA_STAINED_GLASS_PANE" + }, + "magentastainedglasspane": "magenta_stained_glass_pane", + "mglasspane": "magenta_stained_glass_pane", + "msglasspane": "magenta_stained_glass_pane", + "mstainedglasspane": "magenta_stained_glass_pane", + "magentaglasspane": "magenta_stained_glass_pane", + "magentasglasspane": "magenta_stained_glass_pane", + "magenta_terracotta": { + "material": "MAGENTA_TERRACOTTA" + }, + "magentaterracotta": "magenta_terracotta", + "mclay": "magenta_terracotta", + "msclay": "magenta_terracotta", + "mstainedclay": "magenta_terracotta", + "mterra": "magenta_terracotta", + "mtcota": "magenta_terracotta", + "mterracota": "magenta_terracotta", + "mterracotta": "magenta_terracotta", + "magentaclay": "magenta_terracotta", + "magentasclay": "magenta_terracotta", + "magentastainedclay": "magenta_terracotta", + "magentaterra": "magenta_terracotta", + "magentatcota": "magenta_terracotta", + "magentaterracota": "magenta_terracotta", + "magenta_wall_banner": { + "material": "MAGENTA_WALL_BANNER" + }, + "magentawallbanner": "magenta_wall_banner", + "mwallbanner": "magenta_wall_banner", + "magenta_wool": { + "material": "MAGENTA_WOOL" + }, + "magentawool": "magenta_wool", + "mwool": "magenta_wool", + "mcloth": "magenta_wool", + "mcotton": "magenta_wool", + "magentacloth": "magenta_wool", + "magentacotton": "magenta_wool", + "magma_block": { + "material": "MAGMA_BLOCK" + }, + "magmablock": "magma_block", + "magma_cream": { + "material": "MAGMA_CREAM" + }, + "magmacream": "magma_cream", + "magma_cube_spawn_egg": { + "material": "MAGMA_CUBE_SPAWN_EGG" + }, + "magmacubespawnegg": "magma_cube_spawn_egg", + "map": { + "material": "MAP" + }, + "melon": { + "material": "MELON" + }, + "melon_seeds": { + "material": "MELON_SEEDS" + }, + "melonseeds": "melon_seeds", + "melon_slice": { + "material": "MELON_SLICE" + }, + "melonslice": "melon_slice", + "melon_stem": { + "material": "MELON_STEM" + }, + "melonstem": "melon_stem", + "milk_bucket": { + "material": "MILK_BUCKET" + }, + "milkbucket": "milk_bucket", + "minecart": { + "material": "MINECART" + }, + "mooshroom_spawn_egg": { + "material": "MOOSHROOM_SPAWN_EGG" + }, + "mooshroomspawnegg": "mooshroom_spawn_egg", + "mossy_cobblestone": { + "material": "MOSSY_COBBLESTONE" + }, + "mossycobblestone": "mossy_cobblestone", + "mossy_cobblestone_wall": { + "material": "MOSSY_COBBLESTONE_WALL" + }, + "mossycobblestonewall": "mossy_cobblestone_wall", + "mossy_stone_bricks": { + "material": "MOSSY_STONE_BRICKS" + }, + "mossystonebricks": "mossy_stone_bricks", + "moving_piston": { + "material": "MOVING_PISTON" + }, + "movingpiston": "moving_piston", + "mule_spawn_egg": { + "material": "MULE_SPAWN_EGG" + }, + "mulespawnegg": "mule_spawn_egg", + "mushroom_stem": { + "material": "MUSHROOM_STEM" + }, + "mushroomstem": "mushroom_stem", + "mushroom_stew": { + "material": "MUSHROOM_STEW" + }, + "mushroomstew": "mushroom_stew", + "music_disc_11": { + "material": "MUSIC_DISC_11" + }, + "musicdisc11": "music_disc_11", + "11musicrecord": "music_disc_11", + "crackedmusicrecord": "music_disc_11", + "crackmusicrecord": "music_disc_11", + "cmusicrecord": "music_disc_11", + "musicrecord11": "music_disc_11", + "11musicdisk": "music_disc_11", + "crackedmusicdisk": "music_disc_11", + "crackmusicdisk": "music_disc_11", + "cmusicdisk": "music_disc_11", + "musicdisk11": "music_disc_11", + "11musicdisc": "music_disc_11", + "crackedmusicdisc": "music_disc_11", + "crackmusicdisc": "music_disc_11", + "cmusicdisc": "music_disc_11", + "11musiccd": "music_disc_11", + "crackedmusiccd": "music_disc_11", + "crackmusiccd": "music_disc_11", + "cmusiccd": "music_disc_11", + "musiccd11": "music_disc_11", + "11mrecord": "music_disc_11", + "crackedmrecord": "music_disc_11", + "crackmrecord": "music_disc_11", + "cmrecord": "music_disc_11", + "mrecord11": "music_disc_11", + "11mdisk": "music_disc_11", + "crackedmdisk": "music_disc_11", + "crackmdisk": "music_disc_11", + "cmdisk": "music_disc_11", + "mdisk11": "music_disc_11", + "11mdisc": "music_disc_11", + "crackedmdisc": "music_disc_11", + "crackmdisc": "music_disc_11", + "cmdisc": "music_disc_11", + "mdisc11": "music_disc_11", + "11mcd": "music_disc_11", + "crackedmcd": "music_disc_11", + "crackmcd": "music_disc_11", + "cmcd": "music_disc_11", + "mcd11": "music_disc_11", + "11record": "music_disc_11", + "crackedrecord": "music_disc_11", + "crackrecord": "music_disc_11", + "crecord": "music_disc_11", + "record11": "music_disc_11", + "11disk": "music_disc_11", + "crackeddisk": "music_disc_11", + "crackdisk": "music_disc_11", + "cdisk": "music_disc_11", + "disk11": "music_disc_11", + "11disc": "music_disc_11", + "crackeddisc": "music_disc_11", + "crackdisc": "music_disc_11", + "cdisc": "music_disc_11", + "disc11": "music_disc_11", + "11cd": "music_disc_11", + "crackedcd": "music_disc_11", + "crackcd": "music_disc_11", + "ccd": "music_disc_11", + "cd11": "music_disc_11", + "music_disc_13": { + "material": "MUSIC_DISC_13" + }, + "musicdisc13": "music_disc_13", + "13musicrecord": "music_disc_13", + "goldmusicrecord": "music_disc_13", + "gomusicrecord": "music_disc_13", + "musicrecord1": "music_disc_13", + "1musicrecord": "music_disc_13", + "13musicdisk": "music_disc_13", + "goldmusicdisk": "music_disc_13", + "gomusicdisk": "music_disc_13", + "musicdisk1": "music_disc_13", + "1musicdisk": "music_disc_13", + "13musicdisc": "music_disc_13", + "goldmusicdisc": "music_disc_13", + "gomusicdisc": "music_disc_13", + "musicdisc1": "music_disc_13", + "1musicdisc": "music_disc_13", + "13musiccd": "music_disc_13", + "goldmusiccd": "music_disc_13", + "gomusiccd": "music_disc_13", + "musiccd1": "music_disc_13", + "1musiccd": "music_disc_13", + "13mrecord": "music_disc_13", + "goldmrecord": "music_disc_13", + "gomrecord": "music_disc_13", + "mrecord1": "music_disc_13", + "1mrecord": "music_disc_13", + "13mdisk": "music_disc_13", + "goldmdisk": "music_disc_13", + "gomdisk": "music_disc_13", + "mdisk1": "music_disc_13", + "1mdisk": "music_disc_13", + "13mdisc": "music_disc_13", + "goldmdisc": "music_disc_13", + "gomdisc": "music_disc_13", + "mdisc1": "music_disc_13", + "1mdisc": "music_disc_13", + "13mcd": "music_disc_13", + "goldmcd": "music_disc_13", + "gomcd": "music_disc_13", + "mcd1": "music_disc_13", + "1mcd": "music_disc_13", + "13record": "music_disc_13", + "goldrecord": "music_disc_13", + "gorecord": "music_disc_13", + "record1": "music_disc_13", + "1record": "music_disc_13", + "13disk": "music_disc_13", + "golddisk": "music_disc_13", + "godisk": "music_disc_13", + "disk1": "music_disc_13", + "1disk": "music_disc_13", + "13disc": "music_disc_13", + "golddisc": "music_disc_13", + "godisc": "music_disc_13", + "disc1": "music_disc_13", + "1disc": "music_disc_13", + "13cd": "music_disc_13", + "goldcd": "music_disc_13", + "gocd": "music_disc_13", + "cd1": "music_disc_13", + "1cd": "music_disc_13", + "music_disc_blocks": { + "material": "MUSIC_DISC_BLOCKS" + }, + "musicdiscblocks": "music_disc_blocks", + "blocksmusicrecord": "music_disc_blocks", + "orangemusicrecord": "music_disc_blocks", + "ormusicrecord": "music_disc_blocks", + "musicrecord3": "music_disc_blocks", + "3musicrecord": "music_disc_blocks", + "blocksmusicdisk": "music_disc_blocks", + "orangemusicdisk": "music_disc_blocks", + "ormusicdisk": "music_disc_blocks", + "musicdisk3": "music_disc_blocks", + "3musicdisk": "music_disc_blocks", + "blocksmusicdisc": "music_disc_blocks", + "orangemusicdisc": "music_disc_blocks", + "ormusicdisc": "music_disc_blocks", + "musicdisc3": "music_disc_blocks", + "3musicdisc": "music_disc_blocks", + "blocksmusiccd": "music_disc_blocks", + "orangemusiccd": "music_disc_blocks", + "ormusiccd": "music_disc_blocks", + "musiccd3": "music_disc_blocks", + "3musiccd": "music_disc_blocks", + "blocksmrecord": "music_disc_blocks", + "orangemrecord": "music_disc_blocks", + "ormrecord": "music_disc_blocks", + "mrecord3": "music_disc_blocks", + "3mrecord": "music_disc_blocks", + "blocksmdisk": "music_disc_blocks", + "orangemdisk": "music_disc_blocks", + "ormdisk": "music_disc_blocks", + "mdisk3": "music_disc_blocks", + "3mdisk": "music_disc_blocks", + "blocksmdisc": "music_disc_blocks", + "orangemdisc": "music_disc_blocks", + "ormdisc": "music_disc_blocks", + "mdisc3": "music_disc_blocks", + "3mdisc": "music_disc_blocks", + "blocksmcd": "music_disc_blocks", + "orangemcd": "music_disc_blocks", + "ormcd": "music_disc_blocks", + "mcd3": "music_disc_blocks", + "3mcd": "music_disc_blocks", + "blocksrecord": "music_disc_blocks", + "orangerecord": "music_disc_blocks", + "orrecord": "music_disc_blocks", + "record3": "music_disc_blocks", + "3record": "music_disc_blocks", + "blocksdisk": "music_disc_blocks", + "orangedisk": "music_disc_blocks", + "ordisk": "music_disc_blocks", + "disk3": "music_disc_blocks", + "3disk": "music_disc_blocks", + "blocksdisc": "music_disc_blocks", + "orangedisc": "music_disc_blocks", + "ordisc": "music_disc_blocks", + "disc3": "music_disc_blocks", + "3disc": "music_disc_blocks", + "blockscd": "music_disc_blocks", + "orangecd": "music_disc_blocks", + "orcd": "music_disc_blocks", + "cd3": "music_disc_blocks", + "3cd": "music_disc_blocks", + "music_disc_cat": { + "material": "MUSIC_DISC_CAT" + }, + "musicdisccat": "music_disc_cat", + "catmusicrecord": "music_disc_cat", + "greenmusicrecord": "music_disc_cat", + "grmusicrecord": "music_disc_cat", + "musicrecord2": "music_disc_cat", + "2musicrecord": "music_disc_cat", + "catmusicdisk": "music_disc_cat", + "greenmusicdisk": "music_disc_cat", + "grmusicdisk": "music_disc_cat", + "musicdisk2": "music_disc_cat", + "2musicdisk": "music_disc_cat", + "catmusicdisc": "music_disc_cat", + "greenmusicdisc": "music_disc_cat", + "grmusicdisc": "music_disc_cat", + "musicdisc2": "music_disc_cat", + "2musicdisc": "music_disc_cat", + "catmusiccd": "music_disc_cat", + "greenmusiccd": "music_disc_cat", + "grmusiccd": "music_disc_cat", + "musiccd2": "music_disc_cat", + "2musiccd": "music_disc_cat", + "catmrecord": "music_disc_cat", + "greenmrecord": "music_disc_cat", + "grmrecord": "music_disc_cat", + "mrecord2": "music_disc_cat", + "2mrecord": "music_disc_cat", + "catmdisk": "music_disc_cat", + "greenmdisk": "music_disc_cat", + "grmdisk": "music_disc_cat", + "mdisk2": "music_disc_cat", + "2mdisk": "music_disc_cat", + "catmdisc": "music_disc_cat", + "greenmdisc": "music_disc_cat", + "grmdisc": "music_disc_cat", + "mdisc2": "music_disc_cat", + "2mdisc": "music_disc_cat", + "catmcd": "music_disc_cat", + "greenmcd": "music_disc_cat", + "grmcd": "music_disc_cat", + "mcd2": "music_disc_cat", + "2mcd": "music_disc_cat", + "catrecord": "music_disc_cat", + "greenrecord": "music_disc_cat", + "grrecord": "music_disc_cat", + "record2": "music_disc_cat", + "2record": "music_disc_cat", + "catdisk": "music_disc_cat", + "greendisk": "music_disc_cat", + "grdisk": "music_disc_cat", + "disk2": "music_disc_cat", + "2disk": "music_disc_cat", + "catdisc": "music_disc_cat", + "greendisc": "music_disc_cat", + "grdisc": "music_disc_cat", + "disc2": "music_disc_cat", + "2disc": "music_disc_cat", + "catcd": "music_disc_cat", + "greencd": "music_disc_cat", + "grcd": "music_disc_cat", + "cd2": "music_disc_cat", + "2cd": "music_disc_cat", + "music_disc_chirp": { + "material": "MUSIC_DISC_CHIRP" + }, + "musicdiscchirp": "music_disc_chirp", + "chirpmusicrecord": "music_disc_chirp", + "redmusicrecord": "music_disc_chirp", + "remusicrecord": "music_disc_chirp", + "musicrecord4": "music_disc_chirp", + "4musicrecord": "music_disc_chirp", + "chirpmusicdisk": "music_disc_chirp", + "redmusicdisk": "music_disc_chirp", + "remusicdisk": "music_disc_chirp", + "musicdisk4": "music_disc_chirp", + "4musicdisk": "music_disc_chirp", + "chirpmusicdisc": "music_disc_chirp", + "redmusicdisc": "music_disc_chirp", + "remusicdisc": "music_disc_chirp", + "musicdisc4": "music_disc_chirp", + "4musicdisc": "music_disc_chirp", + "chirpmusiccd": "music_disc_chirp", + "redmusiccd": "music_disc_chirp", + "remusiccd": "music_disc_chirp", + "musiccd4": "music_disc_chirp", + "4musiccd": "music_disc_chirp", + "chirpmrecord": "music_disc_chirp", + "redmrecord": "music_disc_chirp", + "remrecord": "music_disc_chirp", + "mrecord4": "music_disc_chirp", + "4mrecord": "music_disc_chirp", + "chirpmdisk": "music_disc_chirp", + "redmdisk": "music_disc_chirp", + "remdisk": "music_disc_chirp", + "mdisk4": "music_disc_chirp", + "4mdisk": "music_disc_chirp", + "chirpmdisc": "music_disc_chirp", + "redmdisc": "music_disc_chirp", + "remdisc": "music_disc_chirp", + "mdisc4": "music_disc_chirp", + "4mdisc": "music_disc_chirp", + "chirpmcd": "music_disc_chirp", + "redmcd": "music_disc_chirp", + "remcd": "music_disc_chirp", + "mcd4": "music_disc_chirp", + "4mcd": "music_disc_chirp", + "chirprecord": "music_disc_chirp", + "redrecord": "music_disc_chirp", + "rerecord": "music_disc_chirp", + "record4": "music_disc_chirp", + "4record": "music_disc_chirp", + "chirpdisk": "music_disc_chirp", + "reddisk": "music_disc_chirp", + "redisk": "music_disc_chirp", + "disk4": "music_disc_chirp", + "4disk": "music_disc_chirp", + "chirpdisc": "music_disc_chirp", + "reddisc": "music_disc_chirp", + "redisc": "music_disc_chirp", + "disc4": "music_disc_chirp", + "4disc": "music_disc_chirp", + "chirpcd": "music_disc_chirp", + "redcd": "music_disc_chirp", + "recd": "music_disc_chirp", + "cd4": "music_disc_chirp", + "4cd": "music_disc_chirp", + "music_disc_far": { + "material": "MUSIC_DISC_FAR" + }, + "musicdiscfar": "music_disc_far", + "farmusicrecord": "music_disc_far", + "lightgreenmusicrecord": "music_disc_far", + "lgreenmusicrecord": "music_disc_far", + "lightgrmusicrecord": "music_disc_far", + "lgrmusicrecord": "music_disc_far", + "musicrecord5": "music_disc_far", + "5musicrecord": "music_disc_far", + "farmusicdisk": "music_disc_far", + "lightgreenmusicdisk": "music_disc_far", + "lgreenmusicdisk": "music_disc_far", + "lightgrmusicdisk": "music_disc_far", + "lgrmusicdisk": "music_disc_far", + "musicdisk5": "music_disc_far", + "5musicdisk": "music_disc_far", + "farmusicdisc": "music_disc_far", + "lightgreenmusicdisc": "music_disc_far", + "lgreenmusicdisc": "music_disc_far", + "lightgrmusicdisc": "music_disc_far", + "lgrmusicdisc": "music_disc_far", + "musicdisc5": "music_disc_far", + "5musicdisc": "music_disc_far", + "farmusiccd": "music_disc_far", + "lightgreenmusiccd": "music_disc_far", + "lgreenmusiccd": "music_disc_far", + "lightgrmusiccd": "music_disc_far", + "lgrmusiccd": "music_disc_far", + "musiccd5": "music_disc_far", + "5musiccd": "music_disc_far", + "farmrecord": "music_disc_far", + "lightgreenmrecord": "music_disc_far", + "lgreenmrecord": "music_disc_far", + "lightgrmrecord": "music_disc_far", + "lgrmrecord": "music_disc_far", + "mrecord5": "music_disc_far", + "5mrecord": "music_disc_far", + "farmdisk": "music_disc_far", + "lightgreenmdisk": "music_disc_far", + "lgreenmdisk": "music_disc_far", + "lightgrmdisk": "music_disc_far", + "lgrmdisk": "music_disc_far", + "mdisk5": "music_disc_far", + "5mdisk": "music_disc_far", + "farmdisc": "music_disc_far", + "lightgreenmdisc": "music_disc_far", + "lgreenmdisc": "music_disc_far", + "lightgrmdisc": "music_disc_far", + "lgrmdisc": "music_disc_far", + "mdisc5": "music_disc_far", + "5mdisc": "music_disc_far", + "farmcd": "music_disc_far", + "lightgreenmcd": "music_disc_far", + "lgreenmcd": "music_disc_far", + "lightgrmcd": "music_disc_far", + "lgrmcd": "music_disc_far", + "mcd5": "music_disc_far", + "5mcd": "music_disc_far", + "farrecord": "music_disc_far", + "lightgreenrecord": "music_disc_far", + "lgreenrecord": "music_disc_far", + "lightgrrecord": "music_disc_far", + "lgrrecord": "music_disc_far", + "record5": "music_disc_far", + "5record": "music_disc_far", + "fardisk": "music_disc_far", + "lightgreendisk": "music_disc_far", + "lgreendisk": "music_disc_far", + "lightgrdisk": "music_disc_far", + "lgrdisk": "music_disc_far", + "disk5": "music_disc_far", + "5disk": "music_disc_far", + "fardisc": "music_disc_far", + "lightgreendisc": "music_disc_far", + "lgreendisc": "music_disc_far", + "lightgrdisc": "music_disc_far", + "lgrdisc": "music_disc_far", + "disc5": "music_disc_far", + "5disc": "music_disc_far", + "farcd": "music_disc_far", + "lightgreencd": "music_disc_far", + "lgreencd": "music_disc_far", + "lightgrcd": "music_disc_far", + "lgrcd": "music_disc_far", + "cd5": "music_disc_far", + "5cd": "music_disc_far", + "music_disc_mall": { + "material": "MUSIC_DISC_MALL" + }, + "musicdiscmall": "music_disc_mall", + "mallmusicrecord": "music_disc_mall", + "purplemusicrecord": "music_disc_mall", + "pumusicrecord": "music_disc_mall", + "musicrecord6": "music_disc_mall", + "6musicrecord": "music_disc_mall", + "mallmusicdisk": "music_disc_mall", + "purplemusicdisk": "music_disc_mall", + "pumusicdisk": "music_disc_mall", + "musicdisk6": "music_disc_mall", + "6musicdisk": "music_disc_mall", + "mallmusicdisc": "music_disc_mall", + "purplemusicdisc": "music_disc_mall", + "pumusicdisc": "music_disc_mall", + "musicdisc6": "music_disc_mall", + "6musicdisc": "music_disc_mall", + "mallmusiccd": "music_disc_mall", + "purplemusiccd": "music_disc_mall", + "pumusiccd": "music_disc_mall", + "musiccd6": "music_disc_mall", + "6musiccd": "music_disc_mall", + "mallmrecord": "music_disc_mall", + "purplemrecord": "music_disc_mall", + "pumrecord": "music_disc_mall", + "mrecord6": "music_disc_mall", + "6mrecord": "music_disc_mall", + "mallmdisk": "music_disc_mall", + "purplemdisk": "music_disc_mall", + "pumdisk": "music_disc_mall", + "mdisk6": "music_disc_mall", + "6mdisk": "music_disc_mall", + "mallmdisc": "music_disc_mall", + "purplemdisc": "music_disc_mall", + "pumdisc": "music_disc_mall", + "mdisc6": "music_disc_mall", + "6mdisc": "music_disc_mall", + "mallmcd": "music_disc_mall", + "purplemcd": "music_disc_mall", + "pumcd": "music_disc_mall", + "mcd6": "music_disc_mall", + "6mcd": "music_disc_mall", + "mallrecord": "music_disc_mall", + "purplerecord": "music_disc_mall", + "purecord": "music_disc_mall", + "record6": "music_disc_mall", + "6record": "music_disc_mall", + "malldisk": "music_disc_mall", + "purpledisk": "music_disc_mall", + "pudisk": "music_disc_mall", + "disk6": "music_disc_mall", + "6disk": "music_disc_mall", + "malldisc": "music_disc_mall", + "purpledisc": "music_disc_mall", + "pudisc": "music_disc_mall", + "disc6": "music_disc_mall", + "6disc": "music_disc_mall", + "mallcd": "music_disc_mall", + "purplecd": "music_disc_mall", + "pucd": "music_disc_mall", + "cd6": "music_disc_mall", + "6cd": "music_disc_mall", + "music_disc_mellohi": { + "material": "MUSIC_DISC_MELLOHI" + }, + "musicdiscmellohi": "music_disc_mellohi", + "mellohimusicrecord": "music_disc_mellohi", + "pinkmusicrecord": "music_disc_mellohi", + "pimusicrecord": "music_disc_mellohi", + "musicrecord7": "music_disc_mellohi", + "7musicrecord": "music_disc_mellohi", + "mellohimusicdisk": "music_disc_mellohi", + "pinkmusicdisk": "music_disc_mellohi", + "pimusicdisk": "music_disc_mellohi", + "musicdisk7": "music_disc_mellohi", + "7musicdisk": "music_disc_mellohi", + "mellohimusicdisc": "music_disc_mellohi", + "pinkmusicdisc": "music_disc_mellohi", + "pimusicdisc": "music_disc_mellohi", + "musicdisc7": "music_disc_mellohi", + "7musicdisc": "music_disc_mellohi", + "mellohimusiccd": "music_disc_mellohi", + "pinkmusiccd": "music_disc_mellohi", + "pimusiccd": "music_disc_mellohi", + "musiccd7": "music_disc_mellohi", + "7musiccd": "music_disc_mellohi", + "mellohimrecord": "music_disc_mellohi", + "pinkmrecord": "music_disc_mellohi", + "pimrecord": "music_disc_mellohi", + "mrecord7": "music_disc_mellohi", + "7mrecord": "music_disc_mellohi", + "mellohimdisk": "music_disc_mellohi", + "pinkmdisk": "music_disc_mellohi", + "pimdisk": "music_disc_mellohi", + "mdisk7": "music_disc_mellohi", + "7mdisk": "music_disc_mellohi", + "mellohimdisc": "music_disc_mellohi", + "pinkmdisc": "music_disc_mellohi", + "pimdisc": "music_disc_mellohi", + "mdisc7": "music_disc_mellohi", + "7mdisc": "music_disc_mellohi", + "mellohimcd": "music_disc_mellohi", + "pinkmcd": "music_disc_mellohi", + "pimcd": "music_disc_mellohi", + "mcd7": "music_disc_mellohi", + "7mcd": "music_disc_mellohi", + "mellohirecord": "music_disc_mellohi", + "pinkrecord": "music_disc_mellohi", + "pirecord": "music_disc_mellohi", + "record7": "music_disc_mellohi", + "7record": "music_disc_mellohi", + "mellohidisk": "music_disc_mellohi", + "pinkdisk": "music_disc_mellohi", + "pidisk": "music_disc_mellohi", + "disk7": "music_disc_mellohi", + "7disk": "music_disc_mellohi", + "mellohidisc": "music_disc_mellohi", + "pinkdisc": "music_disc_mellohi", + "pidisc": "music_disc_mellohi", + "disc7": "music_disc_mellohi", + "7disc": "music_disc_mellohi", + "mellohicd": "music_disc_mellohi", + "pinkcd": "music_disc_mellohi", + "picd": "music_disc_mellohi", + "cd7": "music_disc_mellohi", + "7cd": "music_disc_mellohi", + "music_disc_stal": { + "material": "MUSIC_DISC_STAL" + }, + "musicdiscstal": "music_disc_stal", + "stalmusicrecord": "music_disc_stal", + "blackmusicrecord": "music_disc_stal", + "blmusicrecord": "music_disc_wait", + "musicrecord8": "music_disc_stal", + "8musicrecord": "music_disc_stal", + "stalmusicdisk": "music_disc_stal", + "blackmusicdisk": "music_disc_stal", + "blmusicdisk": "music_disc_wait", + "musicdisk8": "music_disc_stal", + "8musicdisk": "music_disc_stal", + "stalmusicdisc": "music_disc_stal", + "blackmusicdisc": "music_disc_stal", + "blmusicdisc": "music_disc_wait", + "musicdisc8": "music_disc_stal", + "8musicdisc": "music_disc_stal", + "stalmusiccd": "music_disc_stal", + "blackmusiccd": "music_disc_stal", + "blmusiccd": "music_disc_wait", + "musiccd8": "music_disc_stal", + "8musiccd": "music_disc_stal", + "stalmrecord": "music_disc_stal", + "blackmrecord": "music_disc_stal", + "blmrecord": "music_disc_wait", + "mrecord8": "music_disc_stal", + "8mrecord": "music_disc_stal", + "stalmdisk": "music_disc_stal", + "blackmdisk": "music_disc_stal", + "blmdisk": "music_disc_wait", + "mdisk8": "music_disc_stal", + "8mdisk": "music_disc_stal", + "stalmdisc": "music_disc_stal", + "blackmdisc": "music_disc_stal", + "blmdisc": "music_disc_wait", + "mdisc8": "music_disc_stal", + "8mdisc": "music_disc_stal", + "stalmcd": "music_disc_stal", + "blackmcd": "music_disc_stal", + "blmcd": "music_disc_wait", + "mcd8": "music_disc_stal", + "8mcd": "music_disc_stal", + "stalrecord": "music_disc_stal", + "blackrecord": "music_disc_stal", + "blrecord": "music_disc_wait", + "record8": "music_disc_stal", + "8record": "music_disc_stal", + "staldisk": "music_disc_stal", + "blackdisk": "music_disc_stal", + "bldisk": "music_disc_wait", + "disk8": "music_disc_stal", + "8disk": "music_disc_stal", + "staldisc": "music_disc_stal", + "blackdisc": "music_disc_stal", + "bldisc": "music_disc_wait", + "disc8": "music_disc_stal", + "8disc": "music_disc_stal", + "stalcd": "music_disc_stal", + "blackcd": "music_disc_stal", + "blcd": "music_disc_wait", + "cd8": "music_disc_stal", + "8cd": "music_disc_stal", + "music_disc_strad": { + "material": "MUSIC_DISC_STRAD" + }, + "musicdiscstrad": "music_disc_strad", + "stradmusicrecord": "music_disc_strad", + "whitemusicrecord": "music_disc_strad", + "whmusicrecord": "music_disc_strad", + "musicrecord9": "music_disc_strad", + "9musicrecord": "music_disc_strad", + "stradmusicdisk": "music_disc_strad", + "whitemusicdisk": "music_disc_strad", + "whmusicdisk": "music_disc_strad", + "musicdisk9": "music_disc_strad", + "9musicdisk": "music_disc_strad", + "stradmusicdisc": "music_disc_strad", + "whitemusicdisc": "music_disc_strad", + "whmusicdisc": "music_disc_strad", + "musicdisc9": "music_disc_strad", + "9musicdisc": "music_disc_strad", + "stradmusiccd": "music_disc_strad", + "whitemusiccd": "music_disc_strad", + "whmusiccd": "music_disc_strad", + "musiccd9": "music_disc_strad", + "9musiccd": "music_disc_strad", + "stradmrecord": "music_disc_strad", + "whitemrecord": "music_disc_strad", + "whmrecord": "music_disc_strad", + "mrecord9": "music_disc_strad", + "9mrecord": "music_disc_strad", + "stradmdisk": "music_disc_strad", + "whitemdisk": "music_disc_strad", + "whmdisk": "music_disc_strad", + "mdisk9": "music_disc_strad", + "9mdisk": "music_disc_strad", + "stradmdisc": "music_disc_strad", + "whitemdisc": "music_disc_strad", + "whmdisc": "music_disc_strad", + "mdisc9": "music_disc_strad", + "9mdisc": "music_disc_strad", + "stradmcd": "music_disc_strad", + "whitemcd": "music_disc_strad", + "whmcd": "music_disc_strad", + "mcd9": "music_disc_strad", + "9mcd": "music_disc_strad", + "stradrecord": "music_disc_strad", + "whiterecord": "music_disc_strad", + "whrecord": "music_disc_strad", + "record9": "music_disc_strad", + "9record": "music_disc_strad", + "straddisk": "music_disc_strad", + "whitedisk": "music_disc_strad", + "whdisk": "music_disc_strad", + "disk9": "music_disc_strad", + "9disk": "music_disc_strad", + "straddisc": "music_disc_strad", + "whitedisc": "music_disc_strad", + "whdisc": "music_disc_strad", + "disc9": "music_disc_strad", + "9disc": "music_disc_strad", + "stradcd": "music_disc_strad", + "whitecd": "music_disc_strad", + "whcd": "music_disc_strad", + "cd9": "music_disc_strad", + "9cd": "music_disc_strad", + "music_disc_wait": { + "material": "MUSIC_DISC_WAIT" + }, + "musicdiscwait": "music_disc_wait", + "waitmusicrecord": "music_disc_wait", + "bluemusicrecord": "music_disc_wait", + "cyanmusicrecord": "music_disc_wait", + "cymusicrecord": "music_disc_wait", + "musicrecord12": "music_disc_wait", + "12musicrecord": "music_disc_wait", + "waitmusicdisk": "music_disc_wait", + "bluemusicdisk": "music_disc_wait", + "cyanmusicdisk": "music_disc_wait", + "cymusicdisk": "music_disc_wait", + "musicdisk12": "music_disc_wait", + "12musicdisk": "music_disc_wait", + "waitmusicdisc": "music_disc_wait", + "bluemusicdisc": "music_disc_wait", + "cyanmusicdisc": "music_disc_wait", + "cymusicdisc": "music_disc_wait", + "musicdisc12": "music_disc_wait", + "12musicdisc": "music_disc_wait", + "waitmusiccd": "music_disc_wait", + "bluemusiccd": "music_disc_wait", + "cyanmusiccd": "music_disc_wait", + "cymusiccd": "music_disc_wait", + "musiccd12": "music_disc_wait", + "12musiccd": "music_disc_wait", + "waitmrecord": "music_disc_wait", + "bluemrecord": "music_disc_wait", + "cyanmrecord": "music_disc_wait", + "cymrecord": "music_disc_wait", + "mrecord12": "music_disc_wait", + "12mrecord": "music_disc_wait", + "waitmdisk": "music_disc_wait", + "bluemdisk": "music_disc_wait", + "cyanmdisk": "music_disc_wait", + "cymdisk": "music_disc_wait", + "mdisk12": "music_disc_wait", + "12mdisk": "music_disc_wait", + "waitmdisc": "music_disc_wait", + "bluemdisc": "music_disc_wait", + "cyanmdisc": "music_disc_wait", + "cymdisc": "music_disc_wait", + "mdisc12": "music_disc_wait", + "12mdisc": "music_disc_wait", + "waitmcd": "music_disc_wait", + "bluemcd": "music_disc_wait", + "cyanmcd": "music_disc_wait", + "cymcd": "music_disc_wait", + "mcd12": "music_disc_wait", + "12mcd": "music_disc_wait", + "waitrecord": "music_disc_wait", + "bluerecord": "music_disc_wait", + "cyanrecord": "music_disc_wait", + "cyrecord": "music_disc_wait", + "record12": "music_disc_wait", + "12record": "music_disc_wait", + "waitdisk": "music_disc_wait", + "bluedisk": "music_disc_wait", + "cyandisk": "music_disc_wait", + "cydisk": "music_disc_wait", + "disk12": "music_disc_wait", + "12disk": "music_disc_wait", + "waitdisc": "music_disc_wait", + "bluedisc": "music_disc_wait", + "cyandisc": "music_disc_wait", + "cydisc": "music_disc_wait", + "disc12": "music_disc_wait", + "12disc": "music_disc_wait", + "waitcd": "music_disc_wait", + "bluecd": "music_disc_wait", + "cyancd": "music_disc_wait", + "cycd": "music_disc_wait", + "cd12": "music_disc_wait", + "12cd": "music_disc_wait", + "music_disc_ward": { + "material": "MUSIC_DISC_WARD" + }, + "musicdiscward": "music_disc_ward", + "wardmusicrecord": "music_disc_ward", + "darkgreenmusicrecord": "music_disc_ward", + "dgreenmusicrecord": "music_disc_ward", + "darkgrmusicrecord": "music_disc_ward", + "dgrmusicrecord": "music_disc_ward", + "musicrecord10": "music_disc_ward", + "10musicrecord": "music_disc_ward", + "wardmusicdisk": "music_disc_ward", + "darkgreenmusicdisk": "music_disc_ward", + "dgreenmusicdisk": "music_disc_ward", + "darkgrmusicdisk": "music_disc_ward", + "dgrmusicdisk": "music_disc_ward", + "musicdisk10": "music_disc_ward", + "10musicdisk": "music_disc_ward", + "wardmusicdisc": "music_disc_ward", + "darkgreenmusicdisc": "music_disc_ward", + "dgreenmusicdisc": "music_disc_ward", + "darkgrmusicdisc": "music_disc_ward", + "dgrmusicdisc": "music_disc_ward", + "musicdisc10": "music_disc_ward", + "10musicdisc": "music_disc_ward", + "wardmusiccd": "music_disc_ward", + "darkgreenmusiccd": "music_disc_ward", + "dgreenmusiccd": "music_disc_ward", + "darkgrmusiccd": "music_disc_ward", + "dgrmusiccd": "music_disc_ward", + "musiccd10": "music_disc_ward", + "10musiccd": "music_disc_ward", + "wardmrecord": "music_disc_ward", + "darkgreenmrecord": "music_disc_ward", + "dgreenmrecord": "music_disc_ward", + "darkgrmrecord": "music_disc_ward", + "dgrmrecord": "music_disc_ward", + "mrecord10": "music_disc_ward", + "10mrecord": "music_disc_ward", + "wardmdisk": "music_disc_ward", + "darkgreenmdisk": "music_disc_ward", + "dgreenmdisk": "music_disc_ward", + "darkgrmdisk": "music_disc_ward", + "dgrmdisk": "music_disc_ward", + "mdisk10": "music_disc_ward", + "10mdisk": "music_disc_ward", + "wardmdisc": "music_disc_ward", + "darkgreenmdisc": "music_disc_ward", + "dgreenmdisc": "music_disc_ward", + "darkgrmdisc": "music_disc_ward", + "dgrmdisc": "music_disc_ward", + "mdisc10": "music_disc_ward", + "10mdisc": "music_disc_ward", + "wardmcd": "music_disc_ward", + "darkgreenmcd": "music_disc_ward", + "dgreenmcd": "music_disc_ward", + "darkgrmcd": "music_disc_ward", + "dgrmcd": "music_disc_ward", + "mcd10": "music_disc_ward", + "10mcd": "music_disc_ward", + "wardrecord": "music_disc_ward", + "darkgreenrecord": "music_disc_ward", + "dgreenrecord": "music_disc_ward", + "darkgrrecord": "music_disc_ward", + "dgrrecord": "music_disc_ward", + "record10": "music_disc_ward", + "10record": "music_disc_ward", + "warddisk": "music_disc_ward", + "darkgreendisk": "music_disc_ward", + "dgreendisk": "music_disc_ward", + "darkgrdisk": "music_disc_ward", + "dgrdisk": "music_disc_ward", + "disk10": "music_disc_ward", + "10disk": "music_disc_ward", + "warddisc": "music_disc_ward", + "darkgreendisc": "music_disc_ward", + "dgreendisc": "music_disc_ward", + "darkgrdisc": "music_disc_ward", + "dgrdisc": "music_disc_ward", + "disc10": "music_disc_ward", + "10disc": "music_disc_ward", + "wardcd": "music_disc_ward", + "darkgreencd": "music_disc_ward", + "dgreencd": "music_disc_ward", + "darkgrcd": "music_disc_ward", + "dgrcd": "music_disc_ward", + "cd10": "music_disc_ward", + "10cd": "music_disc_ward", + "mutton": { + "material": "MUTTON" + }, + "mycelium": { + "material": "MYCELIUM" + }, + "name_tag": { + "material": "NAME_TAG" + }, + "nametag": "name_tag", + "nautilus_shell": { + "material": "NAUTILUS_SHELL" + }, + "nautilusshell": "nautilus_shell", + "netherrack": { + "material": "NETHERRACK" + }, + "nether_brick": { + "material": "NETHER_BRICK" + }, + "netherbrick": "nether_brick", + "nether_bricks": { + "material": "NETHER_BRICKS" + }, + "netherbricks": "nether_bricks", + "nether_brick_fence": { + "material": "NETHER_BRICK_FENCE" + }, + "netherbrickfence": "nether_brick_fence", + "nether_brick_slab": { + "material": "NETHER_BRICK_SLAB" + }, + "netherbrickslab": "nether_brick_slab", + "nether_brick_stairs": { + "material": "NETHER_BRICK_STAIRS" + }, + "netherbrickstairs": "nether_brick_stairs", + "nether_portal": { + "material": "NETHER_PORTAL" + }, + "netherportal": "nether_portal", + "nether_quartz_ore": { + "material": "NETHER_QUARTZ_ORE" + }, + "netherquartzore": "nether_quartz_ore", + "nether_star": { + "material": "NETHER_STAR" + }, + "netherstar": "nether_star", + "nether_wart": { + "material": "NETHER_WART" + }, + "netherwart": "nether_wart", + "nether_wart_block": { + "material": "NETHER_WART_BLOCK" + }, + "netherwartblock": "nether_wart_block", + "note_block": { + "material": "NOTE_BLOCK" + }, + "noteblock": "note_block", + "musicblock": "note_block", + "nblock": "note_block", + "mblock": "note_block", + "oak_boat": { + "material": "OAK_BOAT" + }, + "oakboat": "oak_boat", + "boat": "oak_boat", + "oboat": "oak_boat", + "oak_button": { + "material": "OAK_BUTTON" + }, + "oakbutton": "oak_button", + "oak_door": { + "material": "OAK_DOOR" + }, + "oakdoor": "oak_door", + "oak_fence": { + "material": "OAK_FENCE" + }, + "oakfence": "oak_fence", + "fence": "oak_fence", + "ofence": "oak_fence", + "oak_fence_gate": { + "material": "OAK_FENCE_GATE" + }, + "oakfencegate": "oak_fence_gate", + "fencegate": "oak_fence_gate", + "gate": "oak_fence_gate", + "oakgate": "oak_fence_gate", + "ofencegate": "oak_fence_gate", + "ogate": "oak_fence_gate", + "oak_leaves": { + "material": "OAK_LEAVES" + }, + "oakleaves": "oak_leaves", + "treeleaves": "oak_leaves", + "logleaves": "oak_leaves", + "trunkleaves": "oak_leaves", + "woodleaves": "oak_leaves", + "leaves": "oak_leaves", + "treeleaf": "oak_leaves", + "logleaf": "oak_leaves", + "trunkleaf": "oak_leaves", + "woodleaf": "oak_leaves", + "leaf": "oak_leaves", + "treeleave": "oak_leaves", + "logleave": "oak_leaves", + "trunkleave": "oak_leaves", + "woodleave": "oak_leaves", + "leave": "oak_leaves", + "oaktreeleaves": "oak_leaves", + "oaklogleaves": "oak_leaves", + "oaktrunkleaves": "oak_leaves", + "oakwoodleaves": "oak_leaves", + "oaktreeleaf": "oak_leaves", + "oaklogleaf": "oak_leaves", + "oaktrunkleaf": "oak_leaves", + "oakwoodleaf": "oak_leaves", + "oakleaf": "oak_leaves", + "oaktreeleave": "oak_leaves", + "oaklogleave": "oak_leaves", + "oaktrunkleave": "oak_leaves", + "oakwoodleave": "oak_leaves", + "oakleave": "oak_leaves", + "otreeleaves": "oak_leaves", + "ologleaves": "oak_leaves", + "otrunkleaves": "oak_leaves", + "owoodleaves": "oak_leaves", + "oleaves": "oak_leaves", + "otreeleaf": "oak_leaves", + "ologleaf": "oak_leaves", + "otrunkleaf": "oak_leaves", + "owoodleaf": "oak_leaves", + "oleaf": "oak_leaves", + "otreeleave": "oak_leaves", + "ologleave": "oak_leaves", + "otrunkleave": "oak_leaves", + "owoodleave": "oak_leaves", + "oleave": "oak_leaves", + "oak_log": { + "material": "OAK_LOG" + }, + "oaklog": "stripped_oak_log", + "": "stripped_oak_log", + "log": "stripped_oak_log", + "trunk": "stripped_oak_log", + "tree": "stripped_oak_log", + "oak": "stripped_oak_log", + "logoak": "stripped_oak_log", + "oaktrunk": "stripped_oak_log", + "oaktree": "stripped_oak_log", + "o": "stripped_oak_log", + "logo": "stripped_oak_log", + "otrunk": "stripped_oak_log", + "olog": "stripped_oak_log", + "otree": "stripped_oak_log", + "oak_planks": { + "material": "OAK_PLANKS" + }, + "oakplanks": "oak_planks", + "woodenplank": "oak_planks", + "woodplank": "oak_planks", + "plankwooden": "oak_planks", + "plankwood": "oak_planks", + "plankw": "oak_planks", + "plank": "oak_planks", + "oakwoodenplank": "oak_planks", + "oakwoodplank": "oak_planks", + "oakwplank": "oak_planks", + "oakplankwooden": "oak_planks", + "oakplankwood": "oak_planks", + "oakplankw": "oak_planks", + "oakplank": "oak_planks", + "owoodenplank": "oak_planks", + "owoodplank": "oak_planks", + "owplank": "oak_planks", + "oplankwooden": "oak_planks", + "oplankwood": "oak_planks", + "oplankw": "oak_planks", + "oplank": "oak_planks", + "oak_pressure_plate": { + "material": "OAK_PRESSURE_PLATE" + }, + "oakpressureplate": "oak_pressure_plate", + "oak_sapling": { + "material": "OAK_SAPLING" + }, + "oaksapling": "potted_oak_sapling", + "sapling": "potted_oak_sapling", + "treesapling": "potted_oak_sapling", + "logsapling": "potted_oak_sapling", + "trunksapling": "potted_oak_sapling", + "woodsapling": "potted_oak_sapling", + "oaktreesapling": "potted_oak_sapling", + "oaklogsapling": "potted_oak_sapling", + "oaktrunksapling": "potted_oak_sapling", + "oakwoodsapling": "potted_oak_sapling", + "osapling": "potted_oak_sapling", + "otreesapling": "potted_oak_sapling", + "ologsapling": "potted_oak_sapling", + "otrunksapling": "potted_oak_sapling", + "owoodsapling": "potted_oak_sapling", + "oak_slab": { + "material": "OAK_SLAB" + }, + "oakslab": "oak_slab", + "woodenstep": "petrified_oak_slab", + "woodstep": "petrified_oak_slab", + "step": "petrified_oak_slab", + "woodenslab": "petrified_oak_slab", + "woodslab": "petrified_oak_slab", + "wslab": "petrified_oak_slab", + "woodenhalfblock": "petrified_oak_slab", + "woodhalfblock": "petrified_oak_slab", + "halfblock": "petrified_oak_slab", + "oakwoodenstep": "petrified_oak_slab", + "oakwoodstep": "petrified_oak_slab", + "oakwstep": "petrified_oak_slab", + "oakstep": "petrified_oak_slab", + "oakwoodenslab": "petrified_oak_slab", + "oakwoodslab": "petrified_oak_slab", + "oakwslab": "petrified_oak_slab", + "oakwoodenhalfblock": "petrified_oak_slab", + "oakwoodhalfblock": "petrified_oak_slab", + "oakwhalfblock": "petrified_oak_slab", + "oakhalfblock": "petrified_oak_slab", + "owoodenstep": "petrified_oak_slab", + "owoodstep": "petrified_oak_slab", + "owstep": "petrified_oak_slab", + "ostep": "petrified_oak_slab", + "owoodenslab": "petrified_oak_slab", + "owoodslab": "petrified_oak_slab", + "owslab": "petrified_oak_slab", + "owoodenhalfblock": "petrified_oak_slab", + "owoodhalfblock": "petrified_oak_slab", + "owhalfblock": "petrified_oak_slab", + "ohalfblock": "petrified_oak_slab", + "oak_stairs": { + "material": "OAK_STAIRS" + }, + "oakstairs": "oak_stairs", + "woodenstairs": "oak_stairs", + "woodstairs": "oak_stairs", + "wstairs": "oak_stairs", + "woodenstair": "oak_stairs", + "woodstair": "oak_stairs", + "stair": "oak_stairs", + "oakwoodenstairs": "oak_stairs", + "oakwoodstairs": "oak_stairs", + "oakwstairs": "oak_stairs", + "oakwoodenstair": "oak_stairs", + "oakwoodstair": "oak_stairs", + "oakwstair": "oak_stairs", + "oakstair": "oak_stairs", + "owoodenstairs": "oak_stairs", + "owoodstairs": "oak_stairs", + "owstairs": "oak_stairs", + "owoodenstair": "oak_stairs", + "owoodstair": "oak_stairs", + "owstair": "oak_stairs", + "ostair": "oak_stairs", + "oak_trapdoor": { + "material": "OAK_TRAPDOOR" + }, + "oaktrapdoor": "oak_trapdoor", + "oak_wood": { + "material": "OAK_WOOD" + }, + "oakwood": "stripped_oak_wood", + "wood": "stripped_oak_wood", + "logall": "stripped_oak_wood", + "trunkall": "stripped_oak_wood", + "treeall": "stripped_oak_wood", + "oaklogall": "stripped_oak_wood", + "oaktrunkall": "stripped_oak_wood", + "oaktreeall": "stripped_oak_wood", + "owood": "stripped_oak_wood", + "ologall": "stripped_oak_wood", + "otrunkall": "stripped_oak_wood", + "otreeall": "stripped_oak_wood", + "observer": { + "material": "OBSERVER" + }, + "obsidian": { + "material": "OBSIDIAN" + }, + "ocelot_spawn_egg": { + "material": "OCELOT_SPAWN_EGG" + }, + "ocelotspawnegg": "ocelot_spawn_egg", + "orange_banner": { + "material": "ORANGE_BANNER" + }, + "orangebanner": "orange_banner", + "ostandingbanner": "orange_banner", + "obanner": "orange_banner", + "orangestandingbanner": "orange_banner", + "orange_bed": { + "material": "ORANGE_BED" + }, + "orangebed": "orange_bed", + "obed": "orange_bed", + "orange_carpet": { + "material": "ORANGE_CARPET" + }, + "orangecarpet": "orange_carpet", + "ocarpet": "orange_carpet", + "ofloor": "orange_carpet", + "orangefloor": "orange_carpet", + "orange_concrete": { + "material": "ORANGE_CONCRETE" + }, + "orangeconcrete": "orange_concrete", + "oconcrete": "orange_concrete", + "orange_concrete_powder": { + "material": "ORANGE_CONCRETE_POWDER" + }, + "orangeconcretepowder": "orange_concrete_powder", + "oconcretepowder": "orange_concrete_powder", + "oconcretesand": "orange_concrete_powder", + "orangeconcretesand": "orange_concrete_powder", + "orange_dye": { + "material": "ORANGE_DYE" + }, + "orangedye": "orange_dye", + "orange_glazed_terracotta": { + "material": "ORANGE_GLAZED_TERRACOTTA" + }, + "orangeglazedterracotta": "orange_glazed_terracotta", + "oglazedtcota": "orange_glazed_terracotta", + "oglazedterra": "orange_glazed_terracotta", + "oglazedterracotta": "orange_glazed_terracotta", + "oglazedterracota": "orange_glazed_terracotta", + "orangeglazedtcota": "orange_glazed_terracotta", + "orangeglazedterra": "orange_glazed_terracotta", + "orangeglazedterracota": "orange_glazed_terracotta", + "orange_shulker_box": { + "material": "ORANGE_SHULKER_BOX" + }, + "orangeshulkerbox": "orange_shulker_box", + "oshulkerbox": "orange_shulker_box", + "ochest": "orange_shulker_box", + "orangechest": "orange_shulker_box", + "orange_stained_glass": { + "material": "ORANGE_STAINED_GLASS" + }, + "orangestainedglass": "orange_stained_glass", + "oglass": "orange_stained_glass", + "osglass": "orange_stained_glass", + "ostainedglass": "orange_stained_glass", + "orangeglass": "orange_stained_glass", + "orangesglass": "orange_stained_glass", + "orange_stained_glass_pane": { + "material": "ORANGE_STAINED_GLASS_PANE" + }, + "orangestainedglasspane": "orange_stained_glass_pane", + "oglasspane": "orange_stained_glass_pane", + "osglasspane": "orange_stained_glass_pane", + "ostainedglasspane": "orange_stained_glass_pane", + "orangeglasspane": "orange_stained_glass_pane", + "orangesglasspane": "orange_stained_glass_pane", + "orange_terracotta": { + "material": "ORANGE_TERRACOTTA" + }, + "orangeterracotta": "orange_terracotta", + "oclay": "orange_terracotta", + "osclay": "orange_terracotta", + "ostainedclay": "orange_terracotta", + "oterra": "orange_terracotta", + "otcota": "orange_terracotta", + "oterracota": "orange_terracotta", + "oterracotta": "orange_terracotta", + "orangeclay": "orange_terracotta", + "orangesclay": "orange_terracotta", + "orangestainedclay": "orange_terracotta", + "orangeterra": "orange_terracotta", + "orangetcota": "orange_terracotta", + "orangeterracota": "orange_terracotta", + "orange_tulip": { + "material": "ORANGE_TULIP" + }, + "orangetulip": "orange_tulip", + "orange_wall_banner": { + "material": "ORANGE_WALL_BANNER" + }, + "orangewallbanner": "orange_wall_banner", + "owallbanner": "orange_wall_banner", + "orange_wool": { + "material": "ORANGE_WOOL" + }, + "orangewool": "orange_wool", + "owool": "orange_wool", + "ocloth": "orange_wool", + "ocotton": "orange_wool", + "orangecloth": "orange_wool", + "orangecotton": "orange_wool", + "oxeye_daisy": { + "material": "OXEYE_DAISY" + }, + "oxeyedaisy": "oxeye_daisy", + "packed_ice": { + "material": "PACKED_ICE" + }, + "packedice": "packed_ice", + "painting": { + "material": "PAINTING" + }, + "paper": { + "material": "PAPER" + }, + "parrot_spawn_egg": { + "material": "PARROT_SPAWN_EGG" + }, + "parrotspawnegg": "parrot_spawn_egg", + "peony": { + "material": "PEONY" + }, + "petrified_oak_slab": { + "material": "PETRIFIED_OAK_SLAB" + }, + "petrifiedoakslab": "petrified_oak_slab", + "phantom_membrane": { + "material": "PHANTOM_MEMBRANE" + }, + "phantommembrane": "phantom_membrane", + "phantom_spawn_egg": { + "material": "PHANTOM_SPAWN_EGG" + }, + "phantomspawnegg": "phantom_spawn_egg", + "pig_spawn_egg": { + "material": "PIG_SPAWN_EGG" + }, + "pigspawnegg": "pig_spawn_egg", + "pink_banner": { + "material": "PINK_BANNER" + }, + "pinkbanner": "pink_banner", + "pistandingbanner": "pink_banner", + "pibanner": "pink_banner", + "pinkstandingbanner": "pink_banner", + "pink_bed": { + "material": "PINK_BED" + }, + "pinkbed": "pink_bed", + "pibed": "pink_bed", + "pink_carpet": { + "material": "PINK_CARPET" + }, + "pinkcarpet": "pink_carpet", + "picarpet": "pink_carpet", + "pifloor": "pink_carpet", + "pinkfloor": "pink_carpet", + "pink_concrete": { + "material": "PINK_CONCRETE" + }, + "pinkconcrete": "pink_concrete", + "piconcrete": "pink_concrete", + "pink_concrete_powder": { + "material": "PINK_CONCRETE_POWDER" + }, + "pinkconcretepowder": "pink_concrete_powder", + "piconcretepowder": "pink_concrete_powder", + "piconcretesand": "pink_concrete_powder", + "pinkconcretesand": "pink_concrete_powder", + "pink_dye": { + "material": "PINK_DYE" + }, + "pinkdye": "pink_dye", + "pink_glazed_terracotta": { + "material": "PINK_GLAZED_TERRACOTTA" + }, + "pinkglazedterracotta": "pink_glazed_terracotta", + "piglazedtcota": "pink_glazed_terracotta", + "piglazedterra": "pink_glazed_terracotta", + "piglazedterracotta": "pink_glazed_terracotta", + "piglazedterracota": "pink_glazed_terracotta", + "pinkglazedtcota": "pink_glazed_terracotta", + "pinkglazedterra": "pink_glazed_terracotta", + "pinkglazedterracota": "pink_glazed_terracotta", + "pink_shulker_box": { + "material": "PINK_SHULKER_BOX" + }, + "pinkshulkerbox": "pink_shulker_box", + "pishulkerbox": "pink_shulker_box", + "pichest": "pink_shulker_box", + "pinkchest": "pink_shulker_box", + "pink_stained_glass": { + "material": "PINK_STAINED_GLASS" + }, + "pinkstainedglass": "pink_stained_glass", + "piglass": "pink_stained_glass", + "pisglass": "pink_stained_glass", + "pistainedglass": "pink_stained_glass", + "pinkglass": "pink_stained_glass", + "pinksglass": "pink_stained_glass", + "pink_stained_glass_pane": { + "material": "PINK_STAINED_GLASS_PANE" + }, + "pinkstainedglasspane": "pink_stained_glass_pane", + "piglasspane": "pink_stained_glass_pane", + "pisglasspane": "pink_stained_glass_pane", + "pistainedglasspane": "pink_stained_glass_pane", + "pinkglasspane": "pink_stained_glass_pane", + "pinksglasspane": "pink_stained_glass_pane", + "pink_terracotta": { + "material": "PINK_TERRACOTTA" + }, + "pinkterracotta": "pink_terracotta", + "piclay": "pink_terracotta", + "pisclay": "pink_terracotta", + "pistainedclay": "pink_terracotta", + "piterra": "pink_terracotta", + "pitcota": "pink_terracotta", + "piterracota": "pink_terracotta", + "piterracotta": "pink_terracotta", + "pinkclay": "pink_terracotta", + "pinksclay": "pink_terracotta", + "pinkstainedclay": "pink_terracotta", + "pinkterra": "pink_terracotta", + "pinktcota": "pink_terracotta", + "pinkterracota": "pink_terracotta", + "pink_tulip": { + "material": "PINK_TULIP" + }, + "pinktulip": "pink_tulip", + "pink_wall_banner": { + "material": "PINK_WALL_BANNER" + }, + "pinkwallbanner": "pink_wall_banner", + "piwallbanner": "pink_wall_banner", + "pink_wool": { + "material": "PINK_WOOL" + }, + "pinkwool": "pink_wool", + "piwool": "pink_wool", + "picloth": "pink_wool", + "picotton": "pink_wool", + "pinkcloth": "pink_wool", + "pinkcotton": "pink_wool", + "piston": { + "material": "PISTON" + }, + "piston_head": { + "material": "PISTON_HEAD" + }, + "pistonhead": "piston_head", + "player_head": { + "material": "PLAYER_HEAD" + }, + "playerhead": "player_head", + "player_wall_head": { + "material": "PLAYER_WALL_HEAD" + }, + "playerwallhead": "player_wall_head", + "podzol": { + "material": "PODZOL" + }, + "poisonous_potato": { + "material": "POISONOUS_POTATO" + }, + "poisonouspotato": "poisonous_potato", + "polar_bear_spawn_egg": { + "material": "POLAR_BEAR_SPAWN_EGG" + }, + "polarbearspawnegg": "polar_bear_spawn_egg", + "polished_andesite": { + "material": "POLISHED_ANDESITE" + }, + "polishedandesite": "polished_andesite", + "pandesite": "polished_andesite", + "pastone": "polished_andesite", + "polishedastone": "polished_andesite", + "polished_diorite": { + "material": "POLISHED_DIORITE" + }, + "polisheddiorite": "polished_diorite", + "pdiorite": "polished_diorite", + "pdstone": "polished_diorite", + "polisheddstone": "polished_diorite", + "polished_granite": { + "material": "POLISHED_GRANITE" + }, + "polishedgranite": "polished_granite", + "pgranite": "polished_granite", + "pgstone": "polished_granite", + "polishedgstone": "polished_granite", + "popped_chorus_fruit": { + "material": "POPPED_CHORUS_FRUIT" + }, + "poppedchorusfruit": "popped_chorus_fruit", + "poppy": { + "material": "POPPY" + }, + "porkchop": { + "material": "PORKCHOP" + }, + "potato": { + "material": "POTATO" + }, + "potatoes": { + "material": "POTATOES" + }, + "potion": { + "material": "POTION" + }, + "potted_acacia_sapling": { + "material": "POTTED_ACACIA_SAPLING" + }, + "pottedacaciasapling": "potted_acacia_sapling", + "potted_allium": { + "material": "POTTED_ALLIUM" + }, + "pottedallium": "potted_allium", + "potted_azure_bluet": { + "material": "POTTED_AZURE_BLUET" + }, + "pottedazurebluet": "potted_azure_bluet", + "potted_birch_sapling": { + "material": "POTTED_BIRCH_SAPLING" + }, + "pottedbirchsapling": "potted_birch_sapling", + "potted_blue_orchid": { + "material": "POTTED_BLUE_ORCHID" + }, + "pottedblueorchid": "potted_blue_orchid", + "potted_brown_mushroom": { + "material": "POTTED_BROWN_MUSHROOM" + }, + "pottedbrownmushroom": "potted_brown_mushroom", + "potted_cactus": { + "material": "POTTED_CACTUS" + }, + "pottedcactus": "potted_cactus", + "potted_dandelion": { + "material": "POTTED_DANDELION" + }, + "potteddandelion": "potted_dandelion", + "potted_dark_oak_sapling": { + "material": "POTTED_DARK_OAK_SAPLING" + }, + "potteddarkoaksapling": "potted_dark_oak_sapling", + "potted_dead_bush": { + "material": "POTTED_DEAD_BUSH" + }, + "potteddeadbush": "potted_dead_bush", + "potted_fern": { + "material": "POTTED_FERN" + }, + "pottedfern": "potted_fern", + "potted_jungle_sapling": { + "material": "POTTED_JUNGLE_SAPLING" + }, + "pottedjunglesapling": "potted_jungle_sapling", + "potted_oak_sapling": { + "material": "POTTED_OAK_SAPLING" + }, + "pottedoaksapling": "potted_oak_sapling", + "potted_orange_tulip": { + "material": "POTTED_ORANGE_TULIP" + }, + "pottedorangetulip": "potted_orange_tulip", + "potted_oxeye_daisy": { + "material": "POTTED_OXEYE_DAISY" + }, + "pottedoxeyedaisy": "potted_oxeye_daisy", + "potted_pink_tulip": { + "material": "POTTED_PINK_TULIP" + }, + "pottedpinktulip": "potted_pink_tulip", + "potted_poppy": { + "material": "POTTED_POPPY" + }, + "pottedpoppy": "potted_poppy", + "potted_red_mushroom": { + "material": "POTTED_RED_MUSHROOM" + }, + "pottedredmushroom": "potted_red_mushroom", + "redmushroom": "red_mushroom", + "redmush": "red_mushroom", + "redshroom": "red_mushroom", + "rmushroom": "red_mushroom", + "rmush": "red_mushroom", + "rshroom": "red_mushroom", + "potted_red_tulip": { + "material": "POTTED_RED_TULIP" + }, + "pottedredtulip": "potted_red_tulip", + "potted_spruce_sapling": { + "material": "POTTED_SPRUCE_SAPLING" + }, + "pottedsprucesapling": "potted_spruce_sapling", + "pinesapling": "spruce_sapling", + "pinetreesapling": "spruce_sapling", + "pinelogsapling": "spruce_sapling", + "pinetrunksapling": "spruce_sapling", + "pinewoodsapling": "spruce_sapling", + "psapling": "spruce_sapling", + "ptreesapling": "spruce_sapling", + "plogsapling": "spruce_sapling", + "ptrunksapling": "spruce_sapling", + "pwoodsapling": "spruce_sapling", + "darksapling": "spruce_sapling", + "darktreesapling": "spruce_sapling", + "darklogsapling": "spruce_sapling", + "darktrunksapling": "spruce_sapling", + "darkwoodsapling": "spruce_sapling", + "dsapling": "spruce_sapling", + "dtreesapling": "spruce_sapling", + "dlogsapling": "spruce_sapling", + "dtrunksapling": "spruce_sapling", + "dwoodsapling": "spruce_sapling", + "sprucesapling": "spruce_sapling", + "sprucetreesapling": "spruce_sapling", + "sprucelogsapling": "spruce_sapling", + "sprucetrunksapling": "spruce_sapling", + "sprucewoodsapling": "spruce_sapling", + "ssapling": "spruce_sapling", + "streesapling": "spruce_sapling", + "slogsapling": "spruce_sapling", + "strunksapling": "spruce_sapling", + "swoodsapling": "spruce_sapling", + "potted_white_tulip": { + "material": "POTTED_WHITE_TULIP" + }, + "pottedwhitetulip": "potted_white_tulip", + "powered_rail": { + "material": "POWERED_RAIL" + }, + "poweredrail": "powered_rail", + "poweredrails": "powered_rail", + "poweredtrack": "powered_rail", + "boosterrails": "powered_rail", + "boosterrail": "powered_rail", + "boostertrack": "powered_rail", + "powerrails": "powered_rail", + "powerrail": "powered_rail", + "powertrack": "powered_rail", + "boostrails": "powered_rail", + "boostrail": "powered_rail", + "boosttrack": "powered_rail", + "prails": "powered_rail", + "prail": "powered_rail", + "ptrack": "powered_rail", + "brails": "powered_rail", + "brail": "powered_rail", + "btrack": "powered_rail", + "prismarine": { + "material": "PRISMARINE" + }, + "prismarine_bricks": { + "material": "PRISMARINE_BRICKS" + }, + "prismarinebricks": "prismarine_bricks", + "prismarine_brick_slab": { + "material": "PRISMARINE_BRICK_SLAB" + }, + "prismarinebrickslab": "prismarine_brick_slab", + "prismarine_brick_stairs": { + "material": "PRISMARINE_BRICK_STAIRS" + }, + "prismarinebrickstairs": "prismarine_brick_stairs", + "prismarine_crystals": { + "material": "PRISMARINE_CRYSTALS" + }, + "prismarinecrystals": "prismarine_crystals", + "prismarine_shard": { + "material": "PRISMARINE_SHARD" + }, + "prismarineshard": "prismarine_shard", + "prismarine_slab": { + "material": "PRISMARINE_SLAB" + }, + "prismarineslab": "prismarine_slab", + "prismarine_stairs": { + "material": "PRISMARINE_STAIRS" + }, + "prismarinestairs": "prismarine_stairs", + "pufferfish": { + "material": "PUFFERFISH" + }, + "pufferfish_bucket": { + "material": "PUFFERFISH_BUCKET" + }, + "pufferfishbucket": "pufferfish_bucket", + "pufferfish_spawn_egg": { + "material": "PUFFERFISH_SPAWN_EGG" + }, + "pufferfishspawnegg": "pufferfish_spawn_egg", + "pumpkin": { + "material": "PUMPKIN" + }, + "pumpkin_pie": { + "material": "PUMPKIN_PIE" + }, + "pumpkinpie": "pumpkin_pie", + "pumpkin_seeds": { + "material": "PUMPKIN_SEEDS" + }, + "pumpkinseeds": "pumpkin_seeds", + "pumpkin_stem": { + "material": "PUMPKIN_STEM" + }, + "pumpkinstem": "pumpkin_stem", + "purple_banner": { + "material": "PURPLE_BANNER" + }, + "purplebanner": "purple_banner", + "pustandingbanner": "purple_banner", + "pubanner": "purple_banner", + "purplestandingbanner": "purple_banner", + "purple_bed": { + "material": "PURPLE_BED" + }, + "purplebed": "purple_bed", + "pubed": "purple_bed", + "purple_carpet": { + "material": "PURPLE_CARPET" + }, + "purplecarpet": "purple_carpet", + "pucarpet": "purple_carpet", + "pufloor": "purple_carpet", + "purplefloor": "purple_carpet", + "purple_concrete": { + "material": "PURPLE_CONCRETE" + }, + "purpleconcrete": "purple_concrete", + "puconcrete": "purple_concrete", + "purple_concrete_powder": { + "material": "PURPLE_CONCRETE_POWDER" + }, + "purpleconcretepowder": "purple_concrete_powder", + "puconcretepowder": "purple_concrete_powder", + "puconcretesand": "purple_concrete_powder", + "purpleconcretesand": "purple_concrete_powder", + "purple_dye": { + "material": "PURPLE_DYE" + }, + "purpledye": "purple_dye", + "purple_glazed_terracotta": { + "material": "PURPLE_GLAZED_TERRACOTTA" + }, + "purpleglazedterracotta": "purple_glazed_terracotta", + "puglazedtcota": "purple_glazed_terracotta", + "puglazedterra": "purple_glazed_terracotta", + "puglazedterracotta": "purple_glazed_terracotta", + "puglazedterracota": "purple_glazed_terracotta", + "purpleglazedtcota": "purple_glazed_terracotta", + "purpleglazedterra": "purple_glazed_terracotta", + "purpleglazedterracota": "purple_glazed_terracotta", + "purple_shulker_box": { + "material": "PURPLE_SHULKER_BOX" + }, + "purpleshulkerbox": "purple_shulker_box", + "pushulkerbox": "purple_shulker_box", + "puchest": "purple_shulker_box", + "purplechest": "purple_shulker_box", + "purple_stained_glass": { + "material": "PURPLE_STAINED_GLASS" + }, + "purplestainedglass": "purple_stained_glass", + "puglass": "purple_stained_glass", + "pusglass": "purple_stained_glass", + "pustainedglass": "purple_stained_glass", + "purpleglass": "purple_stained_glass", + "purplesglass": "purple_stained_glass", + "purple_stained_glass_pane": { + "material": "PURPLE_STAINED_GLASS_PANE" + }, + "purplestainedglasspane": "purple_stained_glass_pane", + "puglasspane": "purple_stained_glass_pane", + "pusglasspane": "purple_stained_glass_pane", + "pustainedglasspane": "purple_stained_glass_pane", + "purpleglasspane": "purple_stained_glass_pane", + "purplesglasspane": "purple_stained_glass_pane", + "purple_terracotta": { + "material": "PURPLE_TERRACOTTA" + }, + "purpleterracotta": "purple_terracotta", + "puclay": "purple_terracotta", + "pusclay": "purple_terracotta", + "pustainedclay": "purple_terracotta", + "puterra": "purple_terracotta", + "putcota": "purple_terracotta", + "puterracota": "purple_terracotta", + "puterracotta": "purple_terracotta", + "purpleclay": "purple_terracotta", + "purplesclay": "purple_terracotta", + "purplestainedclay": "purple_terracotta", + "purpleterra": "purple_terracotta", + "purpletcota": "purple_terracotta", + "purpleterracota": "purple_terracotta", + "purple_wall_banner": { + "material": "PURPLE_WALL_BANNER" + }, + "purplewallbanner": "purple_wall_banner", + "puwallbanner": "purple_wall_banner", + "purple_wool": { + "material": "PURPLE_WOOL" + }, + "purplewool": "purple_wool", + "puwool": "purple_wool", + "pucloth": "purple_wool", + "pucotton": "purple_wool", + "purplecloth": "purple_wool", + "purplecotton": "purple_wool", + "purpur_block": { + "material": "PURPUR_BLOCK" + }, + "purpurblock": "purpur_block", + "purpur_pillar": { + "material": "PURPUR_PILLAR" + }, + "purpurpillar": "purpur_pillar", + "purpur_slab": { + "material": "PURPUR_SLAB" + }, + "purpurslab": "purpur_slab", + "purpur_stairs": { + "material": "PURPUR_STAIRS" + }, + "purpurstairs": "purpur_stairs", + "quartz": { + "material": "QUARTZ" + }, + "quartz_block": { + "material": "QUARTZ_BLOCK" + }, + "quartzblock": "quartz_block", + "quartz_pillar": { + "material": "QUARTZ_PILLAR" + }, + "quartzpillar": "quartz_pillar", + "quartz_slab": { + "material": "QUARTZ_SLAB" + }, + "quartzslab": "quartz_slab", + "quartz_stairs": { + "material": "QUARTZ_STAIRS" + }, + "quartzstairs": "quartz_stairs", + "rabbit": { + "material": "RABBIT" + }, + "rabbit_foot": { + "material": "RABBIT_FOOT" + }, + "rabbitfoot": "rabbit_foot", + "rabbit_hide": { + "material": "RABBIT_HIDE" + }, + "rabbithide": "rabbit_hide", + "rabbit_spawn_egg": { + "material": "RABBIT_SPAWN_EGG" + }, + "rabbitspawnegg": "rabbit_spawn_egg", + "rabbit_stew": { + "material": "RABBIT_STEW" + }, + "rabbitstew": "rabbit_stew", + "rail": { + "material": "RAIL" + }, + "rails": "rail", + "track": "rail", + "minecartrails": "rail", + "minecartrail": "rail", + "minecarttrack": "rail", + "mcartrails": "rail", + "mcartrail": "rail", + "mcarttrack": "rail", + "mcrails": "rail", + "mcrail": "rail", + "mctrack": "rail", + "redstone": { + "material": "REDSTONE" + }, + "redstone_block": { + "material": "REDSTONE_BLOCK" + }, + "redstoneblock": "redstone_block", + "blockredstone": "redstone_block", + "redsblock": "redstone_block", + "blockreds": "redstone_block", + "redblock": "redstone_block", + "blockred": "redstone_block", + "rstoneblock": "redstone_block", + "blockrstone": "redstone_block", + "rsblock": "redstone_block", + "blockrs": "redstone_block", + "rblock": "redstone_block", + "blockr": "redstone_block", + "redstone_lamp": { + "material": "REDSTONE_LAMP" + }, + "redstonelamp": "redstone_lamp", + "redstone_ore": { + "material": "REDSTONE_ORE" + }, + "redstoneore": "redstone_ore", + "redstoneo": "redstone_ore", + "oreredstone": "redstone_ore", + "oredstone": "redstone_ore", + "redsore": "redstone_ore", + "redso": "redstone_ore", + "orereds": "redstone_ore", + "oreds": "redstone_ore", + "redore": "redstone_ore", + "redo": "redstone_ore", + "orered": "redstone_ore", + "rstoneore": "redstone_ore", + "rstoneo": "redstone_ore", + "orerstone": "redstone_ore", + "orstone": "redstone_ore", + "rsore": "redstone_ore", + "rso": "redstone_ore", + "orers": "redstone_ore", + "ors": "redstone_ore", + "rore": "redstone_ore", + "ro": "redstone_ore", + "orer": "redstone_ore", + "or": "redstone_ore", + "redstone_torch": { + "material": "REDSTONE_TORCH" + }, + "redstonetorch": "redstone_torch", + "rstonetorch": "redstone_torch", + "redstorch": "redstone_torch", + "redtorch": "redstone_torch", + "rstorch": "redstone_torch", + "redstone_wall_torch": { + "material": "REDSTONE_WALL_TORCH" + }, + "redstonewalltorch": "redstone_wall_torch", + "redstone_wire": { + "material": "REDSTONE_WIRE" + }, + "redstonewire": "redstone_wire", + "red_banner": { + "material": "RED_BANNER" + }, + "redbanner": "red_banner", + "rstandingbanner": "red_banner", + "rbanner": "red_banner", + "redstandingbanner": "red_banner", + "red_bed": { + "material": "RED_BED" + }, + "redbed": "red_bed", + "rbed": "red_bed", + "red_carpet": { + "material": "RED_CARPET" + }, + "redcarpet": "red_carpet", + "rcarpet": "red_carpet", + "rfloor": "red_carpet", + "redfloor": "red_carpet", + "red_concrete": { + "material": "RED_CONCRETE" + }, + "redconcrete": "red_concrete", + "rconcrete": "red_concrete", + "red_concrete_powder": { + "material": "RED_CONCRETE_POWDER" + }, + "redconcretepowder": "red_concrete_powder", + "rconcretepowder": "red_concrete_powder", + "rconcretesand": "red_concrete_powder", + "redconcretesand": "red_concrete_powder", + "red_glazed_terracotta": { + "material": "RED_GLAZED_TERRACOTTA" + }, + "redglazedterracotta": "red_glazed_terracotta", + "rglazedtcota": "red_glazed_terracotta", + "rglazedterra": "red_glazed_terracotta", + "rglazedterracotta": "red_glazed_terracotta", + "rglazedterracota": "red_glazed_terracotta", + "redglazedtcota": "red_glazed_terracotta", + "redglazedterra": "red_glazed_terracotta", + "redglazedterracota": "red_glazed_terracotta", + "red_mushroom": { + "material": "RED_MUSHROOM" + }, + "red_mushroom_block": { + "material": "RED_MUSHROOM_BLOCK" + }, + "redmushroomblock": "red_mushroom_block", + "giantredmushroom": "red_mushroom_block", + "giantredmush": "red_mushroom_block", + "gredmushroom": "red_mushroom_block", + "gredmush": "red_mushroom_block", + "hugeredmushroom": "red_mushroom_block", + "hugeredmush": "red_mushroom_block", + "hredmushroom": "red_mushroom_block", + "hredmush": "red_mushroom_block", + "bigredmushroom": "red_mushroom_block", + "bigredmush": "red_mushroom_block", + "bredmushroom": "red_mushroom_block", + "bredmush": "red_mushroom_block", + "giantrmushroom": "red_mushroom_block", + "giantrmush": "red_mushroom_block", + "grmushroom": "red_mushroom_block", + "grmush": "red_mushroom_block", + "hugermushroom": "red_mushroom_block", + "hugermush": "red_mushroom_block", + "hrmushroom": "red_mushroom_block", + "hrmush": "red_mushroom_block", + "bigrmushroom": "red_mushroom_block", + "bigrmush": "red_mushroom_block", + "brmushroom": "red_mushroom_block", + "brmush": "red_mushroom_block", + "red_nether_bricks": { + "material": "RED_NETHER_BRICKS" + }, + "rednetherbricks": "red_nether_bricks", + "red_sand": { + "material": "RED_SAND" + }, + "redsand": "red_sand", + "rsand": "red_sand", + "red_sandstone": { + "material": "RED_SANDSTONE" + }, + "redsandstone": "red_sandstone", + "rsstone": "red_sandstone", + "red_sandstone_slab": { + "material": "RED_SANDSTONE_SLAB" + }, + "redsandstoneslab": "red_sandstone_slab", + "red_sandstone_stairs": { + "material": "RED_SANDSTONE_STAIRS" + }, + "redsandstonestairs": "red_sandstone_stairs", + "red_shulker_box": { + "material": "RED_SHULKER_BOX" + }, + "redshulkerbox": "red_shulker_box", + "rshulkerbox": "red_shulker_box", + "rchest": "red_shulker_box", + "redchest": "red_shulker_box", + "red_stained_glass": { + "material": "RED_STAINED_GLASS" + }, + "redstainedglass": "red_stained_glass", + "rglass": "red_stained_glass", + "rsglass": "red_stained_glass", + "rstainedglass": "red_stained_glass", + "redglass": "red_stained_glass", + "redsglass": "red_stained_glass", + "red_stained_glass_pane": { + "material": "RED_STAINED_GLASS_PANE" + }, + "redstainedglasspane": "red_stained_glass_pane", + "rglasspane": "red_stained_glass_pane", + "rsglasspane": "red_stained_glass_pane", + "rstainedglasspane": "red_stained_glass_pane", + "redglasspane": "red_stained_glass_pane", + "redsglasspane": "red_stained_glass_pane", + "red_terracotta": { + "material": "RED_TERRACOTTA" + }, + "redterracotta": "red_terracotta", + "rclay": "red_terracotta", + "rsclay": "red_terracotta", + "rstainedclay": "red_terracotta", + "rterra": "red_terracotta", + "rtcota": "red_terracotta", + "rterracota": "red_terracotta", + "rterracotta": "red_terracotta", + "redclay": "red_terracotta", + "redsclay": "red_terracotta", + "redstainedclay": "red_terracotta", + "redterra": "red_terracotta", + "redtcota": "red_terracotta", + "redterracota": "red_terracotta", + "red_tulip": { + "material": "RED_TULIP" + }, + "redtulip": "red_tulip", + "red_wall_banner": { + "material": "RED_WALL_BANNER" + }, + "redwallbanner": "red_wall_banner", + "rwallbanner": "red_wall_banner", + "red_wool": { + "material": "RED_WOOL" + }, + "redwool": "red_wool", + "rwool": "red_wool", + "rcloth": "red_wool", + "rcotton": "red_wool", + "redcloth": "red_wool", + "redcotton": "red_wool", + "repeater": { + "material": "REPEATER" + }, + "repeating_command_block": { + "material": "REPEATING_COMMAND_BLOCK" + }, + "repeatingcommandblock": "repeating_command_block", + "rose_bush": { + "material": "ROSE_BUSH" + }, + "rosebush": "rose_bush", + "rose_red": { + "material": "ROSE_RED" + }, + "rosered": "rose_red", + "rotten_flesh": { + "material": "ROTTEN_FLESH" + }, + "rottenflesh": "rotten_flesh", + "saddle": { + "material": "SADDLE" + }, + "salmon": { + "material": "SALMON" + }, + "salmon_bucket": { + "material": "SALMON_BUCKET" + }, + "salmonbucket": "salmon_bucket", + "salmon_spawn_egg": { + "material": "SALMON_SPAWN_EGG" + }, + "salmonspawnegg": "salmon_spawn_egg", + "sand": { + "material": "SAND" + }, + "sandstone": { + "material": "SANDSTONE" + }, + "sastone": "sandstone", + "sandstone_slab": { + "material": "SANDSTONE_SLAB" + }, + "sandstoneslab": "sandstone_slab", + "sandstone_stairs": { + "material": "SANDSTONE_STAIRS" + }, + "sandstonestairs": "sandstone_stairs", + "scute": { + "material": "SCUTE" + }, + "seagrass": { + "material": "SEAGRASS" + }, + "sea_lantern": { + "material": "SEA_LANTERN" + }, + "sealantern": "sea_lantern", + "sea_pickle": { + "material": "SEA_PICKLE" + }, + "seapickle": "sea_pickle", + "shears": { + "material": "SHEARS" + }, + "sheep_spawn_egg": { + "material": "SHEEP_SPAWN_EGG" + }, + "sheepspawnegg": "sheep_spawn_egg", + "shield": { + "material": "SHIELD" + }, + "shulker_box": { + "material": "SHULKER_BOX" + }, + "shulkerbox": "white_shulker_box", + "shulker_shell": { + "material": "SHULKER_SHELL" + }, + "shulkershell": "shulker_shell", + "shulker_spawn_egg": { + "material": "SHULKER_SPAWN_EGG" + }, + "shulkerspawnegg": "shulker_spawn_egg", + "sign": { + "material": "SIGN" + }, + "silverfish_spawn_egg": { + "material": "SILVERFISH_SPAWN_EGG" + }, + "silverfishspawnegg": "silverfish_spawn_egg", + "skeleton_horse_spawn_egg": { + "material": "SKELETON_HORSE_SPAWN_EGG" + }, + "skeletonhorsespawnegg": "skeleton_horse_spawn_egg", + "skeleton_skull": { + "material": "SKELETON_SKULL" + }, + "skeletonskull": "skeleton_skull", + "skeleton_spawn_egg": { + "material": "SKELETON_SPAWN_EGG" + }, + "skeletonspawnegg": "skeleton_spawn_egg", + "skeleton_wall_skull": { + "material": "SKELETON_WALL_SKULL" + }, + "skeletonwallskull": "skeleton_wall_skull", + "slime_ball": { + "material": "SLIME_BALL" + }, + "slimeball": "slime_ball", + "slime_block": { + "material": "SLIME_BLOCK" + }, + "slimeblock": "slime_block", + "slime_spawn_egg": { + "material": "SLIME_SPAWN_EGG" + }, + "slimespawnegg": "slime_spawn_egg", + "smooth_quartz": { + "material": "SMOOTH_QUARTZ" + }, + "smoothquartz": "smooth_quartz", + "smooth_red_sandstone": { + "material": "SMOOTH_RED_SANDSTONE" + }, + "smooth_sandstone": { + "material": "SMOOTH_SANDSTONE" + }, + "smoothsandstone": "smooth_sandstone", + "smooth_stone": { + "material": "SMOOTH_STONE" + }, + "smoothstone": "stone", + "snow": { + "material": "SNOW" + }, + "snowball": { + "material": "SNOWBALL" + }, + "snow_block": { + "material": "SNOW_BLOCK" + }, + "snowblock": "snow_block", + "soul_sand": { + "material": "SOUL_SAND" + }, + "soulsand": "soul_sand", + "spawner": { + "material": "SPAWNER" + }, + "spectral_arrow": { + "material": "SPECTRAL_ARROW" + }, + "spectralarrow": "spectral_arrow", + "spider_eye": { + "material": "SPIDER_EYE" + }, + "spidereye": "spider_eye", + "spider_spawn_egg": { + "material": "SPIDER_SPAWN_EGG" + }, + "spiderspawnegg": "spider_spawn_egg", + "splash_potion": { + "material": "SPLASH_POTION" + }, + "splashpotion": "splash_potion", + "sponge": { + "material": "SPONGE" + }, + "spruce_boat": { + "material": "SPRUCE_BOAT" + }, + "spruceboat": "spruce_boat", + "pineboat": "spruce_boat", + "pboat": "spruce_boat", + "darkboat": "spruce_boat", + "dboat": "spruce_boat", + "sboat": "spruce_boat", + "spruce_button": { + "material": "SPRUCE_BUTTON" + }, + "sprucebutton": "spruce_button", + "spruce_door": { + "material": "SPRUCE_DOOR" + }, + "sprucedoor": "spruce_door", + "spruce_fence": { + "material": "SPRUCE_FENCE" + }, + "sprucefence": "spruce_fence", + "pinefence": "spruce_fence", + "pfence": "spruce_fence", + "darkfence": "spruce_fence", + "dfence": "spruce_fence", + "sfence": "spruce_fence", + "spruce_fence_gate": { + "material": "SPRUCE_FENCE_GATE" + }, + "sprucefencegate": "spruce_fence_gate", + "pinefencegate": "spruce_fence_gate", + "pinegate": "spruce_fence_gate", + "pfencegate": "spruce_fence_gate", + "pgate": "spruce_fence_gate", + "darkfencegate": "spruce_fence_gate", + "darkgate": "spruce_fence_gate", + "dfencegate": "spruce_fence_gate", + "dgate": "spruce_fence_gate", + "sprucegate": "spruce_fence_gate", + "sfencegate": "spruce_fence_gate", + "sgate": "spruce_fence_gate", + "spruce_leaves": { + "material": "SPRUCE_LEAVES" + }, + "spruceleaves": "spruce_leaves", + "pinetreeleaves": "spruce_leaves", + "pinelogleaves": "spruce_leaves", + "pinetrunkleaves": "spruce_leaves", + "pinewoodleaves": "spruce_leaves", + "pineleaves": "spruce_leaves", + "pinetreeleaf": "spruce_leaves", + "pinelogleaf": "spruce_leaves", + "pinetrunkleaf": "spruce_leaves", + "pinewoodleaf": "spruce_leaves", + "pineleaf": "spruce_leaves", + "pinetreeleave": "spruce_leaves", + "pinelogleave": "spruce_leaves", + "pinetrunkleave": "spruce_leaves", + "pinewoodleave": "spruce_leaves", + "pineleave": "spruce_leaves", + "ptreeleaves": "spruce_leaves", + "plogleaves": "spruce_leaves", + "ptrunkleaves": "spruce_leaves", + "pwoodleaves": "spruce_leaves", + "pleaves": "spruce_leaves", + "ptreeleaf": "spruce_leaves", + "plogleaf": "spruce_leaves", + "ptrunkleaf": "spruce_leaves", + "pwoodleaf": "spruce_leaves", + "pleaf": "spruce_leaves", + "ptreeleave": "spruce_leaves", + "plogleave": "spruce_leaves", + "ptrunkleave": "spruce_leaves", + "pwoodleave": "spruce_leaves", + "pleave": "spruce_leaves", + "darktreeleaves": "spruce_leaves", + "darklogleaves": "spruce_leaves", + "darktrunkleaves": "spruce_leaves", + "darkwoodleaves": "spruce_leaves", + "darkleaves": "spruce_leaves", + "darktreeleaf": "spruce_leaves", + "darklogleaf": "spruce_leaves", + "darktrunkleaf": "spruce_leaves", + "darkwoodleaf": "spruce_leaves", + "darkleaf": "spruce_leaves", + "darktreeleave": "spruce_leaves", + "darklogleave": "spruce_leaves", + "darktrunkleave": "spruce_leaves", + "darkwoodleave": "spruce_leaves", + "darkleave": "spruce_leaves", + "dtreeleaves": "spruce_leaves", + "dlogleaves": "spruce_leaves", + "dtrunkleaves": "spruce_leaves", + "dwoodleaves": "spruce_leaves", + "dleaves": "spruce_leaves", + "dtreeleaf": "spruce_leaves", + "dlogleaf": "spruce_leaves", + "dtrunkleaf": "spruce_leaves", + "dwoodleaf": "spruce_leaves", + "dleaf": "spruce_leaves", + "dtreeleave": "spruce_leaves", + "dlogleave": "spruce_leaves", + "dtrunkleave": "spruce_leaves", + "dwoodleave": "spruce_leaves", + "dleave": "spruce_leaves", + "sprucetreeleaves": "spruce_leaves", + "sprucelogleaves": "spruce_leaves", + "sprucetrunkleaves": "spruce_leaves", + "sprucewoodleaves": "spruce_leaves", + "sprucetreeleaf": "spruce_leaves", + "sprucelogleaf": "spruce_leaves", + "sprucetrunkleaf": "spruce_leaves", + "sprucewoodleaf": "spruce_leaves", + "spruceleaf": "spruce_leaves", + "sprucetreeleave": "spruce_leaves", + "sprucelogleave": "spruce_leaves", + "sprucetrunkleave": "spruce_leaves", + "sprucewoodleave": "spruce_leaves", + "spruceleave": "spruce_leaves", + "streeleaves": "spruce_leaves", + "slogleaves": "spruce_leaves", + "strunkleaves": "spruce_leaves", + "swoodleaves": "spruce_leaves", + "sleaves": "spruce_leaves", + "streeleaf": "spruce_leaves", + "slogleaf": "spruce_leaves", + "strunkleaf": "spruce_leaves", + "swoodleaf": "spruce_leaves", + "sleaf": "spruce_leaves", + "streeleave": "spruce_leaves", + "slogleave": "spruce_leaves", + "strunkleave": "spruce_leaves", + "swoodleave": "spruce_leaves", + "sleave": "spruce_leaves", + "spruce_log": { + "material": "SPRUCE_LOG" + }, + "sprucelog": "stripped_spruce_log", + "pine": "stripped_spruce_log", + "logpine": "stripped_spruce_log", + "pinetrunk": "stripped_spruce_log", + "pinelog": "stripped_spruce_log", + "pinetree": "stripped_spruce_log", + "p": "stripped_spruce_log", + "logp": "stripped_spruce_log", + "ptrunk": "stripped_spruce_log", + "plog": "stripped_spruce_log", + "ptree": "stripped_spruce_log", + "dark": "stripped_spruce_log", + "logdark": "stripped_spruce_log", + "darktrunk": "stripped_spruce_log", + "darklog": "stripped_spruce_log", + "darktree": "stripped_spruce_log", + "d": "stripped_spruce_log", + "logd": "stripped_spruce_log", + "dtrunk": "stripped_spruce_log", + "dlog": "stripped_spruce_log", + "dtree": "stripped_spruce_log", + "spruce": "stripped_spruce_log", + "logspruce": "stripped_spruce_log", + "sprucetrunk": "stripped_spruce_log", + "sprucetree": "stripped_spruce_log", + "s": "stripped_spruce_log", + "logs": "stripped_spruce_log", + "strunk": "stripped_spruce_log", + "slog": "stripped_spruce_log", + "stree": "stripped_spruce_log", + "spruce_planks": { + "material": "SPRUCE_PLANKS" + }, + "spruceplanks": "spruce_planks", + "pinewoodenplank": "spruce_planks", + "pinewoodplank": "spruce_planks", + "pinewplank": "spruce_planks", + "pineplankwooden": "spruce_planks", + "pineplankwood": "spruce_planks", + "pineplankw": "spruce_planks", + "pineplank": "spruce_planks", + "pwoodenplank": "spruce_planks", + "pwoodplank": "spruce_planks", + "pwplank": "spruce_planks", + "pplankwooden": "spruce_planks", + "pplankwood": "spruce_planks", + "pplankw": "spruce_planks", + "pplank": "spruce_planks", + "darkwoodenplank": "spruce_planks", + "darkwoodplank": "spruce_planks", + "darkwplank": "spruce_planks", + "darkplankwooden": "spruce_planks", + "darkplankwood": "spruce_planks", + "darkplankw": "spruce_planks", + "darkplank": "spruce_planks", + "dwoodenplank": "spruce_planks", + "dwoodplank": "spruce_planks", + "dwplank": "spruce_planks", + "dplankwooden": "spruce_planks", + "dplankwood": "spruce_planks", + "dplankw": "spruce_planks", + "dplank": "spruce_planks", + "sprucewoodenplank": "spruce_planks", + "sprucewoodplank": "spruce_planks", + "sprucewplank": "spruce_planks", + "spruceplankwooden": "spruce_planks", + "spruceplankwood": "spruce_planks", + "spruceplankw": "spruce_planks", + "spruceplank": "spruce_planks", + "swoodenplank": "spruce_planks", + "swoodplank": "spruce_planks", + "swplank": "spruce_planks", + "splankwooden": "spruce_planks", + "splankwood": "spruce_planks", + "splankw": "spruce_planks", + "splank": "spruce_planks", + "spruce_pressure_plate": { + "material": "SPRUCE_PRESSURE_PLATE" + }, + "sprucepressureplate": "spruce_pressure_plate", + "spruce_sapling": { + "material": "SPRUCE_SAPLING" + }, + "spruce_slab": { + "material": "SPRUCE_SLAB" + }, + "spruceslab": "spruce_slab", + "pinewoodenstep": "spruce_slab", + "pinewoodstep": "spruce_slab", + "pinewstep": "spruce_slab", + "pinestep": "spruce_slab", + "pinewoodenslab": "spruce_slab", + "pinewoodslab": "spruce_slab", + "pinewslab": "spruce_slab", + "pinewoodenhalfblock": "spruce_slab", + "pinewoodhalfblock": "spruce_slab", + "pinewhalfblock": "spruce_slab", + "pinehalfblock": "spruce_slab", + "pwoodenstep": "spruce_slab", + "pwoodstep": "spruce_slab", + "pwstep": "spruce_slab", + "pstep": "spruce_slab", + "pwoodenslab": "spruce_slab", + "pwoodslab": "spruce_slab", + "pwslab": "spruce_slab", + "pwoodenhalfblock": "spruce_slab", + "pwoodhalfblock": "spruce_slab", + "pwhalfblock": "spruce_slab", + "phalfblock": "spruce_slab", + "darkwoodenstep": "spruce_slab", + "darkwoodstep": "spruce_slab", + "darkwstep": "spruce_slab", + "darkstep": "spruce_slab", + "darkwoodenslab": "spruce_slab", + "darkwoodslab": "spruce_slab", + "darkwslab": "spruce_slab", + "darkwoodenhalfblock": "spruce_slab", + "darkwoodhalfblock": "spruce_slab", + "darkwhalfblock": "spruce_slab", + "darkhalfblock": "spruce_slab", + "dwoodenstep": "spruce_slab", + "dwoodstep": "spruce_slab", + "dwstep": "spruce_slab", + "dstep": "spruce_slab", + "dwoodenslab": "spruce_slab", + "dwoodslab": "spruce_slab", + "dwslab": "spruce_slab", + "dwoodenhalfblock": "spruce_slab", + "dwoodhalfblock": "spruce_slab", + "dwhalfblock": "spruce_slab", + "dhalfblock": "spruce_slab", + "sprucewoodenstep": "spruce_slab", + "sprucewoodstep": "spruce_slab", + "sprucewstep": "spruce_slab", + "sprucestep": "spruce_slab", + "sprucewoodenslab": "spruce_slab", + "sprucewoodslab": "spruce_slab", + "sprucewslab": "spruce_slab", + "sprucewoodenhalfblock": "spruce_slab", + "sprucewoodhalfblock": "spruce_slab", + "sprucewhalfblock": "spruce_slab", + "sprucehalfblock": "spruce_slab", + "swoodenstep": "spruce_slab", + "swoodstep": "spruce_slab", + "swstep": "spruce_slab", + "sstep": "spruce_slab", + "swoodenslab": "spruce_slab", + "swoodslab": "spruce_slab", + "swslab": "spruce_slab", + "swoodenhalfblock": "spruce_slab", + "swoodhalfblock": "spruce_slab", + "swhalfblock": "spruce_slab", + "shalfblock": "spruce_slab", + "spruce_stairs": { + "material": "SPRUCE_STAIRS" + }, + "sprucestairs": "spruce_stairs", + "pinewoodenstairs": "spruce_stairs", + "pinewoodstairs": "spruce_stairs", + "pinewstairs": "spruce_stairs", + "pinewoodenstair": "spruce_stairs", + "pinewoodstair": "spruce_stairs", + "pinewstair": "spruce_stairs", + "pinestair": "spruce_stairs", + "pwoodenstairs": "spruce_stairs", + "pwoodstairs": "spruce_stairs", + "pwstairs": "spruce_stairs", + "pwoodenstair": "spruce_stairs", + "pwoodstair": "spruce_stairs", + "pwstair": "spruce_stairs", + "pstair": "spruce_stairs", + "darkwoodenstairs": "spruce_stairs", + "darkwoodstairs": "spruce_stairs", + "darkwstairs": "spruce_stairs", + "darkwoodenstair": "spruce_stairs", + "darkwoodstair": "spruce_stairs", + "darkwstair": "spruce_stairs", + "darkstair": "spruce_stairs", + "dwoodenstairs": "spruce_stairs", + "dwoodstairs": "spruce_stairs", + "dwstairs": "spruce_stairs", + "dwoodenstair": "spruce_stairs", + "dwoodstair": "spruce_stairs", + "dwstair": "spruce_stairs", + "dstair": "spruce_stairs", + "sprucewoodenstairs": "spruce_stairs", + "sprucewoodstairs": "spruce_stairs", + "sprucewstairs": "spruce_stairs", + "sprucewoodenstair": "spruce_stairs", + "sprucewoodstair": "spruce_stairs", + "sprucewstair": "spruce_stairs", + "sprucestair": "spruce_stairs", + "swoodenstairs": "spruce_stairs", + "swoodstairs": "spruce_stairs", + "swstairs": "spruce_stairs", + "swoodenstair": "spruce_stairs", + "swoodstair": "spruce_stairs", + "swstair": "spruce_stairs", + "sstair": "spruce_stairs", + "spruce_trapdoor": { + "material": "SPRUCE_TRAPDOOR" + }, + "sprucetrapdoor": "spruce_trapdoor", + "spruce_wood": { + "material": "SPRUCE_WOOD" + }, + "sprucewood": "stripped_spruce_wood", + "pinewood": "stripped_spruce_wood", + "pinelogall": "stripped_spruce_wood", + "pinetrunkall": "stripped_spruce_wood", + "pinetreeall": "stripped_spruce_wood", + "pwood": "stripped_spruce_wood", + "plogall": "stripped_spruce_wood", + "ptrunkall": "stripped_spruce_wood", + "ptreeall": "stripped_spruce_wood", + "darkwood": "stripped_spruce_wood", + "darklogall": "stripped_spruce_wood", + "darktrunkall": "stripped_spruce_wood", + "darktreeall": "stripped_spruce_wood", + "dwood": "stripped_spruce_wood", + "dlogall": "stripped_spruce_wood", + "dtrunkall": "stripped_spruce_wood", + "dtreeall": "stripped_spruce_wood", + "sprucelogall": "stripped_spruce_wood", + "sprucetrunkall": "stripped_spruce_wood", + "sprucetreeall": "stripped_spruce_wood", + "swood": "stripped_spruce_wood", + "slogall": "stripped_spruce_wood", + "strunkall": "stripped_spruce_wood", + "streeall": "stripped_spruce_wood", + "squid_spawn_egg": { + "material": "SQUID_SPAWN_EGG" + }, + "squidspawnegg": "squid_spawn_egg", + "stick": { + "material": "STICK" + }, + "sticky_piston": { + "material": "STICKY_PISTON" + }, + "stickypiston": "sticky_piston", + "pistonsticky": "sticky_piston", + "stickyp": "sticky_piston", + "psticky": "sticky_piston", + "pistonstickybase": "sticky_piston", + "stickypistonbase": "sticky_piston", + "stickpiston": "sticky_piston", + "pistonstick": "sticky_piston", + "stickp": "sticky_piston", + "pstick": "sticky_piston", + "pistonstickbase": "sticky_piston", + "stickpistonbase": "sticky_piston", + "spiston": "sticky_piston", + "pistons": "sticky_piston", + "pistonsbase": "sticky_piston", + "spistonbase": "sticky_piston", + "stone": { + "material": "STONE" + }, + "sstone": "stone", + "rock": "stone", + "stone_axe": { + "material": "STONE_AXE" + }, + "stoneaxe": "stone_axe", + "cobblestoneaxe": "stone_axe", + "cstoneaxe": "stone_axe", + "csaxe": "stone_axe", + "stone_bricks": { + "material": "STONE_BRICKS" + }, + "stonebricks": "stone_bricks", + "stone_brick_slab": { + "material": "STONE_BRICK_SLAB" + }, + "stonebrickslab": "stone_brick_slab", + "stone_brick_stairs": { + "material": "STONE_BRICK_STAIRS" + }, + "stonebrickstairs": "stone_brick_stairs", + "stone_button": { + "material": "STONE_BUTTON" + }, + "stonebutton": "stone_button", + "smoothstonebutton": "stone_button", + "sstonebutton": "stone_button", + "sbutton": "stone_button", + "button": "stone_button", + "stone_hoe": { + "material": "STONE_HOE" + }, + "stonehoe": "stone_hoe", + "cobblestonehoe": "stone_hoe", + "cstonehoe": "stone_hoe", + "cshoe": "stone_hoe", + "stone_pickaxe": { + "material": "STONE_PICKAXE" + }, + "stonepickaxe": "stone_pickaxe", + "cobblestonepickaxe": "stone_pickaxe", + "cobblestonepick": "stone_pickaxe", + "cstonepickaxe": "stone_pickaxe", + "cstonepick": "stone_pickaxe", + "cspickaxe": "stone_pickaxe", + "cspick": "stone_pickaxe", + "stonepick": "stone_pickaxe", + "stone_pressure_plate": { + "material": "STONE_PRESSURE_PLATE" + }, + "stonepressureplate": "stone_pressure_plate", + "stonepressplate": "stone_pressure_plate", + "stonepplate": "stone_pressure_plate", + "stoneplate": "stone_pressure_plate", + "spressureplate": "stone_pressure_plate", + "spressplate": "stone_pressure_plate", + "spplate": "stone_pressure_plate", + "smoothstonepressueplate": "stone_pressure_plate", + "smoothstonepressplate": "stone_pressure_plate", + "smoothstonepplate": "stone_pressure_plate", + "smoothstoneplate": "stone_pressure_plate", + "sstonepressureplate": "stone_pressure_plate", + "sstonepressplate": "stone_pressure_plate", + "sstonepplate": "stone_pressure_plate", + "sstoneplate": "stone_pressure_plate", + "stone_shovel": { + "material": "STONE_SHOVEL" + }, + "stoneshovel": "stone_shovel", + "cobblestoneshovel": "stone_shovel", + "cobblestonespade": "stone_shovel", + "cstoneshovel": "stone_shovel", + "cstonespade": "stone_shovel", + "csshovel": "stone_shovel", + "csspade": "stone_shovel", + "stonespade": "stone_shovel", + "stone_slab": { + "material": "STONE_SLAB" + }, + "stoneslab": "stone_slab", + "stone_sword": { + "material": "STONE_SWORD" + }, + "stonesword": "stone_sword", + "cobblestonesword": "stone_sword", + "cstonesword": "stone_sword", + "cssword": "stone_sword", + "stray_spawn_egg": { + "material": "STRAY_SPAWN_EGG" + }, + "strayspawnegg": "stray_spawn_egg", + "string": { + "material": "STRING" + }, + "stripped_acacia_log": { + "material": "STRIPPED_ACACIA_LOG" + }, + "strippedacacialog": "stripped_acacia_log", + "stripped_acacia_wood": { + "material": "STRIPPED_ACACIA_WOOD" + }, + "strippedacaciawood": "stripped_acacia_wood", + "stripped_birch_log": { + "material": "STRIPPED_BIRCH_LOG" + }, + "strippedbirchlog": "stripped_birch_log", + "stripped_birch_wood": { + "material": "STRIPPED_BIRCH_WOOD" + }, + "strippedbirchwood": "stripped_birch_wood", + "stripped_dark_oak_log": { + "material": "STRIPPED_DARK_OAK_LOG" + }, + "strippeddarkoaklog": "stripped_dark_oak_log", + "stripped_dark_oak_wood": { + "material": "STRIPPED_DARK_OAK_WOOD" + }, + "strippeddarkoakwood": "stripped_dark_oak_wood", + "stripped_jungle_log": { + "material": "STRIPPED_JUNGLE_LOG" + }, + "strippedjunglelog": "stripped_jungle_log", + "stripped_jungle_wood": { + "material": "STRIPPED_JUNGLE_WOOD" + }, + "strippedjunglewood": "stripped_jungle_wood", + "stripped_oak_log": { + "material": "STRIPPED_OAK_LOG" + }, + "strippedoaklog": "stripped_oak_log", + "stripped_oak_wood": { + "material": "STRIPPED_OAK_WOOD" + }, + "strippedoakwood": "stripped_oak_wood", + "stripped_spruce_log": { + "material": "STRIPPED_SPRUCE_LOG" + }, + "strippedsprucelog": "stripped_spruce_log", + "stripped_spruce_wood": { + "material": "STRIPPED_SPRUCE_WOOD" + }, + "strippedsprucewood": "stripped_spruce_wood", + "structure_block": { + "material": "STRUCTURE_BLOCK" + }, + "structureblock": "structure_block", + "structure_void": { + "material": "STRUCTURE_VOID" + }, + "structurevoid": "structure_void", + "sugar": { + "material": "SUGAR" + }, + "sugar_cane": { + "material": "SUGAR_CANE" + }, + "sugarcane": "sugar_cane", + "sunflower": { + "material": "SUNFLOWER" + }, + "tall_grass": { + "material": "TALL_GRASS" + }, + "tallgrass": "tall_grass", + "tall_seagrass": { + "material": "TALL_SEAGRASS" + }, + "tallseagrass": "tall_seagrass", + "terracotta": "white_terracotta", + "tipped_arrow": { + "material": "TIPPED_ARROW" + }, + "tippedarrow": "tipped_arrow", + "tnt": { + "material": "TNT" + }, + "tnt_minecart": { + "material": "TNT_MINECART" + }, + "tntminecart": "tnt_minecart", + "torch": { + "material": "TORCH" + }, + "totem_of_undying": { + "material": "TOTEM_OF_UNDYING" + }, + "totemofundying": "totem_of_undying", + "trapped_chest": { + "material": "TRAPPED_CHEST" + }, + "trappedchest": "trapped_chest", + "trident": { + "material": "TRIDENT" + }, + "tripwire": { + "material": "TRIPWIRE" + }, + "tripwire_hook": { + "material": "TRIPWIRE_HOOK" + }, + "tripwirehook": "tripwire_hook", + "tropical_fish": { + "material": "TROPICAL_FISH" + }, + "tropicalfish": "tropical_fish", + "tropical_fish_bucket": { + "material": "TROPICAL_FISH_BUCKET" + }, + "tropicalfishbucket": "tropical_fish_bucket", + "tropical_fish_spawn_egg": { + "material": "TROPICAL_FISH_SPAWN_EGG" + }, + "tropicalfishspawnegg": "tropical_fish_spawn_egg", + "tube_coral": { + "material": "TUBE_CORAL" + }, + "tubecoral": "tube_coral", + "tube_coral_block": { + "material": "TUBE_CORAL_BLOCK" + }, + "tubecoralblock": "tube_coral_block", + "tube_coral_fan": { + "material": "TUBE_CORAL_FAN" + }, + "tubecoralfan": "tube_coral_fan", + "tube_coral_wall_fan": { + "material": "TUBE_CORAL_WALL_FAN" + }, + "tubecoralwallfan": "tube_coral_wall_fan", + "turtle_egg": { + "material": "TURTLE_EGG" + }, + "turtleegg": "turtle_egg", + "turtle_helmet": { + "material": "TURTLE_HELMET" + }, + "turtlehelmet": "turtle_helmet", + "turtle_spawn_egg": { + "material": "TURTLE_SPAWN_EGG" + }, + "turtlespawnegg": "turtle_spawn_egg", + "vex_spawn_egg": { + "material": "VEX_SPAWN_EGG" + }, + "vexspawnegg": "vex_spawn_egg", + "villager_spawn_egg": { + "material": "VILLAGER_SPAWN_EGG" + }, + "villagerspawnegg": "villager_spawn_egg", + "vindicator_spawn_egg": { + "material": "VINDICATOR_SPAWN_EGG" + }, + "vindicatorspawnegg": "vindicator_spawn_egg", + "vine": { + "material": "VINE" + }, + "void_air": { + "material": "VOID_AIR" + }, + "voidair": "void_air", + "wall_sign": { + "material": "WALL_SIGN" + }, + "wallsign": "wall_sign", + "wall_torch": { + "material": "WALL_TORCH" + }, + "walltorch": "wall_torch", + "water": { + "material": "WATER" + }, + "stationarywater": "water", + "stillwater": "water", + "swater": "water", + "water_bucket": { + "material": "WATER_BUCKET" + }, + "waterbucket": "water_bucket", + "wet_sponge": { + "material": "WET_SPONGE" + }, + "wetsponge": "wet_sponge", + "wheat": { + "material": "WHEAT" + }, + "wheat_seeds": { + "material": "WHEAT_SEEDS" + }, + "wheatseeds": "wheat_seeds", + "white_banner": { + "material": "WHITE_BANNER" + }, + "whitebanner": "white_banner", + "standingbanner": "white_banner", + "banner": "white_banner", + "wstandingbanner": "white_banner", + "wbanner": "white_banner", + "whitestandingbanner": "white_banner", + "white_bed": { + "material": "WHITE_BED" + }, + "whitebed": "white_bed", + "bed": "white_bed", + "wbed": "white_bed", + "white_carpet": { + "material": "WHITE_CARPET" + }, + "whitecarpet": "white_carpet", + "carpet": "white_carpet", + "floor": "white_carpet", + "wcarpet": "white_carpet", + "wfloor": "white_carpet", + "whitefloor": "white_carpet", + "white_concrete": { + "material": "WHITE_CONCRETE" + }, + "whiteconcrete": "white_concrete", + "concrete": "white_concrete", + "wconcrete": "white_concrete", + "white_concrete_powder": { + "material": "WHITE_CONCRETE_POWDER" + }, + "whiteconcretepowder": "white_concrete_powder", + "concretepowder": "white_concrete_powder", + "concretesand": "white_concrete_powder", + "wconcretepowder": "white_concrete_powder", + "wconcretesand": "white_concrete_powder", + "whiteconcretesand": "white_concrete_powder", + "white_glazed_terracotta": { + "material": "WHITE_GLAZED_TERRACOTTA" + }, + "whiteglazedterracotta": "white_glazed_terracotta", + "glazedtcota": "white_glazed_terracotta", + "glazedterra": "white_glazed_terracotta", + "glazedterracotta": "white_glazed_terracotta", + "glazedterracota": "white_glazed_terracotta", + "wglazedtcota": "white_glazed_terracotta", + "wglazedterra": "white_glazed_terracotta", + "wglazedterracotta": "white_glazed_terracotta", + "wglazedterracota": "white_glazed_terracotta", + "whiteglazedtcota": "white_glazed_terracotta", + "whiteglazedterra": "white_glazed_terracotta", + "whiteglazedterracota": "white_glazed_terracotta", + "white_shulker_box": { + "material": "WHITE_SHULKER_BOX" + }, + "whiteshulkerbox": "white_shulker_box", + "wshulkerbox": "white_shulker_box", + "wchest": "white_shulker_box", + "whitechest": "white_shulker_box", + "white_stained_glass": { + "material": "WHITE_STAINED_GLASS" + }, + "whitestainedglass": "white_stained_glass", + "sglass": "white_stained_glass", + "stainedglass": "white_stained_glass", + "wglass": "white_stained_glass", + "wsglass": "white_stained_glass", + "wstainedglass": "white_stained_glass", + "whiteglass": "white_stained_glass", + "whitesglass": "white_stained_glass", + "white_stained_glass_pane": { + "material": "WHITE_STAINED_GLASS_PANE" + }, + "whitestainedglasspane": "white_stained_glass_pane", + "sglasspane": "white_stained_glass_pane", + "stainedglasspane": "white_stained_glass_pane", + "wglasspane": "white_stained_glass_pane", + "wsglasspane": "white_stained_glass_pane", + "wstainedglasspane": "white_stained_glass_pane", + "whiteglasspane": "white_stained_glass_pane", + "whitesglasspane": "white_stained_glass_pane", + "white_terracotta": { + "material": "WHITE_TERRACOTTA" + }, + "whiteterracotta": "white_terracotta", + "sclay": "white_terracotta", + "stainedclay": "white_terracotta", + "terra": "white_terracotta", + "tcota": "white_terracotta", + "terracota": "white_terracotta", + "wclay": "white_terracotta", + "wsclay": "white_terracotta", + "wstainedclay": "white_terracotta", + "wterra": "white_terracotta", + "wtcota": "white_terracotta", + "wterracota": "white_terracotta", + "wterracotta": "white_terracotta", + "whiteclay": "white_terracotta", + "whitesclay": "white_terracotta", + "whitestainedclay": "white_terracotta", + "whiteterra": "white_terracotta", + "whitetcota": "white_terracotta", + "whiteterracota": "white_terracotta", + "white_tulip": { + "material": "WHITE_TULIP" + }, + "whitetulip": "white_tulip", + "white_wall_banner": { + "material": "WHITE_WALL_BANNER" + }, + "whitewallbanner": "white_wall_banner", + "wallbanner": "white_wall_banner", + "wwallbanner": "white_wall_banner", + "white_wool": { + "material": "WHITE_WOOL" + }, + "whitewool": "white_wool", + "wool": "white_wool", + "cloth": "white_wool", + "cotton": "white_wool", + "wwool": "white_wool", + "wcloth": "white_wool", + "wcotton": "white_wool", + "whitecloth": "white_wool", + "whitecotton": "white_wool", + "witch_spawn_egg": { + "material": "WITCH_SPAWN_EGG" + }, + "witchspawnegg": "witch_spawn_egg", + "wither_skeleton_skull": { + "material": "WITHER_SKELETON_SKULL" + }, + "witherskeletonskull": "wither_skeleton_skull", + "wither_skeleton_spawn_egg": { + "material": "WITHER_SKELETON_SPAWN_EGG" + }, + "witherskeletonspawnegg": "wither_skeleton_spawn_egg", + "wither_skeleton_wall_skull": { + "material": "WITHER_SKELETON_WALL_SKULL" + }, + "witherskeletonwallskull": "wither_skeleton_wall_skull", + "wolf_spawn_egg": { + "material": "WOLF_SPAWN_EGG" + }, + "wolfspawnegg": "wolf_spawn_egg", + "wooden_axe": { + "material": "WOODEN_AXE" + }, + "woodenaxe": "wooden_axe", + "woodaxe": "wooden_axe", + "waxe": "wooden_axe", + "wooden_hoe": { + "material": "WOODEN_HOE" + }, + "woodenhoe": "wooden_hoe", + "woodhoe": "wooden_hoe", + "whoe": "wooden_hoe", + "wooden_pickaxe": { + "material": "WOODEN_PICKAXE" + }, + "woodenpickaxe": "wooden_pickaxe", + "woodenpick": "wooden_pickaxe", + "woodpickaxe": "wooden_pickaxe", + "woodpick": "wooden_pickaxe", + "wpickaxe": "wooden_pickaxe", + "wpick": "wooden_pickaxe", + "wooden_shovel": { + "material": "WOODEN_SHOVEL" + }, + "woodenshovel": "wooden_shovel", + "woodenspade": "wooden_shovel", + "woodshovel": "wooden_shovel", + "woodspade": "wooden_shovel", + "wshovel": "wooden_shovel", + "wspade": "wooden_shovel", + "wooden_sword": { + "material": "WOODEN_SWORD" + }, + "woodensword": "wooden_sword", + "woodsword": "wooden_sword", + "wsword": "wooden_sword", + "writable_book": { + "material": "WRITABLE_BOOK" + }, + "writablebook": "writable_book", + "written_book": { + "material": "WRITTEN_BOOK" + }, + "writtenbook": "written_book", + "yellow_banner": { + "material": "YELLOW_BANNER" + }, + "yellowbanner": "yellow_banner", + "ystandingbanner": "yellow_banner", + "ybanner": "yellow_banner", + "yellowstandingbanner": "yellow_banner", + "yellow_bed": { + "material": "YELLOW_BED" + }, + "yellowbed": "yellow_bed", + "ybed": "yellow_bed", + "yellow_carpet": { + "material": "YELLOW_CARPET" + }, + "yellowcarpet": "yellow_carpet", + "ycarpet": "yellow_carpet", + "yfloor": "yellow_carpet", + "yellowfloor": "yellow_carpet", + "yellow_concrete": { + "material": "YELLOW_CONCRETE" + }, + "yellowconcrete": "yellow_concrete", + "yconcrete": "yellow_concrete", + "yellow_concrete_powder": { + "material": "YELLOW_CONCRETE_POWDER" + }, + "yellowconcretepowder": "yellow_concrete_powder", + "yconcretepowder": "yellow_concrete_powder", + "yconcretesand": "yellow_concrete_powder", + "yellowconcretesand": "yellow_concrete_powder", + "yellow_glazed_terracotta": { + "material": "YELLOW_GLAZED_TERRACOTTA" + }, + "yellowglazedterracotta": "yellow_glazed_terracotta", + "yglazedtcota": "yellow_glazed_terracotta", + "yglazedterra": "yellow_glazed_terracotta", + "yglazedterracotta": "yellow_glazed_terracotta", + "yglazedterracota": "yellow_glazed_terracotta", + "yellowglazedtcota": "yellow_glazed_terracotta", + "yellowglazedterra": "yellow_glazed_terracotta", + "yellowglazedterracota": "yellow_glazed_terracotta", + "yellow_shulker_box": { + "material": "YELLOW_SHULKER_BOX" + }, + "yellowshulkerbox": "yellow_shulker_box", + "yshulkerbox": "yellow_shulker_box", + "ychest": "yellow_shulker_box", + "yellowchest": "yellow_shulker_box", + "yellow_stained_glass": { + "material": "YELLOW_STAINED_GLASS" + }, + "yellowstainedglass": "yellow_stained_glass", + "yglass": "yellow_stained_glass", + "ysglass": "yellow_stained_glass", + "ystainedglass": "yellow_stained_glass", + "yellowglass": "yellow_stained_glass", + "yellowsglass": "yellow_stained_glass", + "yellow_stained_glass_pane": { + "material": "YELLOW_STAINED_GLASS_PANE" + }, + "yellowstainedglasspane": "yellow_stained_glass_pane", + "yglasspane": "yellow_stained_glass_pane", + "ysglasspane": "yellow_stained_glass_pane", + "ystainedglasspane": "yellow_stained_glass_pane", + "yellowglasspane": "yellow_stained_glass_pane", + "yellowsglasspane": "yellow_stained_glass_pane", + "yellow_terracotta": { + "material": "YELLOW_TERRACOTTA" + }, + "yellowterracotta": "yellow_terracotta", + "yclay": "yellow_terracotta", + "ysclay": "yellow_terracotta", + "ystainedclay": "yellow_terracotta", + "yterra": "yellow_terracotta", + "ytcota": "yellow_terracotta", + "yterracota": "yellow_terracotta", + "yterracotta": "yellow_terracotta", + "yellowclay": "yellow_terracotta", + "yellowsclay": "yellow_terracotta", + "yellowstainedclay": "yellow_terracotta", + "yellowterra": "yellow_terracotta", + "yellowtcota": "yellow_terracotta", + "yellowterracota": "yellow_terracotta", + "yellow_wall_banner": { + "material": "YELLOW_WALL_BANNER" + }, + "yellowwallbanner": "yellow_wall_banner", + "ywallbanner": "yellow_wall_banner", + "yellow_wool": { + "material": "YELLOW_WOOL" + }, + "yellowwool": "yellow_wool", + "ywool": "yellow_wool", + "ycloth": "yellow_wool", + "ycotton": "yellow_wool", + "yellowcloth": "yellow_wool", + "yellowcotton": "yellow_wool", + "zombie_head": { + "material": "ZOMBIE_HEAD" + }, + "zombiehead": "zombie_head", + "zombie_horse_spawn_egg": { + "material": "ZOMBIE_HORSE_SPAWN_EGG" + }, + "zombiehorsespawnegg": "zombie_horse_spawn_egg", + "zombie_pigman_spawn_egg": { + "material": "ZOMBIE_PIGMAN_SPAWN_EGG" + }, + "zombiepigmanspawnegg": "zombie_pigman_spawn_egg", + "zombie_spawn_egg": { + "material": "ZOMBIE_SPAWN_EGG" + }, + "zombiespawnegg": "zombie_spawn_egg", + "zombie_villager_spawn_egg": { + "material": "ZOMBIE_VILLAGER_SPAWN_EGG" + }, + "zombievillagerspawnegg": "zombie_villager_spawn_egg", + "zombie_wall_head": { + "material": "ZOMBIE_WALL_HEAD" + }, + "zombiewallhead": "zombie_wall_head", + "emptypotion": { + "material": "POTION", + "potionData": { + "vanillaType": "empty", + "bukkitType": "empty", + "isStrong": false, + "isLong": false + } + }, + "emptypot": "emptypotion", + "potionofempty": "emptypotion", + "potofempty": "emptypotion", + "splashemptypotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "empty", + "bukkitType": "empty", + "isStrong": false, + "isLong": false + } + }, + "splemptypotion": "splashemptypotion", + "emptysplashpotion": "splashemptypotion", + "splashemptypot": "splashemptypotion", + "splemptypot": "splashemptypotion", + "emptysplashpot": "splashemptypotion", + "lingerpotempty": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "empty", + "bukkitType": "empty", + "isStrong": false, + "isLong": false + } + }, + "emptylingerpot": "lingerpotempty", + "aoepotionempty": "lingerpotempty", + "emptyaoepoiont": "lingerpotempty", + "aoepotempty": "lingerpotempty", + "emptyaoepot": "lingerpotempty", + "areapotionempty": "lingerpotempty", + "emptyareapotion": "lingerpotempty", + "areapotempty": "lingerpotempty", + "emptyareapot": "lingerpotempty", + "cloudpotionempty": "lingerpotempty", + "emptycloudpotion": "lingerpotempty", + "cloudpotempty": "lingerpotempty", + "emptycloudpot": "lingerpotempty", + "arrowempty": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "empty", + "bukkitType": "empty", + "isStrong": false, + "isLong": false + } + }, + "emptyarrow": "arrowempty", + "waterpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "water", + "bukkitType": "water", + "isStrong": false, + "isLong": false + } + }, + "waterpot": "waterpotion", + "potionofwater": "waterpotion", + "potofwater": "waterpotion", + "splashwaterpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "water", + "bukkitType": "water", + "isStrong": false, + "isLong": false + } + }, + "splwaterpotion": "splashwaterpotion", + "watersplashpotion": "splashwaterpotion", + "splashwaterpot": "splashwaterpotion", + "splwaterpot": "splashwaterpotion", + "watersplashpot": "splashwaterpotion", + "lingerpotwater": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "water", + "bukkitType": "water", + "isStrong": false, + "isLong": false + } + }, + "waterlingerpot": "lingerpotwater", + "aoepotionwater": "lingerpotwater", + "wateraoepoiont": "lingerpotwater", + "aoepotwater": "lingerpotwater", + "wateraoepot": "lingerpotwater", + "areapotionwater": "lingerpotwater", + "waterareapotion": "lingerpotwater", + "areapotwater": "lingerpotwater", + "waterareapot": "lingerpotwater", + "cloudpotionwater": "lingerpotwater", + "watercloudpotion": "lingerpotwater", + "cloudpotwater": "lingerpotwater", + "watercloudpot": "lingerpotwater", + "arrowwater": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "water", + "bukkitType": "water", + "isStrong": false, + "isLong": false + } + }, + "waterarrow": "arrowwater", + "mundanepotion": { + "material": "POTION", + "potionData": { + "vanillaType": "mundane", + "bukkitType": "mundane", + "isStrong": false, + "isLong": false + } + }, + "mundanepot": "mundanepotion", + "potionofmundane": "mundanepotion", + "potofmundane": "mundanepotion", + "splashmundanepotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "mundane", + "bukkitType": "mundane", + "isStrong": false, + "isLong": false + } + }, + "splmundanepotion": "splashmundanepotion", + "mundanesplashpotion": "splashmundanepotion", + "splashmundanepot": "splashmundanepotion", + "splmundanepot": "splashmundanepotion", + "mundanesplashpot": "splashmundanepotion", + "lingerpotmundane": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "mundane", + "bukkitType": "mundane", + "isStrong": false, + "isLong": false + } + }, + "mundanelingerpot": "lingerpotmundane", + "aoepotionmundane": "lingerpotmundane", + "mundaneaoepoiont": "lingerpotmundane", + "aoepotmundane": "lingerpotmundane", + "mundaneaoepot": "lingerpotmundane", + "areapotionmundane": "lingerpotmundane", + "mundaneareapotion": "lingerpotmundane", + "areapotmundane": "lingerpotmundane", + "mundaneareapot": "lingerpotmundane", + "cloudpotionmundane": "lingerpotmundane", + "mundanecloudpotion": "lingerpotmundane", + "cloudpotmundane": "lingerpotmundane", + "mundanecloudpot": "lingerpotmundane", + "arrowmundane": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "mundane", + "bukkitType": "mundane", + "isStrong": false, + "isLong": false + } + }, + "mundanearrow": "arrowmundane", + "thickpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "thick", + "bukkitType": "thick", + "isStrong": false, + "isLong": false + } + }, + "thickpot": "thickpotion", + "potionofthick": "thickpotion", + "potofthick": "thickpotion", + "splashthickpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "thick", + "bukkitType": "thick", + "isStrong": false, + "isLong": false + } + }, + "splthickpotion": "splashthickpotion", + "thicksplashpotion": "splashthickpotion", + "splashthickpot": "splashthickpotion", + "splthickpot": "splashthickpotion", + "thicksplashpot": "splashthickpotion", + "lingerpotthick": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "thick", + "bukkitType": "thick", + "isStrong": false, + "isLong": false + } + }, + "thicklingerpot": "lingerpotthick", + "aoepotionthick": "lingerpotthick", + "thickaoepoiont": "lingerpotthick", + "aoepotthick": "lingerpotthick", + "thickaoepot": "lingerpotthick", + "areapotionthick": "lingerpotthick", + "thickareapotion": "lingerpotthick", + "areapotthick": "lingerpotthick", + "thickareapot": "lingerpotthick", + "cloudpotionthick": "lingerpotthick", + "thickcloudpotion": "lingerpotthick", + "cloudpotthick": "lingerpotthick", + "thickcloudpot": "lingerpotthick", + "arrowthick": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "thick", + "bukkitType": "thick", + "isStrong": false, + "isLong": false + } + }, + "thickarrow": "arrowthick", + "awkwardpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "awkward", + "bukkitType": "awkward", + "isStrong": false, + "isLong": false + } + }, + "awkwardpot": "awkwardpotion", + "potionofawkward": "awkwardpotion", + "potofawkward": "awkwardpotion", + "splashawkwardpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "awkward", + "bukkitType": "awkward", + "isStrong": false, + "isLong": false + } + }, + "splawkwardpotion": "splashawkwardpotion", + "awkwardsplashpotion": "splashawkwardpotion", + "splashawkwardpot": "splashawkwardpotion", + "splawkwardpot": "splashawkwardpotion", + "awkwardsplashpot": "splashawkwardpotion", + "lingerpotawkward": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "awkward", + "bukkitType": "awkward", + "isStrong": false, + "isLong": false + } + }, + "awkwardlingerpot": "lingerpotawkward", + "aoepotionawkward": "lingerpotawkward", + "awkwardaoepoiont": "lingerpotawkward", + "aoepotawkward": "lingerpotawkward", + "awkwardaoepot": "lingerpotawkward", + "areapotionawkward": "lingerpotawkward", + "awkwardareapotion": "lingerpotawkward", + "areapotawkward": "lingerpotawkward", + "awkwardareapot": "lingerpotawkward", + "cloudpotionawkward": "lingerpotawkward", + "awkwardcloudpotion": "lingerpotawkward", + "cloudpotawkward": "lingerpotawkward", + "awkwardcloudpot": "lingerpotawkward", + "arrowawkward": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "awkward", + "bukkitType": "awkward", + "isStrong": false, + "isLong": false + } + }, + "awkwardarrow": "arrowawkward", + "nightvisionpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": false + } + }, + "nvpotion": "nightvisionpotion", + "nvisionpotion": "nightvisionpotion", + "nightvpotion": "nightvisionpotion", + "darkvispotion": "nightvisionpotion", + "dvisionpotion": "nightvisionpotion", + "darkvpotion": "nightvisionpotion", + "nightvisionpot": "nightvisionpotion", + "nvpot": "nightvisionpotion", + "nvisionpot": "nightvisionpotion", + "nightvpot": "nightvisionpotion", + "darkvispot": "nightvisionpotion", + "dvisionpot": "nightvisionpotion", + "darkvpot": "nightvisionpotion", + "potionofnightvision": "nightvisionpotion", + "potionofnv": "nightvisionpotion", + "potionofnvision": "nightvisionpotion", + "potionofnightv": "nightvisionpotion", + "potionofdarkvis": "nightvisionpotion", + "potionofdvision": "nightvisionpotion", + "potionofdarkv": "nightvisionpotion", + "potofnightvision": "nightvisionpotion", + "potofnv": "nightvisionpotion", + "potofnvision": "nightvisionpotion", + "potofnightv": "nightvisionpotion", + "potofdarkvis": "nightvisionpotion", + "potofdvision": "nightvisionpotion", + "potofdarkv": "nightvisionpotion", + "splashnightvisionpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": false + } + }, + "splashnvpotion": "splashnightvisionpotion", + "splashnvisionpotion": "splashnightvisionpotion", + "splashnightvpotion": "splashnightvisionpotion", + "splashdarkvispotion": "splashnightvisionpotion", + "splashdvisionpotion": "splashnightvisionpotion", + "splashdarkvpotion": "splashnightvisionpotion", + "splnightvisionpotion": "splashnightvisionpotion", + "splnvpotion": "splashnightvisionpotion", + "splnvisionpotion": "splashnightvisionpotion", + "splnightvpotion": "splashnightvisionpotion", + "spldarkvispotion": "splashnightvisionpotion", + "spldvisionpotion": "splashnightvisionpotion", + "spldarkvpotion": "splashnightvisionpotion", + "nightvisionsplashpotion": "splashnightvisionpotion", + "nvsplashpotion": "splashnightvisionpotion", + "nvisionsplashpotion": "splashnightvisionpotion", + "nightvsplashpotion": "splashnightvisionpotion", + "darkvissplashpotion": "splashnightvisionpotion", + "dvisionsplashpotion": "splashnightvisionpotion", + "darkvsplashpotion": "splashnightvisionpotion", + "splashnightvisionpot": "splashnightvisionpotion", + "splashnvpot": "splashnightvisionpotion", + "splashnvisionpot": "splashnightvisionpotion", + "splashnightvpot": "splashnightvisionpotion", + "splashdarkvispot": "splashnightvisionpotion", + "splashdvisionpot": "splashnightvisionpotion", + "splashdarkvpot": "splashnightvisionpotion", + "splnightvisionpot": "splashnightvisionpotion", + "splnvpot": "splashnightvisionpotion", + "splnvisionpot": "splashnightvisionpotion", + "splnightvpot": "splashnightvisionpotion", + "spldarkvispot": "splashnightvisionpotion", + "spldvisionpot": "splashnightvisionpotion", + "spldarkvpot": "splashnightvisionpotion", + "nightvisionsplashpot": "splashnightvisionpotion", + "nvsplashpot": "splashnightvisionpotion", + "nvisionsplashpot": "splashnightvisionpotion", + "nightvsplashpot": "splashnightvisionpotion", + "darkvissplashpot": "splashnightvisionpotion", + "dvisionsplashpot": "splashnightvisionpotion", + "darkvsplashpot": "splashnightvisionpotion", + "lingerpotnightvision": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": false + } + }, + "lingerpotnv": "lingerpotnightvision", + "lingerpotnvision": "lingerpotnightvision", + "lingerpotnightv": "lingerpotnightvision", + "lingerpotdarkvis": "lingerpotnightvision", + "lingerpotdvision": "lingerpotnightvision", + "lingerpotdarkv": "lingerpotnightvision", + "nightvisionlingerpot": "lingerpotnightvision", + "nvlingerpot": "lingerpotnightvision", + "nvisionlingerpot": "lingerpotnightvision", + "nightvlingerpot": "lingerpotnightvision", + "darkvislingerpot": "lingerpotnightvision", + "dvisionlingerpot": "lingerpotnightvision", + "darkvlingerpot": "lingerpotnightvision", + "aoepotionnightvision": "lingerpotnightvision", + "aoepotionnv": "lingerpotnightvision", + "aoepotionnvision": "lingerpotnightvision", + "aoepotionnightv": "lingerpotnightvision", + "aoepotiondarkvis": "lingerpotnightvision", + "aoepotiondvision": "lingerpotnightvision", + "aoepotiondarkv": "lingerpotnightvision", + "nightvisionaoepoiont": "lingerpotnightvision", + "nvaoepoiont": "lingerpotnightvision", + "nvisionaoepoiont": "lingerpotnightvision", + "nightvaoepoiont": "lingerpotnightvision", + "darkvisaoepoiont": "lingerpotnightvision", + "dvisionaoepoiont": "lingerpotnightvision", + "darkvaoepoiont": "lingerpotnightvision", + "aoepotnightvision": "lingerpotnightvision", + "aoepotnv": "lingerpotnightvision", + "aoepotnvision": "lingerpotnightvision", + "aoepotnightv": "lingerpotnightvision", + "aoepotdarkvis": "lingerpotnightvision", + "aoepotdvision": "lingerpotnightvision", + "aoepotdarkv": "lingerpotnightvision", + "nightvisionaoepot": "lingerpotnightvision", + "nvaoepot": "lingerpotnightvision", + "nvisionaoepot": "lingerpotnightvision", + "nightvaoepot": "lingerpotnightvision", + "darkvisaoepot": "lingerpotnightvision", + "dvisionaoepot": "lingerpotnightvision", + "darkvaoepot": "lingerpotnightvision", + "areapotionnightvision": "lingerpotnightvision", + "areapotionnv": "lingerpotnightvision", + "areapotionnvision": "lingerpotnightvision", + "areapotionnightv": "lingerpotnightvision", + "areapotiondarkvis": "lingerpotnightvision", + "areapotiondvision": "lingerpotnightvision", + "areapotiondarkv": "lingerpotnightvision", + "nightvisionareapotion": "lingerpotnightvision", + "nvareapotion": "lingerpotnightvision", + "nvisionareapotion": "lingerpotnightvision", + "nightvareapotion": "lingerpotnightvision", + "darkvisareapotion": "lingerpotnightvision", + "dvisionareapotion": "lingerpotnightvision", + "darkvareapotion": "lingerpotnightvision", + "areapotnightvision": "lingerpotnightvision", + "areapotnv": "lingerpotnightvision", + "areapotnvision": "lingerpotnightvision", + "areapotnightv": "lingerpotnightvision", + "areapotdarkvis": "lingerpotnightvision", + "areapotdvision": "lingerpotnightvision", + "areapotdarkv": "lingerpotnightvision", + "nightvisionareapot": "lingerpotnightvision", + "nvareapot": "lingerpotnightvision", + "nvisionareapot": "lingerpotnightvision", + "nightvareapot": "lingerpotnightvision", + "darkvisareapot": "lingerpotnightvision", + "dvisionareapot": "lingerpotnightvision", + "darkvareapot": "lingerpotnightvision", + "cloudpotionnightvision": "lingerpotnightvision", + "cloudpotionnv": "lingerpotnightvision", + "cloudpotionnvision": "lingerpotnightvision", + "cloudpotionnightv": "lingerpotnightvision", + "cloudpotiondarkvis": "lingerpotnightvision", + "cloudpotiondvision": "lingerpotnightvision", + "cloudpotiondarkv": "lingerpotnightvision", + "nightvisioncloudpotion": "lingerpotnightvision", + "nvcloudpotion": "lingerpotnightvision", + "nvisioncloudpotion": "lingerpotnightvision", + "nightvcloudpotion": "lingerpotnightvision", + "darkviscloudpotion": "lingerpotnightvision", + "dvisioncloudpotion": "lingerpotnightvision", + "darkvcloudpotion": "lingerpotnightvision", + "cloudpotnightvision": "lingerpotnightvision", + "cloudpotnv": "lingerpotnightvision", + "cloudpotnvision": "lingerpotnightvision", + "cloudpotnightv": "lingerpotnightvision", + "cloudpotdarkvis": "lingerpotnightvision", + "cloudpotdvision": "lingerpotnightvision", + "cloudpotdarkv": "lingerpotnightvision", + "nightvisioncloudpot": "lingerpotnightvision", + "nvcloudpot": "lingerpotnightvision", + "nvisioncloudpot": "lingerpotnightvision", + "nightvcloudpot": "lingerpotnightvision", + "darkviscloudpot": "lingerpotnightvision", + "dvisioncloudpot": "lingerpotnightvision", + "darkvcloudpot": "lingerpotnightvision", + "arrownightvision": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": false + } + }, + "arrownv": "arrownightvision", + "arrownvision": "arrownightvision", + "arrownightv": "arrownightvision", + "arrowdarkvis": "arrownightvision", + "arrowdvision": "arrownightvision", + "arrowdarkv": "arrownightvision", + "nightvisionarrow": "arrownightvision", + "nvarrow": "arrownightvision", + "nvisionarrow": "arrownightvision", + "nightvarrow": "arrownightvision", + "darkvisarrow": "arrownightvision", + "dvisionarrow": "arrownightvision", + "darkvarrow": "arrownightvision", + "nightvision2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": true + } + }, + "nightvisionlongpotion": "nightvision2potion", + "nightvisionextendedpotion": "nightvision2potion", + "nightvisionexpotion": "nightvision2potion", + "nightvisionlevel2potion": "nightvision2potion", + "nv2potion": "nightvision2potion", + "nvlongpotion": "nightvision2potion", + "nvextendedpotion": "nightvision2potion", + "nvexpotion": "nightvision2potion", + "nvlevel2potion": "nightvision2potion", + "nvision2potion": "nightvision2potion", + "nvisionlongpotion": "nightvision2potion", + "nvisionextendedpotion": "nightvision2potion", + "nvisionexpotion": "nightvision2potion", + "nvisionlevel2potion": "nightvision2potion", + "nightv2potion": "nightvision2potion", + "nightvlongpotion": "nightvision2potion", + "nightvextendedpotion": "nightvision2potion", + "nightvexpotion": "nightvision2potion", + "nightvlevel2potion": "nightvision2potion", + "darkvis2potion": "nightvision2potion", + "darkvislongpotion": "nightvision2potion", + "darkvisextendedpotion": "nightvision2potion", + "darkvisexpotion": "nightvision2potion", + "darkvislevel2potion": "nightvision2potion", + "dvision2potion": "nightvision2potion", + "dvisionlongpotion": "nightvision2potion", + "dvisionextendedpotion": "nightvision2potion", + "dvisionexpotion": "nightvision2potion", + "dvisionlevel2potion": "nightvision2potion", + "darkv2potion": "nightvision2potion", + "darkvlongpotion": "nightvision2potion", + "darkvextendedpotion": "nightvision2potion", + "darkvexpotion": "nightvision2potion", + "darkvlevel2potion": "nightvision2potion", + "nightvision2pot": "nightvision2potion", + "nightvisionlongpot": "nightvision2potion", + "nightvisionextendedpot": "nightvision2potion", + "nightvisionexpot": "nightvision2potion", + "nightvisionlevel2pot": "nightvision2potion", + "nv2pot": "nightvision2potion", + "nvlongpot": "nightvision2potion", + "nvextendedpot": "nightvision2potion", + "nvexpot": "nightvision2potion", + "nvlevel2pot": "nightvision2potion", + "nvision2pot": "nightvision2potion", + "nvisionlongpot": "nightvision2potion", + "nvisionextendedpot": "nightvision2potion", + "nvisionexpot": "nightvision2potion", + "nvisionlevel2pot": "nightvision2potion", + "nightv2pot": "nightvision2potion", + "nightvlongpot": "nightvision2potion", + "nightvextendedpot": "nightvision2potion", + "nightvexpot": "nightvision2potion", + "nightvlevel2pot": "nightvision2potion", + "darkvis2pot": "nightvision2potion", + "darkvislongpot": "nightvision2potion", + "darkvisextendedpot": "nightvision2potion", + "darkvisexpot": "nightvision2potion", + "darkvislevel2pot": "nightvision2potion", + "dvision2pot": "nightvision2potion", + "dvisionlongpot": "nightvision2potion", + "dvisionextendedpot": "nightvision2potion", + "dvisionexpot": "nightvision2potion", + "dvisionlevel2pot": "nightvision2potion", + "darkv2pot": "nightvision2potion", + "darkvlongpot": "nightvision2potion", + "darkvextendedpot": "nightvision2potion", + "darkvexpot": "nightvision2potion", + "darkvlevel2pot": "nightvision2potion", + "potionofnightvision2": "nightvision2potion", + "potionofnightvisionlong": "nightvision2potion", + "potionofnightvisionextended": "nightvision2potion", + "potionofnightvisionex": "nightvision2potion", + "potionofnightvisionlevel2": "nightvision2potion", + "potionofnv2": "nightvision2potion", + "potionofnvlong": "nightvision2potion", + "potionofnvextended": "nightvision2potion", + "potionofnvex": "nightvision2potion", + "potionofnvlevel2": "nightvision2potion", + "potionofnvision2": "nightvision2potion", + "potionofnvisionlong": "nightvision2potion", + "potionofnvisionextended": "nightvision2potion", + "potionofnvisionex": "nightvision2potion", + "potionofnvisionlevel2": "nightvision2potion", + "potionofnightv2": "nightvision2potion", + "potionofnightvlong": "nightvision2potion", + "potionofnightvextended": "nightvision2potion", + "potionofnightvex": "nightvision2potion", + "potionofnightvlevel2": "nightvision2potion", + "potionofdarkvis2": "nightvision2potion", + "potionofdarkvislong": "nightvision2potion", + "potionofdarkvisextended": "nightvision2potion", + "potionofdarkvisex": "nightvision2potion", + "potionofdarkvislevel2": "nightvision2potion", + "potionofdvision2": "nightvision2potion", + "potionofdvisionlong": "nightvision2potion", + "potionofdvisionextended": "nightvision2potion", + "potionofdvisionex": "nightvision2potion", + "potionofdvisionlevel2": "nightvision2potion", + "potionofdarkv2": "nightvision2potion", + "potionofdarkvlong": "nightvision2potion", + "potionofdarkvextended": "nightvision2potion", + "potionofdarkvex": "nightvision2potion", + "potionofdarkvlevel2": "nightvision2potion", + "potofnightvision2": "nightvision2potion", + "potofnightvisionlong": "nightvision2potion", + "potofnightvisionextended": "nightvision2potion", + "potofnightvisionex": "nightvision2potion", + "potofnightvisionlevel2": "nightvision2potion", + "potofnv2": "nightvision2potion", + "potofnvlong": "nightvision2potion", + "potofnvextended": "nightvision2potion", + "potofnvex": "nightvision2potion", + "potofnvlevel2": "nightvision2potion", + "potofnvision2": "nightvision2potion", + "potofnvisionlong": "nightvision2potion", + "potofnvisionextended": "nightvision2potion", + "potofnvisionex": "nightvision2potion", + "potofnvisionlevel2": "nightvision2potion", + "potofnightv2": "nightvision2potion", + "potofnightvlong": "nightvision2potion", + "potofnightvextended": "nightvision2potion", + "potofnightvex": "nightvision2potion", + "potofnightvlevel2": "nightvision2potion", + "potofdarkvis2": "nightvision2potion", + "potofdarkvislong": "nightvision2potion", + "potofdarkvisextended": "nightvision2potion", + "potofdarkvisex": "nightvision2potion", + "potofdarkvislevel2": "nightvision2potion", + "potofdvision2": "nightvision2potion", + "potofdvisionlong": "nightvision2potion", + "potofdvisionextended": "nightvision2potion", + "potofdvisionex": "nightvision2potion", + "potofdvisionlevel2": "nightvision2potion", + "potofdarkv2": "nightvision2potion", + "potofdarkvlong": "nightvision2potion", + "potofdarkvextended": "nightvision2potion", + "potofdarkvex": "nightvision2potion", + "potofdarkvlevel2": "nightvision2potion", + "splashnightvision2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": true + } + }, + "splashnightvisionlongpotion": "splashnightvision2potion", + "splashnightvisionextendedpotion": "splashnightvision2potion", + "splashnightvisionexpotion": "splashnightvision2potion", + "splashnightvisionlevel2potion": "splashnightvision2potion", + "splashnv2potion": "splashnightvision2potion", + "splashnvlongpotion": "splashnightvision2potion", + "splashnvextendedpotion": "splashnightvision2potion", + "splashnvexpotion": "splashnightvision2potion", + "splashnvlevel2potion": "splashnightvision2potion", + "splashnvision2potion": "splashnightvision2potion", + "splashnvisionlongpotion": "splashnightvision2potion", + "splashnvisionextendedpotion": "splashnightvision2potion", + "splashnvisionexpotion": "splashnightvision2potion", + "splashnvisionlevel2potion": "splashnightvision2potion", + "splashnightv2potion": "splashnightvision2potion", + "splashnightvlongpotion": "splashnightvision2potion", + "splashnightvextendedpotion": "splashnightvision2potion", + "splashnightvexpotion": "splashnightvision2potion", + "splashnightvlevel2potion": "splashnightvision2potion", + "splashdarkvis2potion": "splashnightvision2potion", + "splashdarkvislongpotion": "splashnightvision2potion", + "splashdarkvisextendedpotion": "splashnightvision2potion", + "splashdarkvisexpotion": "splashnightvision2potion", + "splashdarkvislevel2potion": "splashnightvision2potion", + "splashdvision2potion": "splashnightvision2potion", + "splashdvisionlongpotion": "splashnightvision2potion", + "splashdvisionextendedpotion": "splashnightvision2potion", + "splashdvisionexpotion": "splashnightvision2potion", + "splashdvisionlevel2potion": "splashnightvision2potion", + "splashdarkv2potion": "splashnightvision2potion", + "splashdarkvlongpotion": "splashnightvision2potion", + "splashdarkvextendedpotion": "splashnightvision2potion", + "splashdarkvexpotion": "splashnightvision2potion", + "splashdarkvlevel2potion": "splashnightvision2potion", + "splnightvision2potion": "splashnightvision2potion", + "splnightvisionlongpotion": "splashnightvision2potion", + "splnightvisionextendedpotion": "splashnightvision2potion", + "splnightvisionexpotion": "splashnightvision2potion", + "splnightvisionlevel2potion": "splashnightvision2potion", + "splnv2potion": "splashnightvision2potion", + "splnvlongpotion": "splashnightvision2potion", + "splnvextendedpotion": "splashnightvision2potion", + "splnvexpotion": "splashnightvision2potion", + "splnvlevel2potion": "splashnightvision2potion", + "splnvision2potion": "splashnightvision2potion", + "splnvisionlongpotion": "splashnightvision2potion", + "splnvisionextendedpotion": "splashnightvision2potion", + "splnvisionexpotion": "splashnightvision2potion", + "splnvisionlevel2potion": "splashnightvision2potion", + "splnightv2potion": "splashnightvision2potion", + "splnightvlongpotion": "splashnightvision2potion", + "splnightvextendedpotion": "splashnightvision2potion", + "splnightvexpotion": "splashnightvision2potion", + "splnightvlevel2potion": "splashnightvision2potion", + "spldarkvis2potion": "splashnightvision2potion", + "spldarkvislongpotion": "splashnightvision2potion", + "spldarkvisextendedpotion": "splashnightvision2potion", + "spldarkvisexpotion": "splashnightvision2potion", + "spldarkvislevel2potion": "splashnightvision2potion", + "spldvision2potion": "splashnightvision2potion", + "spldvisionlongpotion": "splashnightvision2potion", + "spldvisionextendedpotion": "splashnightvision2potion", + "spldvisionexpotion": "splashnightvision2potion", + "spldvisionlevel2potion": "splashnightvision2potion", + "spldarkv2potion": "splashnightvision2potion", + "spldarkvlongpotion": "splashnightvision2potion", + "spldarkvextendedpotion": "splashnightvision2potion", + "spldarkvexpotion": "splashnightvision2potion", + "spldarkvlevel2potion": "splashnightvision2potion", + "nightvision2splashpotion": "splashnightvision2potion", + "nightvisionlongsplashpotion": "splashnightvision2potion", + "nightvisionextendedsplashpotion": "splashnightvision2potion", + "nightvisionexsplashpotion": "splashnightvision2potion", + "nightvisionlevel2splashpotion": "splashnightvision2potion", + "nv2splashpotion": "splashnightvision2potion", + "nvlongsplashpotion": "splashnightvision2potion", + "nvextendedsplashpotion": "splashnightvision2potion", + "nvexsplashpotion": "splashnightvision2potion", + "nvlevel2splashpotion": "splashnightvision2potion", + "nvision2splashpotion": "splashnightvision2potion", + "nvisionlongsplashpotion": "splashnightvision2potion", + "nvisionextendedsplashpotion": "splashnightvision2potion", + "nvisionexsplashpotion": "splashnightvision2potion", + "nvisionlevel2splashpotion": "splashnightvision2potion", + "nightv2splashpotion": "splashnightvision2potion", + "nightvlongsplashpotion": "splashnightvision2potion", + "nightvextendedsplashpotion": "splashnightvision2potion", + "nightvexsplashpotion": "splashnightvision2potion", + "nightvlevel2splashpotion": "splashnightvision2potion", + "darkvis2splashpotion": "splashnightvision2potion", + "darkvislongsplashpotion": "splashnightvision2potion", + "darkvisextendedsplashpotion": "splashnightvision2potion", + "darkvisexsplashpotion": "splashnightvision2potion", + "darkvislevel2splashpotion": "splashnightvision2potion", + "dvision2splashpotion": "splashnightvision2potion", + "dvisionlongsplashpotion": "splashnightvision2potion", + "dvisionextendedsplashpotion": "splashnightvision2potion", + "dvisionexsplashpotion": "splashnightvision2potion", + "dvisionlevel2splashpotion": "splashnightvision2potion", + "darkv2splashpotion": "splashnightvision2potion", + "darkvlongsplashpotion": "splashnightvision2potion", + "darkvextendedsplashpotion": "splashnightvision2potion", + "darkvexsplashpotion": "splashnightvision2potion", + "darkvlevel2splashpotion": "splashnightvision2potion", + "splashnightvision2pot": "splashnightvision2potion", + "splashnightvisionlongpot": "splashnightvision2potion", + "splashnightvisionextendedpot": "splashnightvision2potion", + "splashnightvisionexpot": "splashnightvision2potion", + "splashnightvisionlevel2pot": "splashnightvision2potion", + "splashnv2pot": "splashnightvision2potion", + "splashnvlongpot": "splashnightvision2potion", + "splashnvextendedpot": "splashnightvision2potion", + "splashnvexpot": "splashnightvision2potion", + "splashnvlevel2pot": "splashnightvision2potion", + "splashnvision2pot": "splashnightvision2potion", + "splashnvisionlongpot": "splashnightvision2potion", + "splashnvisionextendedpot": "splashnightvision2potion", + "splashnvisionexpot": "splashnightvision2potion", + "splashnvisionlevel2pot": "splashnightvision2potion", + "splashnightv2pot": "splashnightvision2potion", + "splashnightvlongpot": "splashnightvision2potion", + "splashnightvextendedpot": "splashnightvision2potion", + "splashnightvexpot": "splashnightvision2potion", + "splashnightvlevel2pot": "splashnightvision2potion", + "splashdarkvis2pot": "splashnightvision2potion", + "splashdarkvislongpot": "splashnightvision2potion", + "splashdarkvisextendedpot": "splashnightvision2potion", + "splashdarkvisexpot": "splashnightvision2potion", + "splashdarkvislevel2pot": "splashnightvision2potion", + "splashdvision2pot": "splashnightvision2potion", + "splashdvisionlongpot": "splashnightvision2potion", + "splashdvisionextendedpot": "splashnightvision2potion", + "splashdvisionexpot": "splashnightvision2potion", + "splashdvisionlevel2pot": "splashnightvision2potion", + "splashdarkv2pot": "splashnightvision2potion", + "splashdarkvlongpot": "splashnightvision2potion", + "splashdarkvextendedpot": "splashnightvision2potion", + "splashdarkvexpot": "splashnightvision2potion", + "splashdarkvlevel2pot": "splashnightvision2potion", + "splnightvision2pot": "splashnightvision2potion", + "splnightvisionlongpot": "splashnightvision2potion", + "splnightvisionextendedpot": "splashnightvision2potion", + "splnightvisionexpot": "splashnightvision2potion", + "splnightvisionlevel2pot": "splashnightvision2potion", + "splnv2pot": "splashnightvision2potion", + "splnvlongpot": "splashnightvision2potion", + "splnvextendedpot": "splashnightvision2potion", + "splnvexpot": "splashnightvision2potion", + "splnvlevel2pot": "splashnightvision2potion", + "splnvision2pot": "splashnightvision2potion", + "splnvisionlongpot": "splashnightvision2potion", + "splnvisionextendedpot": "splashnightvision2potion", + "splnvisionexpot": "splashnightvision2potion", + "splnvisionlevel2pot": "splashnightvision2potion", + "splnightv2pot": "splashnightvision2potion", + "splnightvlongpot": "splashnightvision2potion", + "splnightvextendedpot": "splashnightvision2potion", + "splnightvexpot": "splashnightvision2potion", + "splnightvlevel2pot": "splashnightvision2potion", + "spldarkvis2pot": "splashnightvision2potion", + "spldarkvislongpot": "splashnightvision2potion", + "spldarkvisextendedpot": "splashnightvision2potion", + "spldarkvisexpot": "splashnightvision2potion", + "spldarkvislevel2pot": "splashnightvision2potion", + "spldvision2pot": "splashnightvision2potion", + "spldvisionlongpot": "splashnightvision2potion", + "spldvisionextendedpot": "splashnightvision2potion", + "spldvisionexpot": "splashnightvision2potion", + "spldvisionlevel2pot": "splashnightvision2potion", + "spldarkv2pot": "splashnightvision2potion", + "spldarkvlongpot": "splashnightvision2potion", + "spldarkvextendedpot": "splashnightvision2potion", + "spldarkvexpot": "splashnightvision2potion", + "spldarkvlevel2pot": "splashnightvision2potion", + "nightvision2splashpot": "splashnightvision2potion", + "nightvisionlongsplashpot": "splashnightvision2potion", + "nightvisionextendedsplashpot": "splashnightvision2potion", + "nightvisionexsplashpot": "splashnightvision2potion", + "nightvisionlevel2splashpot": "splashnightvision2potion", + "nv2splashpot": "splashnightvision2potion", + "nvlongsplashpot": "splashnightvision2potion", + "nvextendedsplashpot": "splashnightvision2potion", + "nvexsplashpot": "splashnightvision2potion", + "nvlevel2splashpot": "splashnightvision2potion", + "nvision2splashpot": "splashnightvision2potion", + "nvisionlongsplashpot": "splashnightvision2potion", + "nvisionextendedsplashpot": "splashnightvision2potion", + "nvisionexsplashpot": "splashnightvision2potion", + "nvisionlevel2splashpot": "splashnightvision2potion", + "nightv2splashpot": "splashnightvision2potion", + "nightvlongsplashpot": "splashnightvision2potion", + "nightvextendedsplashpot": "splashnightvision2potion", + "nightvexsplashpot": "splashnightvision2potion", + "nightvlevel2splashpot": "splashnightvision2potion", + "darkvis2splashpot": "splashnightvision2potion", + "darkvislongsplashpot": "splashnightvision2potion", + "darkvisextendedsplashpot": "splashnightvision2potion", + "darkvisexsplashpot": "splashnightvision2potion", + "darkvislevel2splashpot": "splashnightvision2potion", + "dvision2splashpot": "splashnightvision2potion", + "dvisionlongsplashpot": "splashnightvision2potion", + "dvisionextendedsplashpot": "splashnightvision2potion", + "dvisionexsplashpot": "splashnightvision2potion", + "dvisionlevel2splashpot": "splashnightvision2potion", + "darkv2splashpot": "splashnightvision2potion", + "darkvlongsplashpot": "splashnightvision2potion", + "darkvextendedsplashpot": "splashnightvision2potion", + "darkvexsplashpot": "splashnightvision2potion", + "darkvlevel2splashpot": "splashnightvision2potion", + "lingerpotnightvision2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": true + } + }, + "lingerpotnightvisionlong": "lingerpotnightvision2", + "lingerpotnightvisionextended": "lingerpotnightvision2", + "lingerpotnightvisionex": "lingerpotnightvision2", + "lingerpotnightvisionlevel2": "lingerpotnightvision2", + "lingerpotnv2": "lingerpotnightvision2", + "lingerpotnvlong": "lingerpotnightvision2", + "lingerpotnvextended": "lingerpotnightvision2", + "lingerpotnvex": "lingerpotnightvision2", + "lingerpotnvlevel2": "lingerpotnightvision2", + "lingerpotnvision2": "lingerpotnightvision2", + "lingerpotnvisionlong": "lingerpotnightvision2", + "lingerpotnvisionextended": "lingerpotnightvision2", + "lingerpotnvisionex": "lingerpotnightvision2", + "lingerpotnvisionlevel2": "lingerpotnightvision2", + "lingerpotnightv2": "lingerpotnightvision2", + "lingerpotnightvlong": "lingerpotnightvision2", + "lingerpotnightvextended": "lingerpotnightvision2", + "lingerpotnightvex": "lingerpotnightvision2", + "lingerpotnightvlevel2": "lingerpotnightvision2", + "lingerpotdarkvis2": "lingerpotnightvision2", + "lingerpotdarkvislong": "lingerpotnightvision2", + "lingerpotdarkvisextended": "lingerpotnightvision2", + "lingerpotdarkvisex": "lingerpotnightvision2", + "lingerpotdarkvislevel2": "lingerpotnightvision2", + "lingerpotdvision2": "lingerpotnightvision2", + "lingerpotdvisionlong": "lingerpotnightvision2", + "lingerpotdvisionextended": "lingerpotnightvision2", + "lingerpotdvisionex": "lingerpotnightvision2", + "lingerpotdvisionlevel2": "lingerpotnightvision2", + "lingerpotdarkv2": "lingerpotnightvision2", + "lingerpotdarkvlong": "lingerpotnightvision2", + "lingerpotdarkvextended": "lingerpotnightvision2", + "lingerpotdarkvex": "lingerpotnightvision2", + "lingerpotdarkvlevel2": "lingerpotnightvision2", + "nightvisionlingerpot2": "lingerpotnightvision2", + "nightvisionlingerpotlong": "lingerpotnightvision2", + "nightvisionlingerpotextended": "lingerpotnightvision2", + "nightvisionlingerpotex": "lingerpotnightvision2", + "nightvisionlingerpotlevel2": "lingerpotnightvision2", + "nvlingerpot2": "lingerpotnightvision2", + "nvlingerpotlong": "lingerpotnightvision2", + "nvlingerpotextended": "lingerpotnightvision2", + "nvlingerpotex": "lingerpotnightvision2", + "nvlingerpotlevel2": "lingerpotnightvision2", + "nvisionlingerpot2": "lingerpotnightvision2", + "nvisionlingerpotlong": "lingerpotnightvision2", + "nvisionlingerpotextended": "lingerpotnightvision2", + "nvisionlingerpotex": "lingerpotnightvision2", + "nvisionlingerpotlevel2": "lingerpotnightvision2", + "nightvlingerpot2": "lingerpotnightvision2", + "nightvlingerpotlong": "lingerpotnightvision2", + "nightvlingerpotextended": "lingerpotnightvision2", + "nightvlingerpotex": "lingerpotnightvision2", + "nightvlingerpotlevel2": "lingerpotnightvision2", + "darkvislingerpot2": "lingerpotnightvision2", + "darkvislingerpotlong": "lingerpotnightvision2", + "darkvislingerpotextended": "lingerpotnightvision2", + "darkvislingerpotex": "lingerpotnightvision2", + "darkvislingerpotlevel2": "lingerpotnightvision2", + "dvisionlingerpot2": "lingerpotnightvision2", + "dvisionlingerpotlong": "lingerpotnightvision2", + "dvisionlingerpotextended": "lingerpotnightvision2", + "dvisionlingerpotex": "lingerpotnightvision2", + "dvisionlingerpotlevel2": "lingerpotnightvision2", + "darkvlingerpot2": "lingerpotnightvision2", + "darkvlingerpotlong": "lingerpotnightvision2", + "darkvlingerpotextended": "lingerpotnightvision2", + "darkvlingerpotex": "lingerpotnightvision2", + "darkvlingerpotlevel2": "lingerpotnightvision2", + "aoepotionnightvision2": "lingerpotnightvision2", + "aoepotionnightvisionlong": "lingerpotnightvision2", + "aoepotionnightvisionextended": "lingerpotnightvision2", + "aoepotionnightvisionex": "lingerpotnightvision2", + "aoepotionnightvisionlevel2": "lingerpotnightvision2", + "aoepotionnv2": "lingerpotnightvision2", + "aoepotionnvlong": "lingerpotnightvision2", + "aoepotionnvextended": "lingerpotnightvision2", + "aoepotionnvex": "lingerpotnightvision2", + "aoepotionnvlevel2": "lingerpotnightvision2", + "aoepotionnvision2": "lingerpotnightvision2", + "aoepotionnvisionlong": "lingerpotnightvision2", + "aoepotionnvisionextended": "lingerpotnightvision2", + "aoepotionnvisionex": "lingerpotnightvision2", + "aoepotionnvisionlevel2": "lingerpotnightvision2", + "aoepotionnightv2": "lingerpotnightvision2", + "aoepotionnightvlong": "lingerpotnightvision2", + "aoepotionnightvextended": "lingerpotnightvision2", + "aoepotionnightvex": "lingerpotnightvision2", + "aoepotionnightvlevel2": "lingerpotnightvision2", + "aoepotiondarkvis2": "lingerpotnightvision2", + "aoepotiondarkvislong": "lingerpotnightvision2", + "aoepotiondarkvisextended": "lingerpotnightvision2", + "aoepotiondarkvisex": "lingerpotnightvision2", + "aoepotiondarkvislevel2": "lingerpotnightvision2", + "aoepotiondvision2": "lingerpotnightvision2", + "aoepotiondvisionlong": "lingerpotnightvision2", + "aoepotiondvisionextended": "lingerpotnightvision2", + "aoepotiondvisionex": "lingerpotnightvision2", + "aoepotiondvisionlevel2": "lingerpotnightvision2", + "aoepotiondarkv2": "lingerpotnightvision2", + "aoepotiondarkvlong": "lingerpotnightvision2", + "aoepotiondarkvextended": "lingerpotnightvision2", + "aoepotiondarkvex": "lingerpotnightvision2", + "aoepotiondarkvlevel2": "lingerpotnightvision2", + "nightvisionaoepoiont2": "lingerpotnightvision2", + "nightvisionaoepoiontlong": "lingerpotnightvision2", + "nightvisionaoepoiontextended": "lingerpotnightvision2", + "nightvisionaoepoiontex": "lingerpotnightvision2", + "nightvisionaoepoiontlevel2": "lingerpotnightvision2", + "nvaoepoiont2": "lingerpotnightvision2", + "nvaoepoiontlong": "lingerpotnightvision2", + "nvaoepoiontextended": "lingerpotnightvision2", + "nvaoepoiontex": "lingerpotnightvision2", + "nvaoepoiontlevel2": "lingerpotnightvision2", + "nvisionaoepoiont2": "lingerpotnightvision2", + "nvisionaoepoiontlong": "lingerpotnightvision2", + "nvisionaoepoiontextended": "lingerpotnightvision2", + "nvisionaoepoiontex": "lingerpotnightvision2", + "nvisionaoepoiontlevel2": "lingerpotnightvision2", + "nightvaoepoiont2": "lingerpotnightvision2", + "nightvaoepoiontlong": "lingerpotnightvision2", + "nightvaoepoiontextended": "lingerpotnightvision2", + "nightvaoepoiontex": "lingerpotnightvision2", + "nightvaoepoiontlevel2": "lingerpotnightvision2", + "darkvisaoepoiont2": "lingerpotnightvision2", + "darkvisaoepoiontlong": "lingerpotnightvision2", + "darkvisaoepoiontextended": "lingerpotnightvision2", + "darkvisaoepoiontex": "lingerpotnightvision2", + "darkvisaoepoiontlevel2": "lingerpotnightvision2", + "dvisionaoepoiont2": "lingerpotnightvision2", + "dvisionaoepoiontlong": "lingerpotnightvision2", + "dvisionaoepoiontextended": "lingerpotnightvision2", + "dvisionaoepoiontex": "lingerpotnightvision2", + "dvisionaoepoiontlevel2": "lingerpotnightvision2", + "darkvaoepoiont2": "lingerpotnightvision2", + "darkvaoepoiontlong": "lingerpotnightvision2", + "darkvaoepoiontextended": "lingerpotnightvision2", + "darkvaoepoiontex": "lingerpotnightvision2", + "darkvaoepoiontlevel2": "lingerpotnightvision2", + "aoepotnightvision2": "lingerpotnightvision2", + "aoepotnightvisionlong": "lingerpotnightvision2", + "aoepotnightvisionextended": "lingerpotnightvision2", + "aoepotnightvisionex": "lingerpotnightvision2", + "aoepotnightvisionlevel2": "lingerpotnightvision2", + "aoepotnv2": "lingerpotnightvision2", + "aoepotnvlong": "lingerpotnightvision2", + "aoepotnvextended": "lingerpotnightvision2", + "aoepotnvex": "lingerpotnightvision2", + "aoepotnvlevel2": "lingerpotnightvision2", + "aoepotnvision2": "lingerpotnightvision2", + "aoepotnvisionlong": "lingerpotnightvision2", + "aoepotnvisionextended": "lingerpotnightvision2", + "aoepotnvisionex": "lingerpotnightvision2", + "aoepotnvisionlevel2": "lingerpotnightvision2", + "aoepotnightv2": "lingerpotnightvision2", + "aoepotnightvlong": "lingerpotnightvision2", + "aoepotnightvextended": "lingerpotnightvision2", + "aoepotnightvex": "lingerpotnightvision2", + "aoepotnightvlevel2": "lingerpotnightvision2", + "aoepotdarkvis2": "lingerpotnightvision2", + "aoepotdarkvislong": "lingerpotnightvision2", + "aoepotdarkvisextended": "lingerpotnightvision2", + "aoepotdarkvisex": "lingerpotnightvision2", + "aoepotdarkvislevel2": "lingerpotnightvision2", + "aoepotdvision2": "lingerpotnightvision2", + "aoepotdvisionlong": "lingerpotnightvision2", + "aoepotdvisionextended": "lingerpotnightvision2", + "aoepotdvisionex": "lingerpotnightvision2", + "aoepotdvisionlevel2": "lingerpotnightvision2", + "aoepotdarkv2": "lingerpotnightvision2", + "aoepotdarkvlong": "lingerpotnightvision2", + "aoepotdarkvextended": "lingerpotnightvision2", + "aoepotdarkvex": "lingerpotnightvision2", + "aoepotdarkvlevel2": "lingerpotnightvision2", + "nightvisionaoepot2": "lingerpotnightvision2", + "nightvisionaoepotlong": "lingerpotnightvision2", + "nightvisionaoepotextended": "lingerpotnightvision2", + "nightvisionaoepotex": "lingerpotnightvision2", + "nightvisionaoepotlevel2": "lingerpotnightvision2", + "nvaoepot2": "lingerpotnightvision2", + "nvaoepotlong": "lingerpotnightvision2", + "nvaoepotextended": "lingerpotnightvision2", + "nvaoepotex": "lingerpotnightvision2", + "nvaoepotlevel2": "lingerpotnightvision2", + "nvisionaoepot2": "lingerpotnightvision2", + "nvisionaoepotlong": "lingerpotnightvision2", + "nvisionaoepotextended": "lingerpotnightvision2", + "nvisionaoepotex": "lingerpotnightvision2", + "nvisionaoepotlevel2": "lingerpotnightvision2", + "nightvaoepot2": "lingerpotnightvision2", + "nightvaoepotlong": "lingerpotnightvision2", + "nightvaoepotextended": "lingerpotnightvision2", + "nightvaoepotex": "lingerpotnightvision2", + "nightvaoepotlevel2": "lingerpotnightvision2", + "darkvisaoepot2": "lingerpotnightvision2", + "darkvisaoepotlong": "lingerpotnightvision2", + "darkvisaoepotextended": "lingerpotnightvision2", + "darkvisaoepotex": "lingerpotnightvision2", + "darkvisaoepotlevel2": "lingerpotnightvision2", + "dvisionaoepot2": "lingerpotnightvision2", + "dvisionaoepotlong": "lingerpotnightvision2", + "dvisionaoepotextended": "lingerpotnightvision2", + "dvisionaoepotex": "lingerpotnightvision2", + "dvisionaoepotlevel2": "lingerpotnightvision2", + "darkvaoepot2": "lingerpotnightvision2", + "darkvaoepotlong": "lingerpotnightvision2", + "darkvaoepotextended": "lingerpotnightvision2", + "darkvaoepotex": "lingerpotnightvision2", + "darkvaoepotlevel2": "lingerpotnightvision2", + "areapotionnightvision2": "lingerpotnightvision2", + "areapotionnightvisionlong": "lingerpotnightvision2", + "areapotionnightvisionextended": "lingerpotnightvision2", + "areapotionnightvisionex": "lingerpotnightvision2", + "areapotionnightvisionlevel2": "lingerpotnightvision2", + "areapotionnv2": "lingerpotnightvision2", + "areapotionnvlong": "lingerpotnightvision2", + "areapotionnvextended": "lingerpotnightvision2", + "areapotionnvex": "lingerpotnightvision2", + "areapotionnvlevel2": "lingerpotnightvision2", + "areapotionnvision2": "lingerpotnightvision2", + "areapotionnvisionlong": "lingerpotnightvision2", + "areapotionnvisionextended": "lingerpotnightvision2", + "areapotionnvisionex": "lingerpotnightvision2", + "areapotionnvisionlevel2": "lingerpotnightvision2", + "areapotionnightv2": "lingerpotnightvision2", + "areapotionnightvlong": "lingerpotnightvision2", + "areapotionnightvextended": "lingerpotnightvision2", + "areapotionnightvex": "lingerpotnightvision2", + "areapotionnightvlevel2": "lingerpotnightvision2", + "areapotiondarkvis2": "lingerpotnightvision2", + "areapotiondarkvislong": "lingerpotnightvision2", + "areapotiondarkvisextended": "lingerpotnightvision2", + "areapotiondarkvisex": "lingerpotnightvision2", + "areapotiondarkvislevel2": "lingerpotnightvision2", + "areapotiondvision2": "lingerpotnightvision2", + "areapotiondvisionlong": "lingerpotnightvision2", + "areapotiondvisionextended": "lingerpotnightvision2", + "areapotiondvisionex": "lingerpotnightvision2", + "areapotiondvisionlevel2": "lingerpotnightvision2", + "areapotiondarkv2": "lingerpotnightvision2", + "areapotiondarkvlong": "lingerpotnightvision2", + "areapotiondarkvextended": "lingerpotnightvision2", + "areapotiondarkvex": "lingerpotnightvision2", + "areapotiondarkvlevel2": "lingerpotnightvision2", + "nightvisionareapotion2": "lingerpotnightvision2", + "nightvisionareapotionlong": "lingerpotnightvision2", + "nightvisionareapotionextended": "lingerpotnightvision2", + "nightvisionareapotionex": "lingerpotnightvision2", + "nightvisionareapotionlevel2": "lingerpotnightvision2", + "nvareapotion2": "lingerpotnightvision2", + "nvareapotionlong": "lingerpotnightvision2", + "nvareapotionextended": "lingerpotnightvision2", + "nvareapotionex": "lingerpotnightvision2", + "nvareapotionlevel2": "lingerpotnightvision2", + "nvisionareapotion2": "lingerpotnightvision2", + "nvisionareapotionlong": "lingerpotnightvision2", + "nvisionareapotionextended": "lingerpotnightvision2", + "nvisionareapotionex": "lingerpotnightvision2", + "nvisionareapotionlevel2": "lingerpotnightvision2", + "nightvareapotion2": "lingerpotnightvision2", + "nightvareapotionlong": "lingerpotnightvision2", + "nightvareapotionextended": "lingerpotnightvision2", + "nightvareapotionex": "lingerpotnightvision2", + "nightvareapotionlevel2": "lingerpotnightvision2", + "darkvisareapotion2": "lingerpotnightvision2", + "darkvisareapotionlong": "lingerpotnightvision2", + "darkvisareapotionextended": "lingerpotnightvision2", + "darkvisareapotionex": "lingerpotnightvision2", + "darkvisareapotionlevel2": "lingerpotnightvision2", + "dvisionareapotion2": "lingerpotnightvision2", + "dvisionareapotionlong": "lingerpotnightvision2", + "dvisionareapotionextended": "lingerpotnightvision2", + "dvisionareapotionex": "lingerpotnightvision2", + "dvisionareapotionlevel2": "lingerpotnightvision2", + "darkvareapotion2": "lingerpotnightvision2", + "darkvareapotionlong": "lingerpotnightvision2", + "darkvareapotionextended": "lingerpotnightvision2", + "darkvareapotionex": "lingerpotnightvision2", + "darkvareapotionlevel2": "lingerpotnightvision2", + "areapotnightvision2": "lingerpotnightvision2", + "areapotnightvisionlong": "lingerpotnightvision2", + "areapotnightvisionextended": "lingerpotnightvision2", + "areapotnightvisionex": "lingerpotnightvision2", + "areapotnightvisionlevel2": "lingerpotnightvision2", + "areapotnv2": "lingerpotnightvision2", + "areapotnvlong": "lingerpotnightvision2", + "areapotnvextended": "lingerpotnightvision2", + "areapotnvex": "lingerpotnightvision2", + "areapotnvlevel2": "lingerpotnightvision2", + "areapotnvision2": "lingerpotnightvision2", + "areapotnvisionlong": "lingerpotnightvision2", + "areapotnvisionextended": "lingerpotnightvision2", + "areapotnvisionex": "lingerpotnightvision2", + "areapotnvisionlevel2": "lingerpotnightvision2", + "areapotnightv2": "lingerpotnightvision2", + "areapotnightvlong": "lingerpotnightvision2", + "areapotnightvextended": "lingerpotnightvision2", + "areapotnightvex": "lingerpotnightvision2", + "areapotnightvlevel2": "lingerpotnightvision2", + "areapotdarkvis2": "lingerpotnightvision2", + "areapotdarkvislong": "lingerpotnightvision2", + "areapotdarkvisextended": "lingerpotnightvision2", + "areapotdarkvisex": "lingerpotnightvision2", + "areapotdarkvislevel2": "lingerpotnightvision2", + "areapotdvision2": "lingerpotnightvision2", + "areapotdvisionlong": "lingerpotnightvision2", + "areapotdvisionextended": "lingerpotnightvision2", + "areapotdvisionex": "lingerpotnightvision2", + "areapotdvisionlevel2": "lingerpotnightvision2", + "areapotdarkv2": "lingerpotnightvision2", + "areapotdarkvlong": "lingerpotnightvision2", + "areapotdarkvextended": "lingerpotnightvision2", + "areapotdarkvex": "lingerpotnightvision2", + "areapotdarkvlevel2": "lingerpotnightvision2", + "nightvisionareapot2": "lingerpotnightvision2", + "nightvisionareapotlong": "lingerpotnightvision2", + "nightvisionareapotextended": "lingerpotnightvision2", + "nightvisionareapotex": "lingerpotnightvision2", + "nightvisionareapotlevel2": "lingerpotnightvision2", + "nvareapot2": "lingerpotnightvision2", + "nvareapotlong": "lingerpotnightvision2", + "nvareapotextended": "lingerpotnightvision2", + "nvareapotex": "lingerpotnightvision2", + "nvareapotlevel2": "lingerpotnightvision2", + "nvisionareapot2": "lingerpotnightvision2", + "nvisionareapotlong": "lingerpotnightvision2", + "nvisionareapotextended": "lingerpotnightvision2", + "nvisionareapotex": "lingerpotnightvision2", + "nvisionareapotlevel2": "lingerpotnightvision2", + "nightvareapot2": "lingerpotnightvision2", + "nightvareapotlong": "lingerpotnightvision2", + "nightvareapotextended": "lingerpotnightvision2", + "nightvareapotex": "lingerpotnightvision2", + "nightvareapotlevel2": "lingerpotnightvision2", + "darkvisareapot2": "lingerpotnightvision2", + "darkvisareapotlong": "lingerpotnightvision2", + "darkvisareapotextended": "lingerpotnightvision2", + "darkvisareapotex": "lingerpotnightvision2", + "darkvisareapotlevel2": "lingerpotnightvision2", + "dvisionareapot2": "lingerpotnightvision2", + "dvisionareapotlong": "lingerpotnightvision2", + "dvisionareapotextended": "lingerpotnightvision2", + "dvisionareapotex": "lingerpotnightvision2", + "dvisionareapotlevel2": "lingerpotnightvision2", + "darkvareapot2": "lingerpotnightvision2", + "darkvareapotlong": "lingerpotnightvision2", + "darkvareapotextended": "lingerpotnightvision2", + "darkvareapotex": "lingerpotnightvision2", + "darkvareapotlevel2": "lingerpotnightvision2", + "cloudpotionnightvision2": "lingerpotnightvision2", + "cloudpotionnightvisionlong": "lingerpotnightvision2", + "cloudpotionnightvisionextended": "lingerpotnightvision2", + "cloudpotionnightvisionex": "lingerpotnightvision2", + "cloudpotionnightvisionlevel2": "lingerpotnightvision2", + "cloudpotionnv2": "lingerpotnightvision2", + "cloudpotionnvlong": "lingerpotnightvision2", + "cloudpotionnvextended": "lingerpotnightvision2", + "cloudpotionnvex": "lingerpotnightvision2", + "cloudpotionnvlevel2": "lingerpotnightvision2", + "cloudpotionnvision2": "lingerpotnightvision2", + "cloudpotionnvisionlong": "lingerpotnightvision2", + "cloudpotionnvisionextended": "lingerpotnightvision2", + "cloudpotionnvisionex": "lingerpotnightvision2", + "cloudpotionnvisionlevel2": "lingerpotnightvision2", + "cloudpotionnightv2": "lingerpotnightvision2", + "cloudpotionnightvlong": "lingerpotnightvision2", + "cloudpotionnightvextended": "lingerpotnightvision2", + "cloudpotionnightvex": "lingerpotnightvision2", + "cloudpotionnightvlevel2": "lingerpotnightvision2", + "cloudpotiondarkvis2": "lingerpotnightvision2", + "cloudpotiondarkvislong": "lingerpotnightvision2", + "cloudpotiondarkvisextended": "lingerpotnightvision2", + "cloudpotiondarkvisex": "lingerpotnightvision2", + "cloudpotiondarkvislevel2": "lingerpotnightvision2", + "cloudpotiondvision2": "lingerpotnightvision2", + "cloudpotiondvisionlong": "lingerpotnightvision2", + "cloudpotiondvisionextended": "lingerpotnightvision2", + "cloudpotiondvisionex": "lingerpotnightvision2", + "cloudpotiondvisionlevel2": "lingerpotnightvision2", + "cloudpotiondarkv2": "lingerpotnightvision2", + "cloudpotiondarkvlong": "lingerpotnightvision2", + "cloudpotiondarkvextended": "lingerpotnightvision2", + "cloudpotiondarkvex": "lingerpotnightvision2", + "cloudpotiondarkvlevel2": "lingerpotnightvision2", + "nightvisioncloudpotion2": "lingerpotnightvision2", + "nightvisioncloudpotionlong": "lingerpotnightvision2", + "nightvisioncloudpotionextended": "lingerpotnightvision2", + "nightvisioncloudpotionex": "lingerpotnightvision2", + "nightvisioncloudpotionlevel2": "lingerpotnightvision2", + "nvcloudpotion2": "lingerpotnightvision2", + "nvcloudpotionlong": "lingerpotnightvision2", + "nvcloudpotionextended": "lingerpotnightvision2", + "nvcloudpotionex": "lingerpotnightvision2", + "nvcloudpotionlevel2": "lingerpotnightvision2", + "nvisioncloudpotion2": "lingerpotnightvision2", + "nvisioncloudpotionlong": "lingerpotnightvision2", + "nvisioncloudpotionextended": "lingerpotnightvision2", + "nvisioncloudpotionex": "lingerpotnightvision2", + "nvisioncloudpotionlevel2": "lingerpotnightvision2", + "nightvcloudpotion2": "lingerpotnightvision2", + "nightvcloudpotionlong": "lingerpotnightvision2", + "nightvcloudpotionextended": "lingerpotnightvision2", + "nightvcloudpotionex": "lingerpotnightvision2", + "nightvcloudpotionlevel2": "lingerpotnightvision2", + "darkviscloudpotion2": "lingerpotnightvision2", + "darkviscloudpotionlong": "lingerpotnightvision2", + "darkviscloudpotionextended": "lingerpotnightvision2", + "darkviscloudpotionex": "lingerpotnightvision2", + "darkviscloudpotionlevel2": "lingerpotnightvision2", + "dvisioncloudpotion2": "lingerpotnightvision2", + "dvisioncloudpotionlong": "lingerpotnightvision2", + "dvisioncloudpotionextended": "lingerpotnightvision2", + "dvisioncloudpotionex": "lingerpotnightvision2", + "dvisioncloudpotionlevel2": "lingerpotnightvision2", + "darkvcloudpotion2": "lingerpotnightvision2", + "darkvcloudpotionlong": "lingerpotnightvision2", + "darkvcloudpotionextended": "lingerpotnightvision2", + "darkvcloudpotionex": "lingerpotnightvision2", + "darkvcloudpotionlevel2": "lingerpotnightvision2", + "cloudpotnightvision2": "lingerpotnightvision2", + "cloudpotnightvisionlong": "lingerpotnightvision2", + "cloudpotnightvisionextended": "lingerpotnightvision2", + "cloudpotnightvisionex": "lingerpotnightvision2", + "cloudpotnightvisionlevel2": "lingerpotnightvision2", + "cloudpotnv2": "lingerpotnightvision2", + "cloudpotnvlong": "lingerpotnightvision2", + "cloudpotnvextended": "lingerpotnightvision2", + "cloudpotnvex": "lingerpotnightvision2", + "cloudpotnvlevel2": "lingerpotnightvision2", + "cloudpotnvision2": "lingerpotnightvision2", + "cloudpotnvisionlong": "lingerpotnightvision2", + "cloudpotnvisionextended": "lingerpotnightvision2", + "cloudpotnvisionex": "lingerpotnightvision2", + "cloudpotnvisionlevel2": "lingerpotnightvision2", + "cloudpotnightv2": "lingerpotnightvision2", + "cloudpotnightvlong": "lingerpotnightvision2", + "cloudpotnightvextended": "lingerpotnightvision2", + "cloudpotnightvex": "lingerpotnightvision2", + "cloudpotnightvlevel2": "lingerpotnightvision2", + "cloudpotdarkvis2": "lingerpotnightvision2", + "cloudpotdarkvislong": "lingerpotnightvision2", + "cloudpotdarkvisextended": "lingerpotnightvision2", + "cloudpotdarkvisex": "lingerpotnightvision2", + "cloudpotdarkvislevel2": "lingerpotnightvision2", + "cloudpotdvision2": "lingerpotnightvision2", + "cloudpotdvisionlong": "lingerpotnightvision2", + "cloudpotdvisionextended": "lingerpotnightvision2", + "cloudpotdvisionex": "lingerpotnightvision2", + "cloudpotdvisionlevel2": "lingerpotnightvision2", + "cloudpotdarkv2": "lingerpotnightvision2", + "cloudpotdarkvlong": "lingerpotnightvision2", + "cloudpotdarkvextended": "lingerpotnightvision2", + "cloudpotdarkvex": "lingerpotnightvision2", + "cloudpotdarkvlevel2": "lingerpotnightvision2", + "nightvisioncloudpot2": "lingerpotnightvision2", + "nightvisioncloudpotlong": "lingerpotnightvision2", + "nightvisioncloudpotextended": "lingerpotnightvision2", + "nightvisioncloudpotex": "lingerpotnightvision2", + "nightvisioncloudpotlevel2": "lingerpotnightvision2", + "nvcloudpot2": "lingerpotnightvision2", + "nvcloudpotlong": "lingerpotnightvision2", + "nvcloudpotextended": "lingerpotnightvision2", + "nvcloudpotex": "lingerpotnightvision2", + "nvcloudpotlevel2": "lingerpotnightvision2", + "nvisioncloudpot2": "lingerpotnightvision2", + "nvisioncloudpotlong": "lingerpotnightvision2", + "nvisioncloudpotextended": "lingerpotnightvision2", + "nvisioncloudpotex": "lingerpotnightvision2", + "nvisioncloudpotlevel2": "lingerpotnightvision2", + "nightvcloudpot2": "lingerpotnightvision2", + "nightvcloudpotlong": "lingerpotnightvision2", + "nightvcloudpotextended": "lingerpotnightvision2", + "nightvcloudpotex": "lingerpotnightvision2", + "nightvcloudpotlevel2": "lingerpotnightvision2", + "darkviscloudpot2": "lingerpotnightvision2", + "darkviscloudpotlong": "lingerpotnightvision2", + "darkviscloudpotextended": "lingerpotnightvision2", + "darkviscloudpotex": "lingerpotnightvision2", + "darkviscloudpotlevel2": "lingerpotnightvision2", + "dvisioncloudpot2": "lingerpotnightvision2", + "dvisioncloudpotlong": "lingerpotnightvision2", + "dvisioncloudpotextended": "lingerpotnightvision2", + "dvisioncloudpotex": "lingerpotnightvision2", + "dvisioncloudpotlevel2": "lingerpotnightvision2", + "darkvcloudpot2": "lingerpotnightvision2", + "darkvcloudpotlong": "lingerpotnightvision2", + "darkvcloudpotextended": "lingerpotnightvision2", + "darkvcloudpotex": "lingerpotnightvision2", + "darkvcloudpotlevel2": "lingerpotnightvision2", + "arrownightvision2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_night_vision", + "bukkitType": "night_vision", + "isStrong": false, + "isLong": true + } + }, + "arrownightvisionlong": "arrownightvision2", + "arrownightvisionextended": "arrownightvision2", + "arrownightvisionex": "arrownightvision2", + "arrownightvisionlevel2": "arrownightvision2", + "arrownv2": "arrownightvision2", + "arrownvlong": "arrownightvision2", + "arrownvextended": "arrownightvision2", + "arrownvex": "arrownightvision2", + "arrownvlevel2": "arrownightvision2", + "arrownvision2": "arrownightvision2", + "arrownvisionlong": "arrownightvision2", + "arrownvisionextended": "arrownightvision2", + "arrownvisionex": "arrownightvision2", + "arrownvisionlevel2": "arrownightvision2", + "arrownightv2": "arrownightvision2", + "arrownightvlong": "arrownightvision2", + "arrownightvextended": "arrownightvision2", + "arrownightvex": "arrownightvision2", + "arrownightvlevel2": "arrownightvision2", + "arrowdarkvis2": "arrownightvision2", + "arrowdarkvislong": "arrownightvision2", + "arrowdarkvisextended": "arrownightvision2", + "arrowdarkvisex": "arrownightvision2", + "arrowdarkvislevel2": "arrownightvision2", + "arrowdvision2": "arrownightvision2", + "arrowdvisionlong": "arrownightvision2", + "arrowdvisionextended": "arrownightvision2", + "arrowdvisionex": "arrownightvision2", + "arrowdvisionlevel2": "arrownightvision2", + "arrowdarkv2": "arrownightvision2", + "arrowdarkvlong": "arrownightvision2", + "arrowdarkvextended": "arrownightvision2", + "arrowdarkvex": "arrownightvision2", + "arrowdarkvlevel2": "arrownightvision2", + "nightvisionarrow2": "arrownightvision2", + "nightvisionarrowlong": "arrownightvision2", + "nightvisionarrowextended": "arrownightvision2", + "nightvisionarrowex": "arrownightvision2", + "nightvisionarrowlevel2": "arrownightvision2", + "nvarrow2": "arrownightvision2", + "nvarrowlong": "arrownightvision2", + "nvarrowextended": "arrownightvision2", + "nvarrowex": "arrownightvision2", + "nvarrowlevel2": "arrownightvision2", + "nvisionarrow2": "arrownightvision2", + "nvisionarrowlong": "arrownightvision2", + "nvisionarrowextended": "arrownightvision2", + "nvisionarrowex": "arrownightvision2", + "nvisionarrowlevel2": "arrownightvision2", + "nightvarrow2": "arrownightvision2", + "nightvarrowlong": "arrownightvision2", + "nightvarrowextended": "arrownightvision2", + "nightvarrowex": "arrownightvision2", + "nightvarrowlevel2": "arrownightvision2", + "darkvisarrow2": "arrownightvision2", + "darkvisarrowlong": "arrownightvision2", + "darkvisarrowextended": "arrownightvision2", + "darkvisarrowex": "arrownightvision2", + "darkvisarrowlevel2": "arrownightvision2", + "dvisionarrow2": "arrownightvision2", + "dvisionarrowlong": "arrownightvision2", + "dvisionarrowextended": "arrownightvision2", + "dvisionarrowex": "arrownightvision2", + "dvisionarrowlevel2": "arrownightvision2", + "darkvarrow2": "arrownightvision2", + "darkvarrowlong": "arrownightvision2", + "darkvarrowextended": "arrownightvision2", + "darkvarrowex": "arrownightvision2", + "darkvarrowlevel2": "arrownightvision2", + "invisibilitypotion": { + "material": "POTION", + "potionData": { + "vanillaType": "invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": false + } + }, + "invispotion": "invisibilitypotion", + "invisiblepotion": "invisibilitypotion", + "invpotion": "invisibilitypotion", + "invisibilitypot": "invisibilitypotion", + "invispot": "invisibilitypotion", + "invisiblepot": "invisibilitypotion", + "invpot": "invisibilitypotion", + "potionofinvisibility": "invisibilitypotion", + "potionofinvis": "invisibilitypotion", + "potionofinvisible": "invisibilitypotion", + "potionofinv": "invisibilitypotion", + "potofinvisibility": "invisibilitypotion", + "potofinvis": "invisibilitypotion", + "potofinvisible": "invisibilitypotion", + "potofinv": "invisibilitypotion", + "splashinvisibilitypotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": false + } + }, + "splashinvispotion": "splashinvisibilitypotion", + "splashinvisiblepotion": "splashinvisibilitypotion", + "splashinvpotion": "splashinvisibilitypotion", + "splinvisibilitypotion": "splashinvisibilitypotion", + "splinvispotion": "splashinvisibilitypotion", + "splinvisiblepotion": "splashinvisibilitypotion", + "splinvpotion": "splashinvisibilitypotion", + "invisibilitysplashpotion": "splashinvisibilitypotion", + "invissplashpotion": "splashinvisibilitypotion", + "invisiblesplashpotion": "splashinvisibilitypotion", + "invsplashpotion": "splashinvisibilitypotion", + "splashinvisibilitypot": "splashinvisibilitypotion", + "splashinvispot": "splashinvisibilitypotion", + "splashinvisiblepot": "splashinvisibilitypotion", + "splashinvpot": "splashinvisibilitypotion", + "splinvisibilitypot": "splashinvisibilitypotion", + "splinvispot": "splashinvisibilitypotion", + "splinvisiblepot": "splashinvisibilitypotion", + "splinvpot": "splashinvisibilitypotion", + "invisibilitysplashpot": "splashinvisibilitypotion", + "invissplashpot": "splashinvisibilitypotion", + "invisiblesplashpot": "splashinvisibilitypotion", + "invsplashpot": "splashinvisibilitypotion", + "lingerpotinvisibility": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": false + } + }, + "lingerpotinvis": "lingerpotinvisibility", + "lingerpotinvisible": "lingerpotinvisibility", + "lingerpotinv": "lingerpotinvisibility", + "invisibilitylingerpot": "lingerpotinvisibility", + "invislingerpot": "lingerpotinvisibility", + "invisiblelingerpot": "lingerpotinvisibility", + "invlingerpot": "lingerpotinvisibility", + "aoepotioninvisibility": "lingerpotinvisibility", + "aoepotioninvis": "lingerpotinvisibility", + "aoepotioninvisible": "lingerpotinvisibility", + "aoepotioninv": "lingerpotinvisibility", + "invisibilityaoepoiont": "lingerpotinvisibility", + "invisaoepoiont": "lingerpotinvisibility", + "invisibleaoepoiont": "lingerpotinvisibility", + "invaoepoiont": "lingerpotinvisibility", + "aoepotinvisibility": "lingerpotinvisibility", + "aoepotinvis": "lingerpotinvisibility", + "aoepotinvisible": "lingerpotinvisibility", + "aoepotinv": "lingerpotinvisibility", + "invisibilityaoepot": "lingerpotinvisibility", + "invisaoepot": "lingerpotinvisibility", + "invisibleaoepot": "lingerpotinvisibility", + "invaoepot": "lingerpotinvisibility", + "areapotioninvisibility": "lingerpotinvisibility", + "areapotioninvis": "lingerpotinvisibility", + "areapotioninvisible": "lingerpotinvisibility", + "areapotioninv": "lingerpotinvisibility", + "invisibilityareapotion": "lingerpotinvisibility", + "invisareapotion": "lingerpotinvisibility", + "invisibleareapotion": "lingerpotinvisibility", + "invareapotion": "lingerpotinvisibility", + "areapotinvisibility": "lingerpotinvisibility", + "areapotinvis": "lingerpotinvisibility", + "areapotinvisible": "lingerpotinvisibility", + "areapotinv": "lingerpotinvisibility", + "invisibilityareapot": "lingerpotinvisibility", + "invisareapot": "lingerpotinvisibility", + "invisibleareapot": "lingerpotinvisibility", + "invareapot": "lingerpotinvisibility", + "cloudpotioninvisibility": "lingerpotinvisibility", + "cloudpotioninvis": "lingerpotinvisibility", + "cloudpotioninvisible": "lingerpotinvisibility", + "cloudpotioninv": "lingerpotinvisibility", + "invisibilitycloudpotion": "lingerpotinvisibility", + "inviscloudpotion": "lingerpotinvisibility", + "invisiblecloudpotion": "lingerpotinvisibility", + "invcloudpotion": "lingerpotinvisibility", + "cloudpotinvisibility": "lingerpotinvisibility", + "cloudpotinvis": "lingerpotinvisibility", + "cloudpotinvisible": "lingerpotinvisibility", + "cloudpotinv": "lingerpotinvisibility", + "invisibilitycloudpot": "lingerpotinvisibility", + "inviscloudpot": "lingerpotinvisibility", + "invisiblecloudpot": "lingerpotinvisibility", + "invcloudpot": "lingerpotinvisibility", + "arrowinvisibility": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": false + } + }, + "arrowinvis": "arrowinvisibility", + "arrowinvisible": "arrowinvisibility", + "arrowinv": "arrowinvisibility", + "invisibilityarrow": "arrowinvisibility", + "invisarrow": "arrowinvisibility", + "invisiblearrow": "arrowinvisibility", + "invarrow": "arrowinvisibility", + "invisibility2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": true + } + }, + "invisibilitylongpotion": "invisibility2potion", + "invisibilityextendedpotion": "invisibility2potion", + "invisibilityexpotion": "invisibility2potion", + "invisibilitylevel2potion": "invisibility2potion", + "invis2potion": "invisibility2potion", + "invislongpotion": "invisibility2potion", + "invisextendedpotion": "invisibility2potion", + "invisexpotion": "invisibility2potion", + "invislevel2potion": "invisibility2potion", + "invisible2potion": "invisibility2potion", + "invisiblelongpotion": "invisibility2potion", + "invisibleextendedpotion": "invisibility2potion", + "invisibleexpotion": "invisibility2potion", + "invisiblelevel2potion": "invisibility2potion", + "inv2potion": "invisibility2potion", + "invlongpotion": "invisibility2potion", + "invextendedpotion": "invisibility2potion", + "invexpotion": "invisibility2potion", + "invlevel2potion": "invisibility2potion", + "invisibility2pot": "invisibility2potion", + "invisibilitylongpot": "invisibility2potion", + "invisibilityextendedpot": "invisibility2potion", + "invisibilityexpot": "invisibility2potion", + "invisibilitylevel2pot": "invisibility2potion", + "invis2pot": "invisibility2potion", + "invislongpot": "invisibility2potion", + "invisextendedpot": "invisibility2potion", + "invisexpot": "invisibility2potion", + "invislevel2pot": "invisibility2potion", + "invisible2pot": "invisibility2potion", + "invisiblelongpot": "invisibility2potion", + "invisibleextendedpot": "invisibility2potion", + "invisibleexpot": "invisibility2potion", + "invisiblelevel2pot": "invisibility2potion", + "inv2pot": "invisibility2potion", + "invlongpot": "invisibility2potion", + "invextendedpot": "invisibility2potion", + "invexpot": "invisibility2potion", + "invlevel2pot": "invisibility2potion", + "potionofinvisibility2": "invisibility2potion", + "potionofinvisibilitylong": "invisibility2potion", + "potionofinvisibilityextended": "invisibility2potion", + "potionofinvisibilityex": "invisibility2potion", + "potionofinvisibilitylevel2": "invisibility2potion", + "potionofinvis2": "invisibility2potion", + "potionofinvislong": "invisibility2potion", + "potionofinvisextended": "invisibility2potion", + "potionofinvisex": "invisibility2potion", + "potionofinvislevel2": "invisibility2potion", + "potionofinvisible2": "invisibility2potion", + "potionofinvisiblelong": "invisibility2potion", + "potionofinvisibleextended": "invisibility2potion", + "potionofinvisibleex": "invisibility2potion", + "potionofinvisiblelevel2": "invisibility2potion", + "potionofinv2": "invisibility2potion", + "potionofinvlong": "invisibility2potion", + "potionofinvextended": "invisibility2potion", + "potionofinvex": "invisibility2potion", + "potionofinvlevel2": "invisibility2potion", + "potofinvisibility2": "invisibility2potion", + "potofinvisibilitylong": "invisibility2potion", + "potofinvisibilityextended": "invisibility2potion", + "potofinvisibilityex": "invisibility2potion", + "potofinvisibilitylevel2": "invisibility2potion", + "potofinvis2": "invisibility2potion", + "potofinvislong": "invisibility2potion", + "potofinvisextended": "invisibility2potion", + "potofinvisex": "invisibility2potion", + "potofinvislevel2": "invisibility2potion", + "potofinvisible2": "invisibility2potion", + "potofinvisiblelong": "invisibility2potion", + "potofinvisibleextended": "invisibility2potion", + "potofinvisibleex": "invisibility2potion", + "potofinvisiblelevel2": "invisibility2potion", + "potofinv2": "invisibility2potion", + "potofinvlong": "invisibility2potion", + "potofinvextended": "invisibility2potion", + "potofinvex": "invisibility2potion", + "potofinvlevel2": "invisibility2potion", + "splashinvisibility2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": true + } + }, + "splashinvisibilitylongpotion": "splashinvisibility2potion", + "splashinvisibilityextendedpotion": "splashinvisibility2potion", + "splashinvisibilityexpotion": "splashinvisibility2potion", + "splashinvisibilitylevel2potion": "splashinvisibility2potion", + "splashinvis2potion": "splashinvisibility2potion", + "splashinvislongpotion": "splashinvisibility2potion", + "splashinvisextendedpotion": "splashinvisibility2potion", + "splashinvisexpotion": "splashinvisibility2potion", + "splashinvislevel2potion": "splashinvisibility2potion", + "splashinvisible2potion": "splashinvisibility2potion", + "splashinvisiblelongpotion": "splashinvisibility2potion", + "splashinvisibleextendedpotion": "splashinvisibility2potion", + "splashinvisibleexpotion": "splashinvisibility2potion", + "splashinvisiblelevel2potion": "splashinvisibility2potion", + "splashinv2potion": "splashinvisibility2potion", + "splashinvlongpotion": "splashinvisibility2potion", + "splashinvextendedpotion": "splashinvisibility2potion", + "splashinvexpotion": "splashinvisibility2potion", + "splashinvlevel2potion": "splashinvisibility2potion", + "splinvisibility2potion": "splashinvisibility2potion", + "splinvisibilitylongpotion": "splashinvisibility2potion", + "splinvisibilityextendedpotion": "splashinvisibility2potion", + "splinvisibilityexpotion": "splashinvisibility2potion", + "splinvisibilitylevel2potion": "splashinvisibility2potion", + "splinvis2potion": "splashinvisibility2potion", + "splinvislongpotion": "splashinvisibility2potion", + "splinvisextendedpotion": "splashinvisibility2potion", + "splinvisexpotion": "splashinvisibility2potion", + "splinvislevel2potion": "splashinvisibility2potion", + "splinvisible2potion": "splashinvisibility2potion", + "splinvisiblelongpotion": "splashinvisibility2potion", + "splinvisibleextendedpotion": "splashinvisibility2potion", + "splinvisibleexpotion": "splashinvisibility2potion", + "splinvisiblelevel2potion": "splashinvisibility2potion", + "splinv2potion": "splashinvisibility2potion", + "splinvlongpotion": "splashinvisibility2potion", + "splinvextendedpotion": "splashinvisibility2potion", + "splinvexpotion": "splashinvisibility2potion", + "splinvlevel2potion": "splashinvisibility2potion", + "invisibility2splashpotion": "splashinvisibility2potion", + "invisibilitylongsplashpotion": "splashinvisibility2potion", + "invisibilityextendedsplashpotion": "splashinvisibility2potion", + "invisibilityexsplashpotion": "splashinvisibility2potion", + "invisibilitylevel2splashpotion": "splashinvisibility2potion", + "invis2splashpotion": "splashinvisibility2potion", + "invislongsplashpotion": "splashinvisibility2potion", + "invisextendedsplashpotion": "splashinvisibility2potion", + "invisexsplashpotion": "splashinvisibility2potion", + "invislevel2splashpotion": "splashinvisibility2potion", + "invisible2splashpotion": "splashinvisibility2potion", + "invisiblelongsplashpotion": "splashinvisibility2potion", + "invisibleextendedsplashpotion": "splashinvisibility2potion", + "invisibleexsplashpotion": "splashinvisibility2potion", + "invisiblelevel2splashpotion": "splashinvisibility2potion", + "inv2splashpotion": "splashinvisibility2potion", + "invlongsplashpotion": "splashinvisibility2potion", + "invextendedsplashpotion": "splashinvisibility2potion", + "invexsplashpotion": "splashinvisibility2potion", + "invlevel2splashpotion": "splashinvisibility2potion", + "splashinvisibility2pot": "splashinvisibility2potion", + "splashinvisibilitylongpot": "splashinvisibility2potion", + "splashinvisibilityextendedpot": "splashinvisibility2potion", + "splashinvisibilityexpot": "splashinvisibility2potion", + "splashinvisibilitylevel2pot": "splashinvisibility2potion", + "splashinvis2pot": "splashinvisibility2potion", + "splashinvislongpot": "splashinvisibility2potion", + "splashinvisextendedpot": "splashinvisibility2potion", + "splashinvisexpot": "splashinvisibility2potion", + "splashinvislevel2pot": "splashinvisibility2potion", + "splashinvisible2pot": "splashinvisibility2potion", + "splashinvisiblelongpot": "splashinvisibility2potion", + "splashinvisibleextendedpot": "splashinvisibility2potion", + "splashinvisibleexpot": "splashinvisibility2potion", + "splashinvisiblelevel2pot": "splashinvisibility2potion", + "splashinv2pot": "splashinvisibility2potion", + "splashinvlongpot": "splashinvisibility2potion", + "splashinvextendedpot": "splashinvisibility2potion", + "splashinvexpot": "splashinvisibility2potion", + "splashinvlevel2pot": "splashinvisibility2potion", + "splinvisibility2pot": "splashinvisibility2potion", + "splinvisibilitylongpot": "splashinvisibility2potion", + "splinvisibilityextendedpot": "splashinvisibility2potion", + "splinvisibilityexpot": "splashinvisibility2potion", + "splinvisibilitylevel2pot": "splashinvisibility2potion", + "splinvis2pot": "splashinvisibility2potion", + "splinvislongpot": "splashinvisibility2potion", + "splinvisextendedpot": "splashinvisibility2potion", + "splinvisexpot": "splashinvisibility2potion", + "splinvislevel2pot": "splashinvisibility2potion", + "splinvisible2pot": "splashinvisibility2potion", + "splinvisiblelongpot": "splashinvisibility2potion", + "splinvisibleextendedpot": "splashinvisibility2potion", + "splinvisibleexpot": "splashinvisibility2potion", + "splinvisiblelevel2pot": "splashinvisibility2potion", + "splinv2pot": "splashinvisibility2potion", + "splinvlongpot": "splashinvisibility2potion", + "splinvextendedpot": "splashinvisibility2potion", + "splinvexpot": "splashinvisibility2potion", + "splinvlevel2pot": "splashinvisibility2potion", + "invisibility2splashpot": "splashinvisibility2potion", + "invisibilitylongsplashpot": "splashinvisibility2potion", + "invisibilityextendedsplashpot": "splashinvisibility2potion", + "invisibilityexsplashpot": "splashinvisibility2potion", + "invisibilitylevel2splashpot": "splashinvisibility2potion", + "invis2splashpot": "splashinvisibility2potion", + "invislongsplashpot": "splashinvisibility2potion", + "invisextendedsplashpot": "splashinvisibility2potion", + "invisexsplashpot": "splashinvisibility2potion", + "invislevel2splashpot": "splashinvisibility2potion", + "invisible2splashpot": "splashinvisibility2potion", + "invisiblelongsplashpot": "splashinvisibility2potion", + "invisibleextendedsplashpot": "splashinvisibility2potion", + "invisibleexsplashpot": "splashinvisibility2potion", + "invisiblelevel2splashpot": "splashinvisibility2potion", + "inv2splashpot": "splashinvisibility2potion", + "invlongsplashpot": "splashinvisibility2potion", + "invextendedsplashpot": "splashinvisibility2potion", + "invexsplashpot": "splashinvisibility2potion", + "invlevel2splashpot": "splashinvisibility2potion", + "lingerpotinvisibility2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": true + } + }, + "lingerpotinvisibilitylong": "lingerpotinvisibility2", + "lingerpotinvisibilityextended": "lingerpotinvisibility2", + "lingerpotinvisibilityex": "lingerpotinvisibility2", + "lingerpotinvisibilitylevel2": "lingerpotinvisibility2", + "lingerpotinvis2": "lingerpotinvisibility2", + "lingerpotinvislong": "lingerpotinvisibility2", + "lingerpotinvisextended": "lingerpotinvisibility2", + "lingerpotinvisex": "lingerpotinvisibility2", + "lingerpotinvislevel2": "lingerpotinvisibility2", + "lingerpotinvisible2": "lingerpotinvisibility2", + "lingerpotinvisiblelong": "lingerpotinvisibility2", + "lingerpotinvisibleextended": "lingerpotinvisibility2", + "lingerpotinvisibleex": "lingerpotinvisibility2", + "lingerpotinvisiblelevel2": "lingerpotinvisibility2", + "lingerpotinv2": "lingerpotinvisibility2", + "lingerpotinvlong": "lingerpotinvisibility2", + "lingerpotinvextended": "lingerpotinvisibility2", + "lingerpotinvex": "lingerpotinvisibility2", + "lingerpotinvlevel2": "lingerpotinvisibility2", + "invisibilitylingerpot2": "lingerpotinvisibility2", + "invisibilitylingerpotlong": "lingerpotinvisibility2", + "invisibilitylingerpotextended": "lingerpotinvisibility2", + "invisibilitylingerpotex": "lingerpotinvisibility2", + "invisibilitylingerpotlevel2": "lingerpotinvisibility2", + "invislingerpot2": "lingerpotinvisibility2", + "invislingerpotlong": "lingerpotinvisibility2", + "invislingerpotextended": "lingerpotinvisibility2", + "invislingerpotex": "lingerpotinvisibility2", + "invislingerpotlevel2": "lingerpotinvisibility2", + "invisiblelingerpot2": "lingerpotinvisibility2", + "invisiblelingerpotlong": "lingerpotinvisibility2", + "invisiblelingerpotextended": "lingerpotinvisibility2", + "invisiblelingerpotex": "lingerpotinvisibility2", + "invisiblelingerpotlevel2": "lingerpotinvisibility2", + "invlingerpot2": "lingerpotinvisibility2", + "invlingerpotlong": "lingerpotinvisibility2", + "invlingerpotextended": "lingerpotinvisibility2", + "invlingerpotex": "lingerpotinvisibility2", + "invlingerpotlevel2": "lingerpotinvisibility2", + "aoepotioninvisibility2": "lingerpotinvisibility2", + "aoepotioninvisibilitylong": "lingerpotinvisibility2", + "aoepotioninvisibilityextended": "lingerpotinvisibility2", + "aoepotioninvisibilityex": "lingerpotinvisibility2", + "aoepotioninvisibilitylevel2": "lingerpotinvisibility2", + "aoepotioninvis2": "lingerpotinvisibility2", + "aoepotioninvislong": "lingerpotinvisibility2", + "aoepotioninvisextended": "lingerpotinvisibility2", + "aoepotioninvisex": "lingerpotinvisibility2", + "aoepotioninvislevel2": "lingerpotinvisibility2", + "aoepotioninvisible2": "lingerpotinvisibility2", + "aoepotioninvisiblelong": "lingerpotinvisibility2", + "aoepotioninvisibleextended": "lingerpotinvisibility2", + "aoepotioninvisibleex": "lingerpotinvisibility2", + "aoepotioninvisiblelevel2": "lingerpotinvisibility2", + "aoepotioninv2": "lingerpotinvisibility2", + "aoepotioninvlong": "lingerpotinvisibility2", + "aoepotioninvextended": "lingerpotinvisibility2", + "aoepotioninvex": "lingerpotinvisibility2", + "aoepotioninvlevel2": "lingerpotinvisibility2", + "invisibilityaoepoiont2": "lingerpotinvisibility2", + "invisibilityaoepoiontlong": "lingerpotinvisibility2", + "invisibilityaoepoiontextended": "lingerpotinvisibility2", + "invisibilityaoepoiontex": "lingerpotinvisibility2", + "invisibilityaoepoiontlevel2": "lingerpotinvisibility2", + "invisaoepoiont2": "lingerpotinvisibility2", + "invisaoepoiontlong": "lingerpotinvisibility2", + "invisaoepoiontextended": "lingerpotinvisibility2", + "invisaoepoiontex": "lingerpotinvisibility2", + "invisaoepoiontlevel2": "lingerpotinvisibility2", + "invisibleaoepoiont2": "lingerpotinvisibility2", + "invisibleaoepoiontlong": "lingerpotinvisibility2", + "invisibleaoepoiontextended": "lingerpotinvisibility2", + "invisibleaoepoiontex": "lingerpotinvisibility2", + "invisibleaoepoiontlevel2": "lingerpotinvisibility2", + "invaoepoiont2": "lingerpotinvisibility2", + "invaoepoiontlong": "lingerpotinvisibility2", + "invaoepoiontextended": "lingerpotinvisibility2", + "invaoepoiontex": "lingerpotinvisibility2", + "invaoepoiontlevel2": "lingerpotinvisibility2", + "aoepotinvisibility2": "lingerpotinvisibility2", + "aoepotinvisibilitylong": "lingerpotinvisibility2", + "aoepotinvisibilityextended": "lingerpotinvisibility2", + "aoepotinvisibilityex": "lingerpotinvisibility2", + "aoepotinvisibilitylevel2": "lingerpotinvisibility2", + "aoepotinvis2": "lingerpotinvisibility2", + "aoepotinvislong": "lingerpotinvisibility2", + "aoepotinvisextended": "lingerpotinvisibility2", + "aoepotinvisex": "lingerpotinvisibility2", + "aoepotinvislevel2": "lingerpotinvisibility2", + "aoepotinvisible2": "lingerpotinvisibility2", + "aoepotinvisiblelong": "lingerpotinvisibility2", + "aoepotinvisibleextended": "lingerpotinvisibility2", + "aoepotinvisibleex": "lingerpotinvisibility2", + "aoepotinvisiblelevel2": "lingerpotinvisibility2", + "aoepotinv2": "lingerpotinvisibility2", + "aoepotinvlong": "lingerpotinvisibility2", + "aoepotinvextended": "lingerpotinvisibility2", + "aoepotinvex": "lingerpotinvisibility2", + "aoepotinvlevel2": "lingerpotinvisibility2", + "invisibilityaoepot2": "lingerpotinvisibility2", + "invisibilityaoepotlong": "lingerpotinvisibility2", + "invisibilityaoepotextended": "lingerpotinvisibility2", + "invisibilityaoepotex": "lingerpotinvisibility2", + "invisibilityaoepotlevel2": "lingerpotinvisibility2", + "invisaoepot2": "lingerpotinvisibility2", + "invisaoepotlong": "lingerpotinvisibility2", + "invisaoepotextended": "lingerpotinvisibility2", + "invisaoepotex": "lingerpotinvisibility2", + "invisaoepotlevel2": "lingerpotinvisibility2", + "invisibleaoepot2": "lingerpotinvisibility2", + "invisibleaoepotlong": "lingerpotinvisibility2", + "invisibleaoepotextended": "lingerpotinvisibility2", + "invisibleaoepotex": "lingerpotinvisibility2", + "invisibleaoepotlevel2": "lingerpotinvisibility2", + "invaoepot2": "lingerpotinvisibility2", + "invaoepotlong": "lingerpotinvisibility2", + "invaoepotextended": "lingerpotinvisibility2", + "invaoepotex": "lingerpotinvisibility2", + "invaoepotlevel2": "lingerpotinvisibility2", + "areapotioninvisibility2": "lingerpotinvisibility2", + "areapotioninvisibilitylong": "lingerpotinvisibility2", + "areapotioninvisibilityextended": "lingerpotinvisibility2", + "areapotioninvisibilityex": "lingerpotinvisibility2", + "areapotioninvisibilitylevel2": "lingerpotinvisibility2", + "areapotioninvis2": "lingerpotinvisibility2", + "areapotioninvislong": "lingerpotinvisibility2", + "areapotioninvisextended": "lingerpotinvisibility2", + "areapotioninvisex": "lingerpotinvisibility2", + "areapotioninvislevel2": "lingerpotinvisibility2", + "areapotioninvisible2": "lingerpotinvisibility2", + "areapotioninvisiblelong": "lingerpotinvisibility2", + "areapotioninvisibleextended": "lingerpotinvisibility2", + "areapotioninvisibleex": "lingerpotinvisibility2", + "areapotioninvisiblelevel2": "lingerpotinvisibility2", + "areapotioninv2": "lingerpotinvisibility2", + "areapotioninvlong": "lingerpotinvisibility2", + "areapotioninvextended": "lingerpotinvisibility2", + "areapotioninvex": "lingerpotinvisibility2", + "areapotioninvlevel2": "lingerpotinvisibility2", + "invisibilityareapotion2": "lingerpotinvisibility2", + "invisibilityareapotionlong": "lingerpotinvisibility2", + "invisibilityareapotionextended": "lingerpotinvisibility2", + "invisibilityareapotionex": "lingerpotinvisibility2", + "invisibilityareapotionlevel2": "lingerpotinvisibility2", + "invisareapotion2": "lingerpotinvisibility2", + "invisareapotionlong": "lingerpotinvisibility2", + "invisareapotionextended": "lingerpotinvisibility2", + "invisareapotionex": "lingerpotinvisibility2", + "invisareapotionlevel2": "lingerpotinvisibility2", + "invisibleareapotion2": "lingerpotinvisibility2", + "invisibleareapotionlong": "lingerpotinvisibility2", + "invisibleareapotionextended": "lingerpotinvisibility2", + "invisibleareapotionex": "lingerpotinvisibility2", + "invisibleareapotionlevel2": "lingerpotinvisibility2", + "invareapotion2": "lingerpotinvisibility2", + "invareapotionlong": "lingerpotinvisibility2", + "invareapotionextended": "lingerpotinvisibility2", + "invareapotionex": "lingerpotinvisibility2", + "invareapotionlevel2": "lingerpotinvisibility2", + "areapotinvisibility2": "lingerpotinvisibility2", + "areapotinvisibilitylong": "lingerpotinvisibility2", + "areapotinvisibilityextended": "lingerpotinvisibility2", + "areapotinvisibilityex": "lingerpotinvisibility2", + "areapotinvisibilitylevel2": "lingerpotinvisibility2", + "areapotinvis2": "lingerpotinvisibility2", + "areapotinvislong": "lingerpotinvisibility2", + "areapotinvisextended": "lingerpotinvisibility2", + "areapotinvisex": "lingerpotinvisibility2", + "areapotinvislevel2": "lingerpotinvisibility2", + "areapotinvisible2": "lingerpotinvisibility2", + "areapotinvisiblelong": "lingerpotinvisibility2", + "areapotinvisibleextended": "lingerpotinvisibility2", + "areapotinvisibleex": "lingerpotinvisibility2", + "areapotinvisiblelevel2": "lingerpotinvisibility2", + "areapotinv2": "lingerpotinvisibility2", + "areapotinvlong": "lingerpotinvisibility2", + "areapotinvextended": "lingerpotinvisibility2", + "areapotinvex": "lingerpotinvisibility2", + "areapotinvlevel2": "lingerpotinvisibility2", + "invisibilityareapot2": "lingerpotinvisibility2", + "invisibilityareapotlong": "lingerpotinvisibility2", + "invisibilityareapotextended": "lingerpotinvisibility2", + "invisibilityareapotex": "lingerpotinvisibility2", + "invisibilityareapotlevel2": "lingerpotinvisibility2", + "invisareapot2": "lingerpotinvisibility2", + "invisareapotlong": "lingerpotinvisibility2", + "invisareapotextended": "lingerpotinvisibility2", + "invisareapotex": "lingerpotinvisibility2", + "invisareapotlevel2": "lingerpotinvisibility2", + "invisibleareapot2": "lingerpotinvisibility2", + "invisibleareapotlong": "lingerpotinvisibility2", + "invisibleareapotextended": "lingerpotinvisibility2", + "invisibleareapotex": "lingerpotinvisibility2", + "invisibleareapotlevel2": "lingerpotinvisibility2", + "invareapot2": "lingerpotinvisibility2", + "invareapotlong": "lingerpotinvisibility2", + "invareapotextended": "lingerpotinvisibility2", + "invareapotex": "lingerpotinvisibility2", + "invareapotlevel2": "lingerpotinvisibility2", + "cloudpotioninvisibility2": "lingerpotinvisibility2", + "cloudpotioninvisibilitylong": "lingerpotinvisibility2", + "cloudpotioninvisibilityextended": "lingerpotinvisibility2", + "cloudpotioninvisibilityex": "lingerpotinvisibility2", + "cloudpotioninvisibilitylevel2": "lingerpotinvisibility2", + "cloudpotioninvis2": "lingerpotinvisibility2", + "cloudpotioninvislong": "lingerpotinvisibility2", + "cloudpotioninvisextended": "lingerpotinvisibility2", + "cloudpotioninvisex": "lingerpotinvisibility2", + "cloudpotioninvislevel2": "lingerpotinvisibility2", + "cloudpotioninvisible2": "lingerpotinvisibility2", + "cloudpotioninvisiblelong": "lingerpotinvisibility2", + "cloudpotioninvisibleextended": "lingerpotinvisibility2", + "cloudpotioninvisibleex": "lingerpotinvisibility2", + "cloudpotioninvisiblelevel2": "lingerpotinvisibility2", + "cloudpotioninv2": "lingerpotinvisibility2", + "cloudpotioninvlong": "lingerpotinvisibility2", + "cloudpotioninvextended": "lingerpotinvisibility2", + "cloudpotioninvex": "lingerpotinvisibility2", + "cloudpotioninvlevel2": "lingerpotinvisibility2", + "invisibilitycloudpotion2": "lingerpotinvisibility2", + "invisibilitycloudpotionlong": "lingerpotinvisibility2", + "invisibilitycloudpotionextended": "lingerpotinvisibility2", + "invisibilitycloudpotionex": "lingerpotinvisibility2", + "invisibilitycloudpotionlevel2": "lingerpotinvisibility2", + "inviscloudpotion2": "lingerpotinvisibility2", + "inviscloudpotionlong": "lingerpotinvisibility2", + "inviscloudpotionextended": "lingerpotinvisibility2", + "inviscloudpotionex": "lingerpotinvisibility2", + "inviscloudpotionlevel2": "lingerpotinvisibility2", + "invisiblecloudpotion2": "lingerpotinvisibility2", + "invisiblecloudpotionlong": "lingerpotinvisibility2", + "invisiblecloudpotionextended": "lingerpotinvisibility2", + "invisiblecloudpotionex": "lingerpotinvisibility2", + "invisiblecloudpotionlevel2": "lingerpotinvisibility2", + "invcloudpotion2": "lingerpotinvisibility2", + "invcloudpotionlong": "lingerpotinvisibility2", + "invcloudpotionextended": "lingerpotinvisibility2", + "invcloudpotionex": "lingerpotinvisibility2", + "invcloudpotionlevel2": "lingerpotinvisibility2", + "cloudpotinvisibility2": "lingerpotinvisibility2", + "cloudpotinvisibilitylong": "lingerpotinvisibility2", + "cloudpotinvisibilityextended": "lingerpotinvisibility2", + "cloudpotinvisibilityex": "lingerpotinvisibility2", + "cloudpotinvisibilitylevel2": "lingerpotinvisibility2", + "cloudpotinvis2": "lingerpotinvisibility2", + "cloudpotinvislong": "lingerpotinvisibility2", + "cloudpotinvisextended": "lingerpotinvisibility2", + "cloudpotinvisex": "lingerpotinvisibility2", + "cloudpotinvislevel2": "lingerpotinvisibility2", + "cloudpotinvisible2": "lingerpotinvisibility2", + "cloudpotinvisiblelong": "lingerpotinvisibility2", + "cloudpotinvisibleextended": "lingerpotinvisibility2", + "cloudpotinvisibleex": "lingerpotinvisibility2", + "cloudpotinvisiblelevel2": "lingerpotinvisibility2", + "cloudpotinv2": "lingerpotinvisibility2", + "cloudpotinvlong": "lingerpotinvisibility2", + "cloudpotinvextended": "lingerpotinvisibility2", + "cloudpotinvex": "lingerpotinvisibility2", + "cloudpotinvlevel2": "lingerpotinvisibility2", + "invisibilitycloudpot2": "lingerpotinvisibility2", + "invisibilitycloudpotlong": "lingerpotinvisibility2", + "invisibilitycloudpotextended": "lingerpotinvisibility2", + "invisibilitycloudpotex": "lingerpotinvisibility2", + "invisibilitycloudpotlevel2": "lingerpotinvisibility2", + "inviscloudpot2": "lingerpotinvisibility2", + "inviscloudpotlong": "lingerpotinvisibility2", + "inviscloudpotextended": "lingerpotinvisibility2", + "inviscloudpotex": "lingerpotinvisibility2", + "inviscloudpotlevel2": "lingerpotinvisibility2", + "invisiblecloudpot2": "lingerpotinvisibility2", + "invisiblecloudpotlong": "lingerpotinvisibility2", + "invisiblecloudpotextended": "lingerpotinvisibility2", + "invisiblecloudpotex": "lingerpotinvisibility2", + "invisiblecloudpotlevel2": "lingerpotinvisibility2", + "invcloudpot2": "lingerpotinvisibility2", + "invcloudpotlong": "lingerpotinvisibility2", + "invcloudpotextended": "lingerpotinvisibility2", + "invcloudpotex": "lingerpotinvisibility2", + "invcloudpotlevel2": "lingerpotinvisibility2", + "arrowinvisibility2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_invisibility", + "bukkitType": "invisibility", + "isStrong": false, + "isLong": true + } + }, + "arrowinvisibilitylong": "arrowinvisibility2", + "arrowinvisibilityextended": "arrowinvisibility2", + "arrowinvisibilityex": "arrowinvisibility2", + "arrowinvisibilitylevel2": "arrowinvisibility2", + "arrowinvis2": "arrowinvisibility2", + "arrowinvislong": "arrowinvisibility2", + "arrowinvisextended": "arrowinvisibility2", + "arrowinvisex": "arrowinvisibility2", + "arrowinvislevel2": "arrowinvisibility2", + "arrowinvisible2": "arrowinvisibility2", + "arrowinvisiblelong": "arrowinvisibility2", + "arrowinvisibleextended": "arrowinvisibility2", + "arrowinvisibleex": "arrowinvisibility2", + "arrowinvisiblelevel2": "arrowinvisibility2", + "arrowinv2": "arrowinvisibility2", + "arrowinvlong": "arrowinvisibility2", + "arrowinvextended": "arrowinvisibility2", + "arrowinvex": "arrowinvisibility2", + "arrowinvlevel2": "arrowinvisibility2", + "invisibilityarrow2": "arrowinvisibility2", + "invisibilityarrowlong": "arrowinvisibility2", + "invisibilityarrowextended": "arrowinvisibility2", + "invisibilityarrowex": "arrowinvisibility2", + "invisibilityarrowlevel2": "arrowinvisibility2", + "invisarrow2": "arrowinvisibility2", + "invisarrowlong": "arrowinvisibility2", + "invisarrowextended": "arrowinvisibility2", + "invisarrowex": "arrowinvisibility2", + "invisarrowlevel2": "arrowinvisibility2", + "invisiblearrow2": "arrowinvisibility2", + "invisiblearrowlong": "arrowinvisibility2", + "invisiblearrowextended": "arrowinvisibility2", + "invisiblearrowex": "arrowinvisibility2", + "invisiblearrowlevel2": "arrowinvisibility2", + "invarrow2": "arrowinvisibility2", + "invarrowlong": "arrowinvisibility2", + "invarrowextended": "arrowinvisibility2", + "invarrowex": "arrowinvisibility2", + "invarrowlevel2": "arrowinvisibility2", + "leapingpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": false + } + }, + "leappotion": "leapingpotion", + "leapingpot": "leapingpotion", + "leappot": "leapingpotion", + "potionofleaping": "leapingpotion", + "potionofleap": "leapingpotion", + "potofleaping": "leapingpotion", + "potofleap": "leapingpotion", + "splashleapingpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": false + } + }, + "splashleappotion": "splashleapingpotion", + "splleapingpotion": "splashleapingpotion", + "splleappotion": "splashleapingpotion", + "leapingsplashpotion": "splashleapingpotion", + "leapsplashpotion": "splashleapingpotion", + "splashleapingpot": "splashleapingpotion", + "splashleappot": "splashleapingpotion", + "splleapingpot": "splashleapingpotion", + "splleappot": "splashleapingpotion", + "leapingsplashpot": "splashleapingpotion", + "leapsplashpot": "splashleapingpotion", + "lingerpotleaping": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": false + } + }, + "lingerpotleap": "lingerpotleaping", + "leapinglingerpot": "lingerpotleaping", + "leaplingerpot": "lingerpotleaping", + "aoepotionleaping": "lingerpotleaping", + "aoepotionleap": "lingerpotleaping", + "leapingaoepoiont": "lingerpotleaping", + "leapaoepoiont": "lingerpotleaping", + "aoepotleaping": "lingerpotleaping", + "aoepotleap": "lingerpotleaping", + "leapingaoepot": "lingerpotleaping", + "leapaoepot": "lingerpotleaping", + "areapotionleaping": "lingerpotleaping", + "areapotionleap": "lingerpotleaping", + "leapingareapotion": "lingerpotleaping", + "leapareapotion": "lingerpotleaping", + "areapotleaping": "lingerpotleaping", + "areapotleap": "lingerpotleaping", + "leapingareapot": "lingerpotleaping", + "leapareapot": "lingerpotleaping", + "cloudpotionleaping": "lingerpotleaping", + "cloudpotionleap": "lingerpotleaping", + "leapingcloudpotion": "lingerpotleaping", + "leapcloudpotion": "lingerpotleaping", + "cloudpotleaping": "lingerpotleaping", + "cloudpotleap": "lingerpotleaping", + "leapingcloudpot": "lingerpotleaping", + "leapcloudpot": "lingerpotleaping", + "arrowleaping": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": false + } + }, + "arrowleap": "arrowleaping", + "leapingarrow": "arrowleaping", + "leaparrow": "arrowleaping", + "leapingiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_leaping", + "bukkitType": "leaping", + "isStrong": true, + "isLong": false + } + }, + "leapingstrongpotion": "leapingiipotion", + "leapingleveliipotion": "leapingiipotion", + "leapiipotion": "leapingiipotion", + "leapstrongpotion": "leapingiipotion", + "leapleveliipotion": "leapingiipotion", + "leapingiipot": "leapingiipotion", + "leapingstrongpot": "leapingiipotion", + "leapingleveliipot": "leapingiipotion", + "leapiipot": "leapingiipotion", + "leapstrongpot": "leapingiipotion", + "leapleveliipot": "leapingiipotion", + "potionofleapingii": "leapingiipotion", + "potionofleapingstrong": "leapingiipotion", + "potionofleapinglevelii": "leapingiipotion", + "potionofleapii": "leapingiipotion", + "potionofleapstrong": "leapingiipotion", + "potionofleaplevelii": "leapingiipotion", + "potofleapingii": "leapingiipotion", + "potofleapingstrong": "leapingiipotion", + "potofleapinglevelii": "leapingiipotion", + "potofleapii": "leapingiipotion", + "potofleapstrong": "leapingiipotion", + "potofleaplevelii": "leapingiipotion", + "splashleapingiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_leaping", + "bukkitType": "leaping", + "isStrong": true, + "isLong": false + } + }, + "splashleapingstrongpotion": "splashleapingiipotion", + "splashleapingleveliipotion": "splashleapingiipotion", + "splashleapiipotion": "splashleapingiipotion", + "splashleapstrongpotion": "splashleapingiipotion", + "splashleapleveliipotion": "splashleapingiipotion", + "splleapingiipotion": "splashleapingiipotion", + "splleapingstrongpotion": "splashleapingiipotion", + "splleapingleveliipotion": "splashleapingiipotion", + "splleapiipotion": "splashleapingiipotion", + "splleapstrongpotion": "splashleapingiipotion", + "splleapleveliipotion": "splashleapingiipotion", + "leapingiisplashpotion": "splashleapingiipotion", + "leapingstrongsplashpotion": "splashleapingiipotion", + "leapingleveliisplashpotion": "splashleapingiipotion", + "leapiisplashpotion": "splashleapingiipotion", + "leapstrongsplashpotion": "splashleapingiipotion", + "leapleveliisplashpotion": "splashleapingiipotion", + "splashleapingiipot": "splashleapingiipotion", + "splashleapingstrongpot": "splashleapingiipotion", + "splashleapingleveliipot": "splashleapingiipotion", + "splashleapiipot": "splashleapingiipotion", + "splashleapstrongpot": "splashleapingiipotion", + "splashleapleveliipot": "splashleapingiipotion", + "splleapingiipot": "splashleapingiipotion", + "splleapingstrongpot": "splashleapingiipotion", + "splleapingleveliipot": "splashleapingiipotion", + "splleapiipot": "splashleapingiipotion", + "splleapstrongpot": "splashleapingiipotion", + "splleapleveliipot": "splashleapingiipotion", + "leapingiisplashpot": "splashleapingiipotion", + "leapingstrongsplashpot": "splashleapingiipotion", + "leapingleveliisplashpot": "splashleapingiipotion", + "leapiisplashpot": "splashleapingiipotion", + "leapstrongsplashpot": "splashleapingiipotion", + "leapleveliisplashpot": "splashleapingiipotion", + "lingerpotleapingii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_leaping", + "bukkitType": "leaping", + "isStrong": true, + "isLong": false + } + }, + "lingerpotleapingstrong": "lingerpotleapingii", + "lingerpotleapinglevelii": "lingerpotleapingii", + "lingerpotleapii": "lingerpotleapingii", + "lingerpotleapstrong": "lingerpotleapingii", + "lingerpotleaplevelii": "lingerpotleapingii", + "leapinglingerpotii": "lingerpotleapingii", + "leapinglingerpotstrong": "lingerpotleapingii", + "leapinglingerpotlevelii": "lingerpotleapingii", + "leaplingerpotii": "lingerpotleapingii", + "leaplingerpotstrong": "lingerpotleapingii", + "leaplingerpotlevelii": "lingerpotleapingii", + "aoepotionleapingii": "lingerpotleapingii", + "aoepotionleapingstrong": "lingerpotleapingii", + "aoepotionleapinglevelii": "lingerpotleapingii", + "aoepotionleapii": "lingerpotleapingii", + "aoepotionleapstrong": "lingerpotleapingii", + "aoepotionleaplevelii": "lingerpotleapingii", + "leapingaoepoiontii": "lingerpotleapingii", + "leapingaoepoiontstrong": "lingerpotleapingii", + "leapingaoepoiontlevelii": "lingerpotleapingii", + "leapaoepoiontii": "lingerpotleapingii", + "leapaoepoiontstrong": "lingerpotleapingii", + "leapaoepoiontlevelii": "lingerpotleapingii", + "aoepotleapingii": "lingerpotleapingii", + "aoepotleapingstrong": "lingerpotleapingii", + "aoepotleapinglevelii": "lingerpotleapingii", + "aoepotleapii": "lingerpotleapingii", + "aoepotleapstrong": "lingerpotleapingii", + "aoepotleaplevelii": "lingerpotleapingii", + "leapingaoepotii": "lingerpotleapingii", + "leapingaoepotstrong": "lingerpotleapingii", + "leapingaoepotlevelii": "lingerpotleapingii", + "leapaoepotii": "lingerpotleapingii", + "leapaoepotstrong": "lingerpotleapingii", + "leapaoepotlevelii": "lingerpotleapingii", + "areapotionleapingii": "lingerpotleapingii", + "areapotionleapingstrong": "lingerpotleapingii", + "areapotionleapinglevelii": "lingerpotleapingii", + "areapotionleapii": "lingerpotleapingii", + "areapotionleapstrong": "lingerpotleapingii", + "areapotionleaplevelii": "lingerpotleapingii", + "leapingareapotionii": "lingerpotleapingii", + "leapingareapotionstrong": "lingerpotleapingii", + "leapingareapotionlevelii": "lingerpotleapingii", + "leapareapotionii": "lingerpotleapingii", + "leapareapotionstrong": "lingerpotleapingii", + "leapareapotionlevelii": "lingerpotleapingii", + "areapotleapingii": "lingerpotleapingii", + "areapotleapingstrong": "lingerpotleapingii", + "areapotleapinglevelii": "lingerpotleapingii", + "areapotleapii": "lingerpotleapingii", + "areapotleapstrong": "lingerpotleapingii", + "areapotleaplevelii": "lingerpotleapingii", + "leapingareapotii": "lingerpotleapingii", + "leapingareapotstrong": "lingerpotleapingii", + "leapingareapotlevelii": "lingerpotleapingii", + "leapareapotii": "lingerpotleapingii", + "leapareapotstrong": "lingerpotleapingii", + "leapareapotlevelii": "lingerpotleapingii", + "cloudpotionleapingii": "lingerpotleapingii", + "cloudpotionleapingstrong": "lingerpotleapingii", + "cloudpotionleapinglevelii": "lingerpotleapingii", + "cloudpotionleapii": "lingerpotleapingii", + "cloudpotionleapstrong": "lingerpotleapingii", + "cloudpotionleaplevelii": "lingerpotleapingii", + "leapingcloudpotionii": "lingerpotleapingii", + "leapingcloudpotionstrong": "lingerpotleapingii", + "leapingcloudpotionlevelii": "lingerpotleapingii", + "leapcloudpotionii": "lingerpotleapingii", + "leapcloudpotionstrong": "lingerpotleapingii", + "leapcloudpotionlevelii": "lingerpotleapingii", + "cloudpotleapingii": "lingerpotleapingii", + "cloudpotleapingstrong": "lingerpotleapingii", + "cloudpotleapinglevelii": "lingerpotleapingii", + "cloudpotleapii": "lingerpotleapingii", + "cloudpotleapstrong": "lingerpotleapingii", + "cloudpotleaplevelii": "lingerpotleapingii", + "leapingcloudpotii": "lingerpotleapingii", + "leapingcloudpotstrong": "lingerpotleapingii", + "leapingcloudpotlevelii": "lingerpotleapingii", + "leapcloudpotii": "lingerpotleapingii", + "leapcloudpotstrong": "lingerpotleapingii", + "leapcloudpotlevelii": "lingerpotleapingii", + "arrowleapingii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_leaping", + "bukkitType": "leaping", + "isStrong": true, + "isLong": false + } + }, + "arrowleapingstrong": "arrowleapingii", + "arrowleapinglevelii": "arrowleapingii", + "arrowleapii": "arrowleapingii", + "arrowleapstrong": "arrowleapingii", + "arrowleaplevelii": "arrowleapingii", + "leapingarrowii": "arrowleapingii", + "leapingarrowstrong": "arrowleapingii", + "leapingarrowlevelii": "arrowleapingii", + "leaparrowii": "arrowleapingii", + "leaparrowstrong": "arrowleapingii", + "leaparrowlevelii": "arrowleapingii", + "leaping2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": true + } + }, + "leapinglongpotion": "leaping2potion", + "leapingextendedpotion": "leaping2potion", + "leapingexpotion": "leaping2potion", + "leapinglevel2potion": "leaping2potion", + "leap2potion": "leaping2potion", + "leaplongpotion": "leaping2potion", + "leapextendedpotion": "leaping2potion", + "leapexpotion": "leaping2potion", + "leaplevel2potion": "leaping2potion", + "leaping2pot": "leaping2potion", + "leapinglongpot": "leaping2potion", + "leapingextendedpot": "leaping2potion", + "leapingexpot": "leaping2potion", + "leapinglevel2pot": "leaping2potion", + "leap2pot": "leaping2potion", + "leaplongpot": "leaping2potion", + "leapextendedpot": "leaping2potion", + "leapexpot": "leaping2potion", + "leaplevel2pot": "leaping2potion", + "potionofleaping2": "leaping2potion", + "potionofleapinglong": "leaping2potion", + "potionofleapingextended": "leaping2potion", + "potionofleapingex": "leaping2potion", + "potionofleapinglevel2": "leaping2potion", + "potionofleap2": "leaping2potion", + "potionofleaplong": "leaping2potion", + "potionofleapextended": "leaping2potion", + "potionofleapex": "leaping2potion", + "potionofleaplevel2": "leaping2potion", + "potofleaping2": "leaping2potion", + "potofleapinglong": "leaping2potion", + "potofleapingextended": "leaping2potion", + "potofleapingex": "leaping2potion", + "potofleapinglevel2": "leaping2potion", + "potofleap2": "leaping2potion", + "potofleaplong": "leaping2potion", + "potofleapextended": "leaping2potion", + "potofleapex": "leaping2potion", + "potofleaplevel2": "leaping2potion", + "splashleaping2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": true + } + }, + "splashleapinglongpotion": "splashleaping2potion", + "splashleapingextendedpotion": "splashleaping2potion", + "splashleapingexpotion": "splashleaping2potion", + "splashleapinglevel2potion": "splashleaping2potion", + "splashleap2potion": "splashleaping2potion", + "splashleaplongpotion": "splashleaping2potion", + "splashleapextendedpotion": "splashleaping2potion", + "splashleapexpotion": "splashleaping2potion", + "splashleaplevel2potion": "splashleaping2potion", + "splleaping2potion": "splashleaping2potion", + "splleapinglongpotion": "splashleaping2potion", + "splleapingextendedpotion": "splashleaping2potion", + "splleapingexpotion": "splashleaping2potion", + "splleapinglevel2potion": "splashleaping2potion", + "splleap2potion": "splashleaping2potion", + "splleaplongpotion": "splashleaping2potion", + "splleapextendedpotion": "splashleaping2potion", + "splleapexpotion": "splashleaping2potion", + "splleaplevel2potion": "splashleaping2potion", + "leaping2splashpotion": "splashleaping2potion", + "leapinglongsplashpotion": "splashleaping2potion", + "leapingextendedsplashpotion": "splashleaping2potion", + "leapingexsplashpotion": "splashleaping2potion", + "leapinglevel2splashpotion": "splashleaping2potion", + "leap2splashpotion": "splashleaping2potion", + "leaplongsplashpotion": "splashleaping2potion", + "leapextendedsplashpotion": "splashleaping2potion", + "leapexsplashpotion": "splashleaping2potion", + "leaplevel2splashpotion": "splashleaping2potion", + "splashleaping2pot": "splashleaping2potion", + "splashleapinglongpot": "splashleaping2potion", + "splashleapingextendedpot": "splashleaping2potion", + "splashleapingexpot": "splashleaping2potion", + "splashleapinglevel2pot": "splashleaping2potion", + "splashleap2pot": "splashleaping2potion", + "splashleaplongpot": "splashleaping2potion", + "splashleapextendedpot": "splashleaping2potion", + "splashleapexpot": "splashleaping2potion", + "splashleaplevel2pot": "splashleaping2potion", + "splleaping2pot": "splashleaping2potion", + "splleapinglongpot": "splashleaping2potion", + "splleapingextendedpot": "splashleaping2potion", + "splleapingexpot": "splashleaping2potion", + "splleapinglevel2pot": "splashleaping2potion", + "splleap2pot": "splashleaping2potion", + "splleaplongpot": "splashleaping2potion", + "splleapextendedpot": "splashleaping2potion", + "splleapexpot": "splashleaping2potion", + "splleaplevel2pot": "splashleaping2potion", + "leaping2splashpot": "splashleaping2potion", + "leapinglongsplashpot": "splashleaping2potion", + "leapingextendedsplashpot": "splashleaping2potion", + "leapingexsplashpot": "splashleaping2potion", + "leapinglevel2splashpot": "splashleaping2potion", + "leap2splashpot": "splashleaping2potion", + "leaplongsplashpot": "splashleaping2potion", + "leapextendedsplashpot": "splashleaping2potion", + "leapexsplashpot": "splashleaping2potion", + "leaplevel2splashpot": "splashleaping2potion", + "lingerpotleaping2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": true + } + }, + "lingerpotleapinglong": "lingerpotleaping2", + "lingerpotleapingextended": "lingerpotleaping2", + "lingerpotleapingex": "lingerpotleaping2", + "lingerpotleapinglevel2": "lingerpotleaping2", + "lingerpotleap2": "lingerpotleaping2", + "lingerpotleaplong": "lingerpotleaping2", + "lingerpotleapextended": "lingerpotleaping2", + "lingerpotleapex": "lingerpotleaping2", + "lingerpotleaplevel2": "lingerpotleaping2", + "leapinglingerpot2": "lingerpotleaping2", + "leapinglingerpotlong": "lingerpotleaping2", + "leapinglingerpotextended": "lingerpotleaping2", + "leapinglingerpotex": "lingerpotleaping2", + "leapinglingerpotlevel2": "lingerpotleaping2", + "leaplingerpot2": "lingerpotleaping2", + "leaplingerpotlong": "lingerpotleaping2", + "leaplingerpotextended": "lingerpotleaping2", + "leaplingerpotex": "lingerpotleaping2", + "leaplingerpotlevel2": "lingerpotleaping2", + "aoepotionleaping2": "lingerpotleaping2", + "aoepotionleapinglong": "lingerpotleaping2", + "aoepotionleapingextended": "lingerpotleaping2", + "aoepotionleapingex": "lingerpotleaping2", + "aoepotionleapinglevel2": "lingerpotleaping2", + "aoepotionleap2": "lingerpotleaping2", + "aoepotionleaplong": "lingerpotleaping2", + "aoepotionleapextended": "lingerpotleaping2", + "aoepotionleapex": "lingerpotleaping2", + "aoepotionleaplevel2": "lingerpotleaping2", + "leapingaoepoiont2": "lingerpotleaping2", + "leapingaoepoiontlong": "lingerpotleaping2", + "leapingaoepoiontextended": "lingerpotleaping2", + "leapingaoepoiontex": "lingerpotleaping2", + "leapingaoepoiontlevel2": "lingerpotleaping2", + "leapaoepoiont2": "lingerpotleaping2", + "leapaoepoiontlong": "lingerpotleaping2", + "leapaoepoiontextended": "lingerpotleaping2", + "leapaoepoiontex": "lingerpotleaping2", + "leapaoepoiontlevel2": "lingerpotleaping2", + "aoepotleaping2": "lingerpotleaping2", + "aoepotleapinglong": "lingerpotleaping2", + "aoepotleapingextended": "lingerpotleaping2", + "aoepotleapingex": "lingerpotleaping2", + "aoepotleapinglevel2": "lingerpotleaping2", + "aoepotleap2": "lingerpotleaping2", + "aoepotleaplong": "lingerpotleaping2", + "aoepotleapextended": "lingerpotleaping2", + "aoepotleapex": "lingerpotleaping2", + "aoepotleaplevel2": "lingerpotleaping2", + "leapingaoepot2": "lingerpotleaping2", + "leapingaoepotlong": "lingerpotleaping2", + "leapingaoepotextended": "lingerpotleaping2", + "leapingaoepotex": "lingerpotleaping2", + "leapingaoepotlevel2": "lingerpotleaping2", + "leapaoepot2": "lingerpotleaping2", + "leapaoepotlong": "lingerpotleaping2", + "leapaoepotextended": "lingerpotleaping2", + "leapaoepotex": "lingerpotleaping2", + "leapaoepotlevel2": "lingerpotleaping2", + "areapotionleaping2": "lingerpotleaping2", + "areapotionleapinglong": "lingerpotleaping2", + "areapotionleapingextended": "lingerpotleaping2", + "areapotionleapingex": "lingerpotleaping2", + "areapotionleapinglevel2": "lingerpotleaping2", + "areapotionleap2": "lingerpotleaping2", + "areapotionleaplong": "lingerpotleaping2", + "areapotionleapextended": "lingerpotleaping2", + "areapotionleapex": "lingerpotleaping2", + "areapotionleaplevel2": "lingerpotleaping2", + "leapingareapotion2": "lingerpotleaping2", + "leapingareapotionlong": "lingerpotleaping2", + "leapingareapotionextended": "lingerpotleaping2", + "leapingareapotionex": "lingerpotleaping2", + "leapingareapotionlevel2": "lingerpotleaping2", + "leapareapotion2": "lingerpotleaping2", + "leapareapotionlong": "lingerpotleaping2", + "leapareapotionextended": "lingerpotleaping2", + "leapareapotionex": "lingerpotleaping2", + "leapareapotionlevel2": "lingerpotleaping2", + "areapotleaping2": "lingerpotleaping2", + "areapotleapinglong": "lingerpotleaping2", + "areapotleapingextended": "lingerpotleaping2", + "areapotleapingex": "lingerpotleaping2", + "areapotleapinglevel2": "lingerpotleaping2", + "areapotleap2": "lingerpotleaping2", + "areapotleaplong": "lingerpotleaping2", + "areapotleapextended": "lingerpotleaping2", + "areapotleapex": "lingerpotleaping2", + "areapotleaplevel2": "lingerpotleaping2", + "leapingareapot2": "lingerpotleaping2", + "leapingareapotlong": "lingerpotleaping2", + "leapingareapotextended": "lingerpotleaping2", + "leapingareapotex": "lingerpotleaping2", + "leapingareapotlevel2": "lingerpotleaping2", + "leapareapot2": "lingerpotleaping2", + "leapareapotlong": "lingerpotleaping2", + "leapareapotextended": "lingerpotleaping2", + "leapareapotex": "lingerpotleaping2", + "leapareapotlevel2": "lingerpotleaping2", + "cloudpotionleaping2": "lingerpotleaping2", + "cloudpotionleapinglong": "lingerpotleaping2", + "cloudpotionleapingextended": "lingerpotleaping2", + "cloudpotionleapingex": "lingerpotleaping2", + "cloudpotionleapinglevel2": "lingerpotleaping2", + "cloudpotionleap2": "lingerpotleaping2", + "cloudpotionleaplong": "lingerpotleaping2", + "cloudpotionleapextended": "lingerpotleaping2", + "cloudpotionleapex": "lingerpotleaping2", + "cloudpotionleaplevel2": "lingerpotleaping2", + "leapingcloudpotion2": "lingerpotleaping2", + "leapingcloudpotionlong": "lingerpotleaping2", + "leapingcloudpotionextended": "lingerpotleaping2", + "leapingcloudpotionex": "lingerpotleaping2", + "leapingcloudpotionlevel2": "lingerpotleaping2", + "leapcloudpotion2": "lingerpotleaping2", + "leapcloudpotionlong": "lingerpotleaping2", + "leapcloudpotionextended": "lingerpotleaping2", + "leapcloudpotionex": "lingerpotleaping2", + "leapcloudpotionlevel2": "lingerpotleaping2", + "cloudpotleaping2": "lingerpotleaping2", + "cloudpotleapinglong": "lingerpotleaping2", + "cloudpotleapingextended": "lingerpotleaping2", + "cloudpotleapingex": "lingerpotleaping2", + "cloudpotleapinglevel2": "lingerpotleaping2", + "cloudpotleap2": "lingerpotleaping2", + "cloudpotleaplong": "lingerpotleaping2", + "cloudpotleapextended": "lingerpotleaping2", + "cloudpotleapex": "lingerpotleaping2", + "cloudpotleaplevel2": "lingerpotleaping2", + "leapingcloudpot2": "lingerpotleaping2", + "leapingcloudpotlong": "lingerpotleaping2", + "leapingcloudpotextended": "lingerpotleaping2", + "leapingcloudpotex": "lingerpotleaping2", + "leapingcloudpotlevel2": "lingerpotleaping2", + "leapcloudpot2": "lingerpotleaping2", + "leapcloudpotlong": "lingerpotleaping2", + "leapcloudpotextended": "lingerpotleaping2", + "leapcloudpotex": "lingerpotleaping2", + "leapcloudpotlevel2": "lingerpotleaping2", + "arrowleaping2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_leaping", + "bukkitType": "leaping", + "isStrong": false, + "isLong": true + } + }, + "arrowleapinglong": "arrowleaping2", + "arrowleapingextended": "arrowleaping2", + "arrowleapingex": "arrowleaping2", + "arrowleapinglevel2": "arrowleaping2", + "arrowleap2": "arrowleaping2", + "arrowleaplong": "arrowleaping2", + "arrowleapextended": "arrowleaping2", + "arrowleapex": "arrowleaping2", + "arrowleaplevel2": "arrowleaping2", + "leapingarrow2": "arrowleaping2", + "leapingarrowlong": "arrowleaping2", + "leapingarrowextended": "arrowleaping2", + "leapingarrowex": "arrowleaping2", + "leapingarrowlevel2": "arrowleaping2", + "leaparrow2": "arrowleaping2", + "leaparrowlong": "arrowleaping2", + "leaparrowextended": "arrowleaping2", + "leaparrowex": "arrowleaping2", + "leaparrowlevel2": "arrowleaping2", + "fireresistpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": false + } + }, + "firerespotion": "fireresistpotion", + "fireresistancepotion": "fireresistpotion", + "fireresistpot": "fireresistpotion", + "firerespot": "fireresistpotion", + "fireresistancepot": "fireresistpotion", + "potionoffireresist": "fireresistpotion", + "potionoffireres": "fireresistpotion", + "potionoffireresistance": "fireresistpotion", + "potoffireresist": "fireresistpotion", + "potoffireres": "fireresistpotion", + "potoffireresistance": "fireresistpotion", + "splashfireresistpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": false + } + }, + "splashfirerespotion": "splashfireresistpotion", + "splashfireresistancepotion": "splashfireresistpotion", + "splfireresistpotion": "splashfireresistpotion", + "splfirerespotion": "splashfireresistpotion", + "splfireresistancepotion": "splashfireresistpotion", + "fireresistsplashpotion": "splashfireresistpotion", + "fireressplashpotion": "splashfireresistpotion", + "fireresistancesplashpotion": "splashfireresistpotion", + "splashfireresistpot": "splashfireresistpotion", + "splashfirerespot": "splashfireresistpotion", + "splashfireresistancepot": "splashfireresistpotion", + "splfireresistpot": "splashfireresistpotion", + "splfirerespot": "splashfireresistpotion", + "splfireresistancepot": "splashfireresistpotion", + "fireresistsplashpot": "splashfireresistpotion", + "fireressplashpot": "splashfireresistpotion", + "fireresistancesplashpot": "splashfireresistpotion", + "lingerpotfireresist": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": false + } + }, + "lingerpotfireres": "lingerpotfireresist", + "lingerpotfireresistance": "lingerpotfireresist", + "fireresistlingerpot": "lingerpotfireresist", + "firereslingerpot": "lingerpotfireresist", + "fireresistancelingerpot": "lingerpotfireresist", + "aoepotionfireresist": "lingerpotfireresist", + "aoepotionfireres": "lingerpotfireresist", + "aoepotionfireresistance": "lingerpotfireresist", + "fireresistaoepoiont": "lingerpotfireresist", + "fireresaoepoiont": "lingerpotfireresist", + "fireresistanceaoepoiont": "lingerpotfireresist", + "aoepotfireresist": "lingerpotfireresist", + "aoepotfireres": "lingerpotfireresist", + "aoepotfireresistance": "lingerpotfireresist", + "fireresistaoepot": "lingerpotfireresist", + "fireresaoepot": "lingerpotfireresist", + "fireresistanceaoepot": "lingerpotfireresist", + "areapotionfireresist": "lingerpotfireresist", + "areapotionfireres": "lingerpotfireresist", + "areapotionfireresistance": "lingerpotfireresist", + "fireresistareapotion": "lingerpotfireresist", + "fireresareapotion": "lingerpotfireresist", + "fireresistanceareapotion": "lingerpotfireresist", + "areapotfireresist": "lingerpotfireresist", + "areapotfireres": "lingerpotfireresist", + "areapotfireresistance": "lingerpotfireresist", + "fireresistareapot": "lingerpotfireresist", + "fireresareapot": "lingerpotfireresist", + "fireresistanceareapot": "lingerpotfireresist", + "cloudpotionfireresist": "lingerpotfireresist", + "cloudpotionfireres": "lingerpotfireresist", + "cloudpotionfireresistance": "lingerpotfireresist", + "fireresistcloudpotion": "lingerpotfireresist", + "firerescloudpotion": "lingerpotfireresist", + "fireresistancecloudpotion": "lingerpotfireresist", + "cloudpotfireresist": "lingerpotfireresist", + "cloudpotfireres": "lingerpotfireresist", + "cloudpotfireresistance": "lingerpotfireresist", + "fireresistcloudpot": "lingerpotfireresist", + "firerescloudpot": "lingerpotfireresist", + "fireresistancecloudpot": "lingerpotfireresist", + "arrowfireresist": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": false + } + }, + "arrowfireres": "arrowfireresist", + "arrowfireresistance": "arrowfireresist", + "fireresistarrow": "arrowfireresist", + "fireresarrow": "arrowfireresist", + "fireresistancearrow": "arrowfireresist", + "fireresist2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": true + } + }, + "fireresistlongpotion": "fireresist2potion", + "fireresistextendedpotion": "fireresist2potion", + "fireresistexpotion": "fireresist2potion", + "fireresistlevel2potion": "fireresist2potion", + "fireres2potion": "fireresist2potion", + "firereslongpotion": "fireresist2potion", + "fireresextendedpotion": "fireresist2potion", + "fireresexpotion": "fireresist2potion", + "firereslevel2potion": "fireresist2potion", + "fireresistance2potion": "fireresist2potion", + "fireresistancelongpotion": "fireresist2potion", + "fireresistanceextendedpotion": "fireresist2potion", + "fireresistanceexpotion": "fireresist2potion", + "fireresistancelevel2potion": "fireresist2potion", + "fireresist2pot": "fireresist2potion", + "fireresistlongpot": "fireresist2potion", + "fireresistextendedpot": "fireresist2potion", + "fireresistexpot": "fireresist2potion", + "fireresistlevel2pot": "fireresist2potion", + "fireres2pot": "fireresist2potion", + "firereslongpot": "fireresist2potion", + "fireresextendedpot": "fireresist2potion", + "fireresexpot": "fireresist2potion", + "firereslevel2pot": "fireresist2potion", + "fireresistance2pot": "fireresist2potion", + "fireresistancelongpot": "fireresist2potion", + "fireresistanceextendedpot": "fireresist2potion", + "fireresistanceexpot": "fireresist2potion", + "fireresistancelevel2pot": "fireresist2potion", + "potionoffireresist2": "fireresist2potion", + "potionoffireresistlong": "fireresist2potion", + "potionoffireresistextended": "fireresist2potion", + "potionoffireresistex": "fireresist2potion", + "potionoffireresistlevel2": "fireresist2potion", + "potionoffireres2": "fireresist2potion", + "potionoffirereslong": "fireresist2potion", + "potionoffireresextended": "fireresist2potion", + "potionoffireresex": "fireresist2potion", + "potionoffirereslevel2": "fireresist2potion", + "potionoffireresistance2": "fireresist2potion", + "potionoffireresistancelong": "fireresist2potion", + "potionoffireresistanceextended": "fireresist2potion", + "potionoffireresistanceex": "fireresist2potion", + "potionoffireresistancelevel2": "fireresist2potion", + "potoffireresist2": "fireresist2potion", + "potoffireresistlong": "fireresist2potion", + "potoffireresistextended": "fireresist2potion", + "potoffireresistex": "fireresist2potion", + "potoffireresistlevel2": "fireresist2potion", + "potoffireres2": "fireresist2potion", + "potoffirereslong": "fireresist2potion", + "potoffireresextended": "fireresist2potion", + "potoffireresex": "fireresist2potion", + "potoffirereslevel2": "fireresist2potion", + "potoffireresistance2": "fireresist2potion", + "potoffireresistancelong": "fireresist2potion", + "potoffireresistanceextended": "fireresist2potion", + "potoffireresistanceex": "fireresist2potion", + "potoffireresistancelevel2": "fireresist2potion", + "splashfireresist2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": true + } + }, + "splashfireresistlongpotion": "splashfireresist2potion", + "splashfireresistextendedpotion": "splashfireresist2potion", + "splashfireresistexpotion": "splashfireresist2potion", + "splashfireresistlevel2potion": "splashfireresist2potion", + "splashfireres2potion": "splashfireresist2potion", + "splashfirereslongpotion": "splashfireresist2potion", + "splashfireresextendedpotion": "splashfireresist2potion", + "splashfireresexpotion": "splashfireresist2potion", + "splashfirereslevel2potion": "splashfireresist2potion", + "splashfireresistance2potion": "splashfireresist2potion", + "splashfireresistancelongpotion": "splashfireresist2potion", + "splashfireresistanceextendedpotion": "splashfireresist2potion", + "splashfireresistanceexpotion": "splashfireresist2potion", + "splashfireresistancelevel2potion": "splashfireresist2potion", + "splfireresist2potion": "splashfireresist2potion", + "splfireresistlongpotion": "splashfireresist2potion", + "splfireresistextendedpotion": "splashfireresist2potion", + "splfireresistexpotion": "splashfireresist2potion", + "splfireresistlevel2potion": "splashfireresist2potion", + "splfireres2potion": "splashfireresist2potion", + "splfirereslongpotion": "splashfireresist2potion", + "splfireresextendedpotion": "splashfireresist2potion", + "splfireresexpotion": "splashfireresist2potion", + "splfirereslevel2potion": "splashfireresist2potion", + "splfireresistance2potion": "splashfireresist2potion", + "splfireresistancelongpotion": "splashfireresist2potion", + "splfireresistanceextendedpotion": "splashfireresist2potion", + "splfireresistanceexpotion": "splashfireresist2potion", + "splfireresistancelevel2potion": "splashfireresist2potion", + "fireresist2splashpotion": "splashfireresist2potion", + "fireresistlongsplashpotion": "splashfireresist2potion", + "fireresistextendedsplashpotion": "splashfireresist2potion", + "fireresistexsplashpotion": "splashfireresist2potion", + "fireresistlevel2splashpotion": "splashfireresist2potion", + "fireres2splashpotion": "splashfireresist2potion", + "firereslongsplashpotion": "splashfireresist2potion", + "fireresextendedsplashpotion": "splashfireresist2potion", + "fireresexsplashpotion": "splashfireresist2potion", + "firereslevel2splashpotion": "splashfireresist2potion", + "fireresistance2splashpotion": "splashfireresist2potion", + "fireresistancelongsplashpotion": "splashfireresist2potion", + "fireresistanceextendedsplashpotion": "splashfireresist2potion", + "fireresistanceexsplashpotion": "splashfireresist2potion", + "fireresistancelevel2splashpotion": "splashfireresist2potion", + "splashfireresist2pot": "splashfireresist2potion", + "splashfireresistlongpot": "splashfireresist2potion", + "splashfireresistextendedpot": "splashfireresist2potion", + "splashfireresistexpot": "splashfireresist2potion", + "splashfireresistlevel2pot": "splashfireresist2potion", + "splashfireres2pot": "splashfireresist2potion", + "splashfirereslongpot": "splashfireresist2potion", + "splashfireresextendedpot": "splashfireresist2potion", + "splashfireresexpot": "splashfireresist2potion", + "splashfirereslevel2pot": "splashfireresist2potion", + "splashfireresistance2pot": "splashfireresist2potion", + "splashfireresistancelongpot": "splashfireresist2potion", + "splashfireresistanceextendedpot": "splashfireresist2potion", + "splashfireresistanceexpot": "splashfireresist2potion", + "splashfireresistancelevel2pot": "splashfireresist2potion", + "splfireresist2pot": "splashfireresist2potion", + "splfireresistlongpot": "splashfireresist2potion", + "splfireresistextendedpot": "splashfireresist2potion", + "splfireresistexpot": "splashfireresist2potion", + "splfireresistlevel2pot": "splashfireresist2potion", + "splfireres2pot": "splashfireresist2potion", + "splfirereslongpot": "splashfireresist2potion", + "splfireresextendedpot": "splashfireresist2potion", + "splfireresexpot": "splashfireresist2potion", + "splfirereslevel2pot": "splashfireresist2potion", + "splfireresistance2pot": "splashfireresist2potion", + "splfireresistancelongpot": "splashfireresist2potion", + "splfireresistanceextendedpot": "splashfireresist2potion", + "splfireresistanceexpot": "splashfireresist2potion", + "splfireresistancelevel2pot": "splashfireresist2potion", + "fireresist2splashpot": "splashfireresist2potion", + "fireresistlongsplashpot": "splashfireresist2potion", + "fireresistextendedsplashpot": "splashfireresist2potion", + "fireresistexsplashpot": "splashfireresist2potion", + "fireresistlevel2splashpot": "splashfireresist2potion", + "fireres2splashpot": "splashfireresist2potion", + "firereslongsplashpot": "splashfireresist2potion", + "fireresextendedsplashpot": "splashfireresist2potion", + "fireresexsplashpot": "splashfireresist2potion", + "firereslevel2splashpot": "splashfireresist2potion", + "fireresistance2splashpot": "splashfireresist2potion", + "fireresistancelongsplashpot": "splashfireresist2potion", + "fireresistanceextendedsplashpot": "splashfireresist2potion", + "fireresistanceexsplashpot": "splashfireresist2potion", + "fireresistancelevel2splashpot": "splashfireresist2potion", + "lingerpotfireresist2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": true + } + }, + "lingerpotfireresistlong": "lingerpotfireresist2", + "lingerpotfireresistextended": "lingerpotfireresist2", + "lingerpotfireresistex": "lingerpotfireresist2", + "lingerpotfireresistlevel2": "lingerpotfireresist2", + "lingerpotfireres2": "lingerpotfireresist2", + "lingerpotfirereslong": "lingerpotfireresist2", + "lingerpotfireresextended": "lingerpotfireresist2", + "lingerpotfireresex": "lingerpotfireresist2", + "lingerpotfirereslevel2": "lingerpotfireresist2", + "lingerpotfireresistance2": "lingerpotfireresist2", + "lingerpotfireresistancelong": "lingerpotfireresist2", + "lingerpotfireresistanceextended": "lingerpotfireresist2", + "lingerpotfireresistanceex": "lingerpotfireresist2", + "lingerpotfireresistancelevel2": "lingerpotfireresist2", + "fireresistlingerpot2": "lingerpotfireresist2", + "fireresistlingerpotlong": "lingerpotfireresist2", + "fireresistlingerpotextended": "lingerpotfireresist2", + "fireresistlingerpotex": "lingerpotfireresist2", + "fireresistlingerpotlevel2": "lingerpotfireresist2", + "firereslingerpot2": "lingerpotfireresist2", + "firereslingerpotlong": "lingerpotfireresist2", + "firereslingerpotextended": "lingerpotfireresist2", + "firereslingerpotex": "lingerpotfireresist2", + "firereslingerpotlevel2": "lingerpotfireresist2", + "fireresistancelingerpot2": "lingerpotfireresist2", + "fireresistancelingerpotlong": "lingerpotfireresist2", + "fireresistancelingerpotextended": "lingerpotfireresist2", + "fireresistancelingerpotex": "lingerpotfireresist2", + "fireresistancelingerpotlevel2": "lingerpotfireresist2", + "aoepotionfireresist2": "lingerpotfireresist2", + "aoepotionfireresistlong": "lingerpotfireresist2", + "aoepotionfireresistextended": "lingerpotfireresist2", + "aoepotionfireresistex": "lingerpotfireresist2", + "aoepotionfireresistlevel2": "lingerpotfireresist2", + "aoepotionfireres2": "lingerpotfireresist2", + "aoepotionfirereslong": "lingerpotfireresist2", + "aoepotionfireresextended": "lingerpotfireresist2", + "aoepotionfireresex": "lingerpotfireresist2", + "aoepotionfirereslevel2": "lingerpotfireresist2", + "aoepotionfireresistance2": "lingerpotfireresist2", + "aoepotionfireresistancelong": "lingerpotfireresist2", + "aoepotionfireresistanceextended": "lingerpotfireresist2", + "aoepotionfireresistanceex": "lingerpotfireresist2", + "aoepotionfireresistancelevel2": "lingerpotfireresist2", + "fireresistaoepoiont2": "lingerpotfireresist2", + "fireresistaoepoiontlong": "lingerpotfireresist2", + "fireresistaoepoiontextended": "lingerpotfireresist2", + "fireresistaoepoiontex": "lingerpotfireresist2", + "fireresistaoepoiontlevel2": "lingerpotfireresist2", + "fireresaoepoiont2": "lingerpotfireresist2", + "fireresaoepoiontlong": "lingerpotfireresist2", + "fireresaoepoiontextended": "lingerpotfireresist2", + "fireresaoepoiontex": "lingerpotfireresist2", + "fireresaoepoiontlevel2": "lingerpotfireresist2", + "fireresistanceaoepoiont2": "lingerpotfireresist2", + "fireresistanceaoepoiontlong": "lingerpotfireresist2", + "fireresistanceaoepoiontextended": "lingerpotfireresist2", + "fireresistanceaoepoiontex": "lingerpotfireresist2", + "fireresistanceaoepoiontlevel2": "lingerpotfireresist2", + "aoepotfireresist2": "lingerpotfireresist2", + "aoepotfireresistlong": "lingerpotfireresist2", + "aoepotfireresistextended": "lingerpotfireresist2", + "aoepotfireresistex": "lingerpotfireresist2", + "aoepotfireresistlevel2": "lingerpotfireresist2", + "aoepotfireres2": "lingerpotfireresist2", + "aoepotfirereslong": "lingerpotfireresist2", + "aoepotfireresextended": "lingerpotfireresist2", + "aoepotfireresex": "lingerpotfireresist2", + "aoepotfirereslevel2": "lingerpotfireresist2", + "aoepotfireresistance2": "lingerpotfireresist2", + "aoepotfireresistancelong": "lingerpotfireresist2", + "aoepotfireresistanceextended": "lingerpotfireresist2", + "aoepotfireresistanceex": "lingerpotfireresist2", + "aoepotfireresistancelevel2": "lingerpotfireresist2", + "fireresistaoepot2": "lingerpotfireresist2", + "fireresistaoepotlong": "lingerpotfireresist2", + "fireresistaoepotextended": "lingerpotfireresist2", + "fireresistaoepotex": "lingerpotfireresist2", + "fireresistaoepotlevel2": "lingerpotfireresist2", + "fireresaoepot2": "lingerpotfireresist2", + "fireresaoepotlong": "lingerpotfireresist2", + "fireresaoepotextended": "lingerpotfireresist2", + "fireresaoepotex": "lingerpotfireresist2", + "fireresaoepotlevel2": "lingerpotfireresist2", + "fireresistanceaoepot2": "lingerpotfireresist2", + "fireresistanceaoepotlong": "lingerpotfireresist2", + "fireresistanceaoepotextended": "lingerpotfireresist2", + "fireresistanceaoepotex": "lingerpotfireresist2", + "fireresistanceaoepotlevel2": "lingerpotfireresist2", + "areapotionfireresist2": "lingerpotfireresist2", + "areapotionfireresistlong": "lingerpotfireresist2", + "areapotionfireresistextended": "lingerpotfireresist2", + "areapotionfireresistex": "lingerpotfireresist2", + "areapotionfireresistlevel2": "lingerpotfireresist2", + "areapotionfireres2": "lingerpotfireresist2", + "areapotionfirereslong": "lingerpotfireresist2", + "areapotionfireresextended": "lingerpotfireresist2", + "areapotionfireresex": "lingerpotfireresist2", + "areapotionfirereslevel2": "lingerpotfireresist2", + "areapotionfireresistance2": "lingerpotfireresist2", + "areapotionfireresistancelong": "lingerpotfireresist2", + "areapotionfireresistanceextended": "lingerpotfireresist2", + "areapotionfireresistanceex": "lingerpotfireresist2", + "areapotionfireresistancelevel2": "lingerpotfireresist2", + "fireresistareapotion2": "lingerpotfireresist2", + "fireresistareapotionlong": "lingerpotfireresist2", + "fireresistareapotionextended": "lingerpotfireresist2", + "fireresistareapotionex": "lingerpotfireresist2", + "fireresistareapotionlevel2": "lingerpotfireresist2", + "fireresareapotion2": "lingerpotfireresist2", + "fireresareapotionlong": "lingerpotfireresist2", + "fireresareapotionextended": "lingerpotfireresist2", + "fireresareapotionex": "lingerpotfireresist2", + "fireresareapotionlevel2": "lingerpotfireresist2", + "fireresistanceareapotion2": "lingerpotfireresist2", + "fireresistanceareapotionlong": "lingerpotfireresist2", + "fireresistanceareapotionextended": "lingerpotfireresist2", + "fireresistanceareapotionex": "lingerpotfireresist2", + "fireresistanceareapotionlevel2": "lingerpotfireresist2", + "areapotfireresist2": "lingerpotfireresist2", + "areapotfireresistlong": "lingerpotfireresist2", + "areapotfireresistextended": "lingerpotfireresist2", + "areapotfireresistex": "lingerpotfireresist2", + "areapotfireresistlevel2": "lingerpotfireresist2", + "areapotfireres2": "lingerpotfireresist2", + "areapotfirereslong": "lingerpotfireresist2", + "areapotfireresextended": "lingerpotfireresist2", + "areapotfireresex": "lingerpotfireresist2", + "areapotfirereslevel2": "lingerpotfireresist2", + "areapotfireresistance2": "lingerpotfireresist2", + "areapotfireresistancelong": "lingerpotfireresist2", + "areapotfireresistanceextended": "lingerpotfireresist2", + "areapotfireresistanceex": "lingerpotfireresist2", + "areapotfireresistancelevel2": "lingerpotfireresist2", + "fireresistareapot2": "lingerpotfireresist2", + "fireresistareapotlong": "lingerpotfireresist2", + "fireresistareapotextended": "lingerpotfireresist2", + "fireresistareapotex": "lingerpotfireresist2", + "fireresistareapotlevel2": "lingerpotfireresist2", + "fireresareapot2": "lingerpotfireresist2", + "fireresareapotlong": "lingerpotfireresist2", + "fireresareapotextended": "lingerpotfireresist2", + "fireresareapotex": "lingerpotfireresist2", + "fireresareapotlevel2": "lingerpotfireresist2", + "fireresistanceareapot2": "lingerpotfireresist2", + "fireresistanceareapotlong": "lingerpotfireresist2", + "fireresistanceareapotextended": "lingerpotfireresist2", + "fireresistanceareapotex": "lingerpotfireresist2", + "fireresistanceareapotlevel2": "lingerpotfireresist2", + "cloudpotionfireresist2": "lingerpotfireresist2", + "cloudpotionfireresistlong": "lingerpotfireresist2", + "cloudpotionfireresistextended": "lingerpotfireresist2", + "cloudpotionfireresistex": "lingerpotfireresist2", + "cloudpotionfireresistlevel2": "lingerpotfireresist2", + "cloudpotionfireres2": "lingerpotfireresist2", + "cloudpotionfirereslong": "lingerpotfireresist2", + "cloudpotionfireresextended": "lingerpotfireresist2", + "cloudpotionfireresex": "lingerpotfireresist2", + "cloudpotionfirereslevel2": "lingerpotfireresist2", + "cloudpotionfireresistance2": "lingerpotfireresist2", + "cloudpotionfireresistancelong": "lingerpotfireresist2", + "cloudpotionfireresistanceextended": "lingerpotfireresist2", + "cloudpotionfireresistanceex": "lingerpotfireresist2", + "cloudpotionfireresistancelevel2": "lingerpotfireresist2", + "fireresistcloudpotion2": "lingerpotfireresist2", + "fireresistcloudpotionlong": "lingerpotfireresist2", + "fireresistcloudpotionextended": "lingerpotfireresist2", + "fireresistcloudpotionex": "lingerpotfireresist2", + "fireresistcloudpotionlevel2": "lingerpotfireresist2", + "firerescloudpotion2": "lingerpotfireresist2", + "firerescloudpotionlong": "lingerpotfireresist2", + "firerescloudpotionextended": "lingerpotfireresist2", + "firerescloudpotionex": "lingerpotfireresist2", + "firerescloudpotionlevel2": "lingerpotfireresist2", + "fireresistancecloudpotion2": "lingerpotfireresist2", + "fireresistancecloudpotionlong": "lingerpotfireresist2", + "fireresistancecloudpotionextended": "lingerpotfireresist2", + "fireresistancecloudpotionex": "lingerpotfireresist2", + "fireresistancecloudpotionlevel2": "lingerpotfireresist2", + "cloudpotfireresist2": "lingerpotfireresist2", + "cloudpotfireresistlong": "lingerpotfireresist2", + "cloudpotfireresistextended": "lingerpotfireresist2", + "cloudpotfireresistex": "lingerpotfireresist2", + "cloudpotfireresistlevel2": "lingerpotfireresist2", + "cloudpotfireres2": "lingerpotfireresist2", + "cloudpotfirereslong": "lingerpotfireresist2", + "cloudpotfireresextended": "lingerpotfireresist2", + "cloudpotfireresex": "lingerpotfireresist2", + "cloudpotfirereslevel2": "lingerpotfireresist2", + "cloudpotfireresistance2": "lingerpotfireresist2", + "cloudpotfireresistancelong": "lingerpotfireresist2", + "cloudpotfireresistanceextended": "lingerpotfireresist2", + "cloudpotfireresistanceex": "lingerpotfireresist2", + "cloudpotfireresistancelevel2": "lingerpotfireresist2", + "fireresistcloudpot2": "lingerpotfireresist2", + "fireresistcloudpotlong": "lingerpotfireresist2", + "fireresistcloudpotextended": "lingerpotfireresist2", + "fireresistcloudpotex": "lingerpotfireresist2", + "fireresistcloudpotlevel2": "lingerpotfireresist2", + "firerescloudpot2": "lingerpotfireresist2", + "firerescloudpotlong": "lingerpotfireresist2", + "firerescloudpotextended": "lingerpotfireresist2", + "firerescloudpotex": "lingerpotfireresist2", + "firerescloudpotlevel2": "lingerpotfireresist2", + "fireresistancecloudpot2": "lingerpotfireresist2", + "fireresistancecloudpotlong": "lingerpotfireresist2", + "fireresistancecloudpotextended": "lingerpotfireresist2", + "fireresistancecloudpotex": "lingerpotfireresist2", + "fireresistancecloudpotlevel2": "lingerpotfireresist2", + "arrowfireresist2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_fire_resistance", + "bukkitType": "fire_resistance", + "isStrong": false, + "isLong": true + } + }, + "arrowfireresistlong": "arrowfireresist2", + "arrowfireresistextended": "arrowfireresist2", + "arrowfireresistex": "arrowfireresist2", + "arrowfireresistlevel2": "arrowfireresist2", + "arrowfireres2": "arrowfireresist2", + "arrowfirereslong": "arrowfireresist2", + "arrowfireresextended": "arrowfireresist2", + "arrowfireresex": "arrowfireresist2", + "arrowfirereslevel2": "arrowfireresist2", + "arrowfireresistance2": "arrowfireresist2", + "arrowfireresistancelong": "arrowfireresist2", + "arrowfireresistanceextended": "arrowfireresist2", + "arrowfireresistanceex": "arrowfireresist2", + "arrowfireresistancelevel2": "arrowfireresist2", + "fireresistarrow2": "arrowfireresist2", + "fireresistarrowlong": "arrowfireresist2", + "fireresistarrowextended": "arrowfireresist2", + "fireresistarrowex": "arrowfireresist2", + "fireresistarrowlevel2": "arrowfireresist2", + "fireresarrow2": "arrowfireresist2", + "fireresarrowlong": "arrowfireresist2", + "fireresarrowextended": "arrowfireresist2", + "fireresarrowex": "arrowfireresist2", + "fireresarrowlevel2": "arrowfireresist2", + "fireresistancearrow2": "arrowfireresist2", + "fireresistancearrowlong": "arrowfireresist2", + "fireresistancearrowextended": "arrowfireresist2", + "fireresistancearrowex": "arrowfireresist2", + "fireresistancearrowlevel2": "arrowfireresist2", + "swiftnesspotion": { + "material": "POTION", + "potionData": { + "vanillaType": "swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": false + } + }, + "swiftpotion": "swiftnesspotion", + "speedpotion": "swiftnesspotion", + "swiftnesspot": "swiftnesspotion", + "swiftpot": "swiftnesspotion", + "speedpot": "swiftnesspotion", + "potionofswiftness": "swiftnesspotion", + "potionofswift": "swiftnesspotion", + "potionofspeed": "swiftnesspotion", + "potofswiftness": "swiftnesspotion", + "potofswift": "swiftnesspotion", + "potofspeed": "swiftnesspotion", + "splashswiftnesspotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": false + } + }, + "splashswiftpotion": "splashswiftnesspotion", + "splashspeedpotion": "splashswiftnesspotion", + "splswiftnesspotion": "splashswiftnesspotion", + "splswiftpotion": "splashswiftnesspotion", + "splspeedpotion": "splashswiftnesspotion", + "swiftnesssplashpotion": "splashswiftnesspotion", + "swiftsplashpotion": "splashswiftnesspotion", + "speedsplashpotion": "splashswiftnesspotion", + "splashswiftnesspot": "splashswiftnesspotion", + "splashswiftpot": "splashswiftnesspotion", + "splashspeedpot": "splashswiftnesspotion", + "splswiftnesspot": "splashswiftnesspotion", + "splswiftpot": "splashswiftnesspotion", + "splspeedpot": "splashswiftnesspotion", + "swiftnesssplashpot": "splashswiftnesspotion", + "swiftsplashpot": "splashswiftnesspotion", + "speedsplashpot": "splashswiftnesspotion", + "lingerpotswiftness": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": false + } + }, + "lingerpotswift": "lingerpotswiftness", + "lingerpotspeed": "lingerpotswiftness", + "swiftnesslingerpot": "lingerpotswiftness", + "swiftlingerpot": "lingerpotswiftness", + "speedlingerpot": "lingerpotswiftness", + "aoepotionswiftness": "lingerpotswiftness", + "aoepotionswift": "lingerpotswiftness", + "aoepotionspeed": "lingerpotswiftness", + "swiftnessaoepoiont": "lingerpotswiftness", + "swiftaoepoiont": "lingerpotswiftness", + "speedaoepoiont": "lingerpotswiftness", + "aoepotswiftness": "lingerpotswiftness", + "aoepotswift": "lingerpotswiftness", + "aoepotspeed": "lingerpotswiftness", + "swiftnessaoepot": "lingerpotswiftness", + "swiftaoepot": "lingerpotswiftness", + "speedaoepot": "lingerpotswiftness", + "areapotionswiftness": "lingerpotswiftness", + "areapotionswift": "lingerpotswiftness", + "areapotionspeed": "lingerpotswiftness", + "swiftnessareapotion": "lingerpotswiftness", + "swiftareapotion": "lingerpotswiftness", + "speedareapotion": "lingerpotswiftness", + "areapotswiftness": "lingerpotswiftness", + "areapotswift": "lingerpotswiftness", + "areapotspeed": "lingerpotswiftness", + "swiftnessareapot": "lingerpotswiftness", + "swiftareapot": "lingerpotswiftness", + "speedareapot": "lingerpotswiftness", + "cloudpotionswiftness": "lingerpotswiftness", + "cloudpotionswift": "lingerpotswiftness", + "cloudpotionspeed": "lingerpotswiftness", + "swiftnesscloudpotion": "lingerpotswiftness", + "swiftcloudpotion": "lingerpotswiftness", + "speedcloudpotion": "lingerpotswiftness", + "cloudpotswiftness": "lingerpotswiftness", + "cloudpotswift": "lingerpotswiftness", + "cloudpotspeed": "lingerpotswiftness", + "swiftnesscloudpot": "lingerpotswiftness", + "swiftcloudpot": "lingerpotswiftness", + "speedcloudpot": "lingerpotswiftness", + "arrowswiftness": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": false + } + }, + "arrowswift": "arrowswiftness", + "arrowspeed": "arrowswiftness", + "swiftnessarrow": "arrowswiftness", + "swiftarrow": "arrowswiftness", + "speedarrow": "arrowswiftness", + "swiftnessiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_swiftness", + "bukkitType": "swiftness", + "isStrong": true, + "isLong": false + } + }, + "swiftnessstrongpotion": "swiftnessiipotion", + "swiftnessleveliipotion": "swiftnessiipotion", + "swiftiipotion": "swiftnessiipotion", + "swiftstrongpotion": "swiftnessiipotion", + "swiftleveliipotion": "swiftnessiipotion", + "speediipotion": "swiftnessiipotion", + "speedstrongpotion": "swiftnessiipotion", + "speedleveliipotion": "swiftnessiipotion", + "swiftnessiipot": "swiftnessiipotion", + "swiftnessstrongpot": "swiftnessiipotion", + "swiftnessleveliipot": "swiftnessiipotion", + "swiftiipot": "swiftnessiipotion", + "swiftstrongpot": "swiftnessiipotion", + "swiftleveliipot": "swiftnessiipotion", + "speediipot": "swiftnessiipotion", + "speedstrongpot": "swiftnessiipotion", + "speedleveliipot": "swiftnessiipotion", + "potionofswiftnessii": "swiftnessiipotion", + "potionofswiftnessstrong": "swiftnessiipotion", + "potionofswiftnesslevelii": "swiftnessiipotion", + "potionofswiftii": "swiftnessiipotion", + "potionofswiftstrong": "swiftnessiipotion", + "potionofswiftlevelii": "swiftnessiipotion", + "potionofspeedii": "swiftnessiipotion", + "potionofspeedstrong": "swiftnessiipotion", + "potionofspeedlevelii": "swiftnessiipotion", + "potofswiftnessii": "swiftnessiipotion", + "potofswiftnessstrong": "swiftnessiipotion", + "potofswiftnesslevelii": "swiftnessiipotion", + "potofswiftii": "swiftnessiipotion", + "potofswiftstrong": "swiftnessiipotion", + "potofswiftlevelii": "swiftnessiipotion", + "potofspeedii": "swiftnessiipotion", + "potofspeedstrong": "swiftnessiipotion", + "potofspeedlevelii": "swiftnessiipotion", + "splashswiftnessiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_swiftness", + "bukkitType": "swiftness", + "isStrong": true, + "isLong": false + } + }, + "splashswiftnessstrongpotion": "splashswiftnessiipotion", + "splashswiftnessleveliipotion": "splashswiftnessiipotion", + "splashswiftiipotion": "splashswiftnessiipotion", + "splashswiftstrongpotion": "splashswiftnessiipotion", + "splashswiftleveliipotion": "splashswiftnessiipotion", + "splashspeediipotion": "splashswiftnessiipotion", + "splashspeedstrongpotion": "splashswiftnessiipotion", + "splashspeedleveliipotion": "splashswiftnessiipotion", + "splswiftnessiipotion": "splashswiftnessiipotion", + "splswiftnessstrongpotion": "splashswiftnessiipotion", + "splswiftnessleveliipotion": "splashswiftnessiipotion", + "splswiftiipotion": "splashswiftnessiipotion", + "splswiftstrongpotion": "splashswiftnessiipotion", + "splswiftleveliipotion": "splashswiftnessiipotion", + "splspeediipotion": "splashswiftnessiipotion", + "splspeedstrongpotion": "splashswiftnessiipotion", + "splspeedleveliipotion": "splashswiftnessiipotion", + "swiftnessiisplashpotion": "splashswiftnessiipotion", + "swiftnessstrongsplashpotion": "splashswiftnessiipotion", + "swiftnessleveliisplashpotion": "splashswiftnessiipotion", + "swiftiisplashpotion": "splashswiftnessiipotion", + "swiftstrongsplashpotion": "splashswiftnessiipotion", + "swiftleveliisplashpotion": "splashswiftnessiipotion", + "speediisplashpotion": "splashswiftnessiipotion", + "speedstrongsplashpotion": "splashswiftnessiipotion", + "speedleveliisplashpotion": "splashswiftnessiipotion", + "splashswiftnessiipot": "splashswiftnessiipotion", + "splashswiftnessstrongpot": "splashswiftnessiipotion", + "splashswiftnessleveliipot": "splashswiftnessiipotion", + "splashswiftiipot": "splashswiftnessiipotion", + "splashswiftstrongpot": "splashswiftnessiipotion", + "splashswiftleveliipot": "splashswiftnessiipotion", + "splashspeediipot": "splashswiftnessiipotion", + "splashspeedstrongpot": "splashswiftnessiipotion", + "splashspeedleveliipot": "splashswiftnessiipotion", + "splswiftnessiipot": "splashswiftnessiipotion", + "splswiftnessstrongpot": "splashswiftnessiipotion", + "splswiftnessleveliipot": "splashswiftnessiipotion", + "splswiftiipot": "splashswiftnessiipotion", + "splswiftstrongpot": "splashswiftnessiipotion", + "splswiftleveliipot": "splashswiftnessiipotion", + "splspeediipot": "splashswiftnessiipotion", + "splspeedstrongpot": "splashswiftnessiipotion", + "splspeedleveliipot": "splashswiftnessiipotion", + "swiftnessiisplashpot": "splashswiftnessiipotion", + "swiftnessstrongsplashpot": "splashswiftnessiipotion", + "swiftnessleveliisplashpot": "splashswiftnessiipotion", + "swiftiisplashpot": "splashswiftnessiipotion", + "swiftstrongsplashpot": "splashswiftnessiipotion", + "swiftleveliisplashpot": "splashswiftnessiipotion", + "speediisplashpot": "splashswiftnessiipotion", + "speedstrongsplashpot": "splashswiftnessiipotion", + "speedleveliisplashpot": "splashswiftnessiipotion", + "lingerpotswiftnessii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_swiftness", + "bukkitType": "swiftness", + "isStrong": true, + "isLong": false + } + }, + "lingerpotswiftnessstrong": "lingerpotswiftnessii", + "lingerpotswiftnesslevelii": "lingerpotswiftnessii", + "lingerpotswiftii": "lingerpotswiftnessii", + "lingerpotswiftstrong": "lingerpotswiftnessii", + "lingerpotswiftlevelii": "lingerpotswiftnessii", + "lingerpotspeedii": "lingerpotswiftnessii", + "lingerpotspeedstrong": "lingerpotswiftnessii", + "lingerpotspeedlevelii": "lingerpotswiftnessii", + "swiftnesslingerpotii": "lingerpotswiftnessii", + "swiftnesslingerpotstrong": "lingerpotswiftnessii", + "swiftnesslingerpotlevelii": "lingerpotswiftnessii", + "swiftlingerpotii": "lingerpotswiftnessii", + "swiftlingerpotstrong": "lingerpotswiftnessii", + "swiftlingerpotlevelii": "lingerpotswiftnessii", + "speedlingerpotii": "lingerpotswiftnessii", + "speedlingerpotstrong": "lingerpotswiftnessii", + "speedlingerpotlevelii": "lingerpotswiftnessii", + "aoepotionswiftnessii": "lingerpotswiftnessii", + "aoepotionswiftnessstrong": "lingerpotswiftnessii", + "aoepotionswiftnesslevelii": "lingerpotswiftnessii", + "aoepotionswiftii": "lingerpotswiftnessii", + "aoepotionswiftstrong": "lingerpotswiftnessii", + "aoepotionswiftlevelii": "lingerpotswiftnessii", + "aoepotionspeedii": "lingerpotswiftnessii", + "aoepotionspeedstrong": "lingerpotswiftnessii", + "aoepotionspeedlevelii": "lingerpotswiftnessii", + "swiftnessaoepoiontii": "lingerpotswiftnessii", + "swiftnessaoepoiontstrong": "lingerpotswiftnessii", + "swiftnessaoepoiontlevelii": "lingerpotswiftnessii", + "swiftaoepoiontii": "lingerpotswiftnessii", + "swiftaoepoiontstrong": "lingerpotswiftnessii", + "swiftaoepoiontlevelii": "lingerpotswiftnessii", + "speedaoepoiontii": "lingerpotswiftnessii", + "speedaoepoiontstrong": "lingerpotswiftnessii", + "speedaoepoiontlevelii": "lingerpotswiftnessii", + "aoepotswiftnessii": "lingerpotswiftnessii", + "aoepotswiftnessstrong": "lingerpotswiftnessii", + "aoepotswiftnesslevelii": "lingerpotswiftnessii", + "aoepotswiftii": "lingerpotswiftnessii", + "aoepotswiftstrong": "lingerpotswiftnessii", + "aoepotswiftlevelii": "lingerpotswiftnessii", + "aoepotspeedii": "lingerpotswiftnessii", + "aoepotspeedstrong": "lingerpotswiftnessii", + "aoepotspeedlevelii": "lingerpotswiftnessii", + "swiftnessaoepotii": "lingerpotswiftnessii", + "swiftnessaoepotstrong": "lingerpotswiftnessii", + "swiftnessaoepotlevelii": "lingerpotswiftnessii", + "swiftaoepotii": "lingerpotswiftnessii", + "swiftaoepotstrong": "lingerpotswiftnessii", + "swiftaoepotlevelii": "lingerpotswiftnessii", + "speedaoepotii": "lingerpotswiftnessii", + "speedaoepotstrong": "lingerpotswiftnessii", + "speedaoepotlevelii": "lingerpotswiftnessii", + "areapotionswiftnessii": "lingerpotswiftnessii", + "areapotionswiftnessstrong": "lingerpotswiftnessii", + "areapotionswiftnesslevelii": "lingerpotswiftnessii", + "areapotionswiftii": "lingerpotswiftnessii", + "areapotionswiftstrong": "lingerpotswiftnessii", + "areapotionswiftlevelii": "lingerpotswiftnessii", + "areapotionspeedii": "lingerpotswiftnessii", + "areapotionspeedstrong": "lingerpotswiftnessii", + "areapotionspeedlevelii": "lingerpotswiftnessii", + "swiftnessareapotionii": "lingerpotswiftnessii", + "swiftnessareapotionstrong": "lingerpotswiftnessii", + "swiftnessareapotionlevelii": "lingerpotswiftnessii", + "swiftareapotionii": "lingerpotswiftnessii", + "swiftareapotionstrong": "lingerpotswiftnessii", + "swiftareapotionlevelii": "lingerpotswiftnessii", + "speedareapotionii": "lingerpotswiftnessii", + "speedareapotionstrong": "lingerpotswiftnessii", + "speedareapotionlevelii": "lingerpotswiftnessii", + "areapotswiftnessii": "lingerpotswiftnessii", + "areapotswiftnessstrong": "lingerpotswiftnessii", + "areapotswiftnesslevelii": "lingerpotswiftnessii", + "areapotswiftii": "lingerpotswiftnessii", + "areapotswiftstrong": "lingerpotswiftnessii", + "areapotswiftlevelii": "lingerpotswiftnessii", + "areapotspeedii": "lingerpotswiftnessii", + "areapotspeedstrong": "lingerpotswiftnessii", + "areapotspeedlevelii": "lingerpotswiftnessii", + "swiftnessareapotii": "lingerpotswiftnessii", + "swiftnessareapotstrong": "lingerpotswiftnessii", + "swiftnessareapotlevelii": "lingerpotswiftnessii", + "swiftareapotii": "lingerpotswiftnessii", + "swiftareapotstrong": "lingerpotswiftnessii", + "swiftareapotlevelii": "lingerpotswiftnessii", + "speedareapotii": "lingerpotswiftnessii", + "speedareapotstrong": "lingerpotswiftnessii", + "speedareapotlevelii": "lingerpotswiftnessii", + "cloudpotionswiftnessii": "lingerpotswiftnessii", + "cloudpotionswiftnessstrong": "lingerpotswiftnessii", + "cloudpotionswiftnesslevelii": "lingerpotswiftnessii", + "cloudpotionswiftii": "lingerpotswiftnessii", + "cloudpotionswiftstrong": "lingerpotswiftnessii", + "cloudpotionswiftlevelii": "lingerpotswiftnessii", + "cloudpotionspeedii": "lingerpotswiftnessii", + "cloudpotionspeedstrong": "lingerpotswiftnessii", + "cloudpotionspeedlevelii": "lingerpotswiftnessii", + "swiftnesscloudpotionii": "lingerpotswiftnessii", + "swiftnesscloudpotionstrong": "lingerpotswiftnessii", + "swiftnesscloudpotionlevelii": "lingerpotswiftnessii", + "swiftcloudpotionii": "lingerpotswiftnessii", + "swiftcloudpotionstrong": "lingerpotswiftnessii", + "swiftcloudpotionlevelii": "lingerpotswiftnessii", + "speedcloudpotionii": "lingerpotswiftnessii", + "speedcloudpotionstrong": "lingerpotswiftnessii", + "speedcloudpotionlevelii": "lingerpotswiftnessii", + "cloudpotswiftnessii": "lingerpotswiftnessii", + "cloudpotswiftnessstrong": "lingerpotswiftnessii", + "cloudpotswiftnesslevelii": "lingerpotswiftnessii", + "cloudpotswiftii": "lingerpotswiftnessii", + "cloudpotswiftstrong": "lingerpotswiftnessii", + "cloudpotswiftlevelii": "lingerpotswiftnessii", + "cloudpotspeedii": "lingerpotswiftnessii", + "cloudpotspeedstrong": "lingerpotswiftnessii", + "cloudpotspeedlevelii": "lingerpotswiftnessii", + "swiftnesscloudpotii": "lingerpotswiftnessii", + "swiftnesscloudpotstrong": "lingerpotswiftnessii", + "swiftnesscloudpotlevelii": "lingerpotswiftnessii", + "swiftcloudpotii": "lingerpotswiftnessii", + "swiftcloudpotstrong": "lingerpotswiftnessii", + "swiftcloudpotlevelii": "lingerpotswiftnessii", + "speedcloudpotii": "lingerpotswiftnessii", + "speedcloudpotstrong": "lingerpotswiftnessii", + "speedcloudpotlevelii": "lingerpotswiftnessii", + "arrowswiftnessii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_swiftness", + "bukkitType": "swiftness", + "isStrong": true, + "isLong": false + } + }, + "arrowswiftnessstrong": "arrowswiftnessii", + "arrowswiftnesslevelii": "arrowswiftnessii", + "arrowswiftii": "arrowswiftnessii", + "arrowswiftstrong": "arrowswiftnessii", + "arrowswiftlevelii": "arrowswiftnessii", + "arrowspeedii": "arrowswiftnessii", + "arrowspeedstrong": "arrowswiftnessii", + "arrowspeedlevelii": "arrowswiftnessii", + "swiftnessarrowii": "arrowswiftnessii", + "swiftnessarrowstrong": "arrowswiftnessii", + "swiftnessarrowlevelii": "arrowswiftnessii", + "swiftarrowii": "arrowswiftnessii", + "swiftarrowstrong": "arrowswiftnessii", + "swiftarrowlevelii": "arrowswiftnessii", + "speedarrowii": "arrowswiftnessii", + "speedarrowstrong": "arrowswiftnessii", + "speedarrowlevelii": "arrowswiftnessii", + "swiftness2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": true + } + }, + "swiftnesslongpotion": "swiftness2potion", + "swiftnessextendedpotion": "swiftness2potion", + "swiftnessexpotion": "swiftness2potion", + "swiftnesslevel2potion": "swiftness2potion", + "swift2potion": "swiftness2potion", + "swiftlongpotion": "swiftness2potion", + "swiftextendedpotion": "swiftness2potion", + "swiftexpotion": "swiftness2potion", + "swiftlevel2potion": "swiftness2potion", + "speed2potion": "swiftness2potion", + "speedlongpotion": "swiftness2potion", + "speedextendedpotion": "swiftness2potion", + "speedexpotion": "swiftness2potion", + "speedlevel2potion": "swiftness2potion", + "swiftness2pot": "swiftness2potion", + "swiftnesslongpot": "swiftness2potion", + "swiftnessextendedpot": "swiftness2potion", + "swiftnessexpot": "swiftness2potion", + "swiftnesslevel2pot": "swiftness2potion", + "swift2pot": "swiftness2potion", + "swiftlongpot": "swiftness2potion", + "swiftextendedpot": "swiftness2potion", + "swiftexpot": "swiftness2potion", + "swiftlevel2pot": "swiftness2potion", + "speed2pot": "swiftness2potion", + "speedlongpot": "swiftness2potion", + "speedextendedpot": "swiftness2potion", + "speedexpot": "swiftness2potion", + "speedlevel2pot": "swiftness2potion", + "potionofswiftness2": "swiftness2potion", + "potionofswiftnesslong": "swiftness2potion", + "potionofswiftnessextended": "swiftness2potion", + "potionofswiftnessex": "swiftness2potion", + "potionofswiftnesslevel2": "swiftness2potion", + "potionofswift2": "swiftness2potion", + "potionofswiftlong": "swiftness2potion", + "potionofswiftextended": "swiftness2potion", + "potionofswiftex": "swiftness2potion", + "potionofswiftlevel2": "swiftness2potion", + "potionofspeed2": "swiftness2potion", + "potionofspeedlong": "swiftness2potion", + "potionofspeedextended": "swiftness2potion", + "potionofspeedex": "swiftness2potion", + "potionofspeedlevel2": "swiftness2potion", + "potofswiftness2": "swiftness2potion", + "potofswiftnesslong": "swiftness2potion", + "potofswiftnessextended": "swiftness2potion", + "potofswiftnessex": "swiftness2potion", + "potofswiftnesslevel2": "swiftness2potion", + "potofswift2": "swiftness2potion", + "potofswiftlong": "swiftness2potion", + "potofswiftextended": "swiftness2potion", + "potofswiftex": "swiftness2potion", + "potofswiftlevel2": "swiftness2potion", + "potofspeed2": "swiftness2potion", + "potofspeedlong": "swiftness2potion", + "potofspeedextended": "swiftness2potion", + "potofspeedex": "swiftness2potion", + "potofspeedlevel2": "swiftness2potion", + "splashswiftness2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": true + } + }, + "splashswiftnesslongpotion": "splashswiftness2potion", + "splashswiftnessextendedpotion": "splashswiftness2potion", + "splashswiftnessexpotion": "splashswiftness2potion", + "splashswiftnesslevel2potion": "splashswiftness2potion", + "splashswift2potion": "splashswiftness2potion", + "splashswiftlongpotion": "splashswiftness2potion", + "splashswiftextendedpotion": "splashswiftness2potion", + "splashswiftexpotion": "splashswiftness2potion", + "splashswiftlevel2potion": "splashswiftness2potion", + "splashspeed2potion": "splashswiftness2potion", + "splashspeedlongpotion": "splashswiftness2potion", + "splashspeedextendedpotion": "splashswiftness2potion", + "splashspeedexpotion": "splashswiftness2potion", + "splashspeedlevel2potion": "splashswiftness2potion", + "splswiftness2potion": "splashswiftness2potion", + "splswiftnesslongpotion": "splashswiftness2potion", + "splswiftnessextendedpotion": "splashswiftness2potion", + "splswiftnessexpotion": "splashswiftness2potion", + "splswiftnesslevel2potion": "splashswiftness2potion", + "splswift2potion": "splashswiftness2potion", + "splswiftlongpotion": "splashswiftness2potion", + "splswiftextendedpotion": "splashswiftness2potion", + "splswiftexpotion": "splashswiftness2potion", + "splswiftlevel2potion": "splashswiftness2potion", + "splspeed2potion": "splashswiftness2potion", + "splspeedlongpotion": "splashswiftness2potion", + "splspeedextendedpotion": "splashswiftness2potion", + "splspeedexpotion": "splashswiftness2potion", + "splspeedlevel2potion": "splashswiftness2potion", + "swiftness2splashpotion": "splashswiftness2potion", + "swiftnesslongsplashpotion": "splashswiftness2potion", + "swiftnessextendedsplashpotion": "splashswiftness2potion", + "swiftnessexsplashpotion": "splashswiftness2potion", + "swiftnesslevel2splashpotion": "splashswiftness2potion", + "swift2splashpotion": "splashswiftness2potion", + "swiftlongsplashpotion": "splashswiftness2potion", + "swiftextendedsplashpotion": "splashswiftness2potion", + "swiftexsplashpotion": "splashswiftness2potion", + "swiftlevel2splashpotion": "splashswiftness2potion", + "speed2splashpotion": "splashswiftness2potion", + "speedlongsplashpotion": "splashswiftness2potion", + "speedextendedsplashpotion": "splashswiftness2potion", + "speedexsplashpotion": "splashswiftness2potion", + "speedlevel2splashpotion": "splashswiftness2potion", + "splashswiftness2pot": "splashswiftness2potion", + "splashswiftnesslongpot": "splashswiftness2potion", + "splashswiftnessextendedpot": "splashswiftness2potion", + "splashswiftnessexpot": "splashswiftness2potion", + "splashswiftnesslevel2pot": "splashswiftness2potion", + "splashswift2pot": "splashswiftness2potion", + "splashswiftlongpot": "splashswiftness2potion", + "splashswiftextendedpot": "splashswiftness2potion", + "splashswiftexpot": "splashswiftness2potion", + "splashswiftlevel2pot": "splashswiftness2potion", + "splashspeed2pot": "splashswiftness2potion", + "splashspeedlongpot": "splashswiftness2potion", + "splashspeedextendedpot": "splashswiftness2potion", + "splashspeedexpot": "splashswiftness2potion", + "splashspeedlevel2pot": "splashswiftness2potion", + "splswiftness2pot": "splashswiftness2potion", + "splswiftnesslongpot": "splashswiftness2potion", + "splswiftnessextendedpot": "splashswiftness2potion", + "splswiftnessexpot": "splashswiftness2potion", + "splswiftnesslevel2pot": "splashswiftness2potion", + "splswift2pot": "splashswiftness2potion", + "splswiftlongpot": "splashswiftness2potion", + "splswiftextendedpot": "splashswiftness2potion", + "splswiftexpot": "splashswiftness2potion", + "splswiftlevel2pot": "splashswiftness2potion", + "splspeed2pot": "splashswiftness2potion", + "splspeedlongpot": "splashswiftness2potion", + "splspeedextendedpot": "splashswiftness2potion", + "splspeedexpot": "splashswiftness2potion", + "splspeedlevel2pot": "splashswiftness2potion", + "swiftness2splashpot": "splashswiftness2potion", + "swiftnesslongsplashpot": "splashswiftness2potion", + "swiftnessextendedsplashpot": "splashswiftness2potion", + "swiftnessexsplashpot": "splashswiftness2potion", + "swiftnesslevel2splashpot": "splashswiftness2potion", + "swift2splashpot": "splashswiftness2potion", + "swiftlongsplashpot": "splashswiftness2potion", + "swiftextendedsplashpot": "splashswiftness2potion", + "swiftexsplashpot": "splashswiftness2potion", + "swiftlevel2splashpot": "splashswiftness2potion", + "speed2splashpot": "splashswiftness2potion", + "speedlongsplashpot": "splashswiftness2potion", + "speedextendedsplashpot": "splashswiftness2potion", + "speedexsplashpot": "splashswiftness2potion", + "speedlevel2splashpot": "splashswiftness2potion", + "lingerpotswiftness2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": true + } + }, + "lingerpotswiftnesslong": "lingerpotswiftness2", + "lingerpotswiftnessextended": "lingerpotswiftness2", + "lingerpotswiftnessex": "lingerpotswiftness2", + "lingerpotswiftnesslevel2": "lingerpotswiftness2", + "lingerpotswift2": "lingerpotswiftness2", + "lingerpotswiftlong": "lingerpotswiftness2", + "lingerpotswiftextended": "lingerpotswiftness2", + "lingerpotswiftex": "lingerpotswiftness2", + "lingerpotswiftlevel2": "lingerpotswiftness2", + "lingerpotspeed2": "lingerpotswiftness2", + "lingerpotspeedlong": "lingerpotswiftness2", + "lingerpotspeedextended": "lingerpotswiftness2", + "lingerpotspeedex": "lingerpotswiftness2", + "lingerpotspeedlevel2": "lingerpotswiftness2", + "swiftnesslingerpot2": "lingerpotswiftness2", + "swiftnesslingerpotlong": "lingerpotswiftness2", + "swiftnesslingerpotextended": "lingerpotswiftness2", + "swiftnesslingerpotex": "lingerpotswiftness2", + "swiftnesslingerpotlevel2": "lingerpotswiftness2", + "swiftlingerpot2": "lingerpotswiftness2", + "swiftlingerpotlong": "lingerpotswiftness2", + "swiftlingerpotextended": "lingerpotswiftness2", + "swiftlingerpotex": "lingerpotswiftness2", + "swiftlingerpotlevel2": "lingerpotswiftness2", + "speedlingerpot2": "lingerpotswiftness2", + "speedlingerpotlong": "lingerpotswiftness2", + "speedlingerpotextended": "lingerpotswiftness2", + "speedlingerpotex": "lingerpotswiftness2", + "speedlingerpotlevel2": "lingerpotswiftness2", + "aoepotionswiftness2": "lingerpotswiftness2", + "aoepotionswiftnesslong": "lingerpotswiftness2", + "aoepotionswiftnessextended": "lingerpotswiftness2", + "aoepotionswiftnessex": "lingerpotswiftness2", + "aoepotionswiftnesslevel2": "lingerpotswiftness2", + "aoepotionswift2": "lingerpotswiftness2", + "aoepotionswiftlong": "lingerpotswiftness2", + "aoepotionswiftextended": "lingerpotswiftness2", + "aoepotionswiftex": "lingerpotswiftness2", + "aoepotionswiftlevel2": "lingerpotswiftness2", + "aoepotionspeed2": "lingerpotswiftness2", + "aoepotionspeedlong": "lingerpotswiftness2", + "aoepotionspeedextended": "lingerpotswiftness2", + "aoepotionspeedex": "lingerpotswiftness2", + "aoepotionspeedlevel2": "lingerpotswiftness2", + "swiftnessaoepoiont2": "lingerpotswiftness2", + "swiftnessaoepoiontlong": "lingerpotswiftness2", + "swiftnessaoepoiontextended": "lingerpotswiftness2", + "swiftnessaoepoiontex": "lingerpotswiftness2", + "swiftnessaoepoiontlevel2": "lingerpotswiftness2", + "swiftaoepoiont2": "lingerpotswiftness2", + "swiftaoepoiontlong": "lingerpotswiftness2", + "swiftaoepoiontextended": "lingerpotswiftness2", + "swiftaoepoiontex": "lingerpotswiftness2", + "swiftaoepoiontlevel2": "lingerpotswiftness2", + "speedaoepoiont2": "lingerpotswiftness2", + "speedaoepoiontlong": "lingerpotswiftness2", + "speedaoepoiontextended": "lingerpotswiftness2", + "speedaoepoiontex": "lingerpotswiftness2", + "speedaoepoiontlevel2": "lingerpotswiftness2", + "aoepotswiftness2": "lingerpotswiftness2", + "aoepotswiftnesslong": "lingerpotswiftness2", + "aoepotswiftnessextended": "lingerpotswiftness2", + "aoepotswiftnessex": "lingerpotswiftness2", + "aoepotswiftnesslevel2": "lingerpotswiftness2", + "aoepotswift2": "lingerpotswiftness2", + "aoepotswiftlong": "lingerpotswiftness2", + "aoepotswiftextended": "lingerpotswiftness2", + "aoepotswiftex": "lingerpotswiftness2", + "aoepotswiftlevel2": "lingerpotswiftness2", + "aoepotspeed2": "lingerpotswiftness2", + "aoepotspeedlong": "lingerpotswiftness2", + "aoepotspeedextended": "lingerpotswiftness2", + "aoepotspeedex": "lingerpotswiftness2", + "aoepotspeedlevel2": "lingerpotswiftness2", + "swiftnessaoepot2": "lingerpotswiftness2", + "swiftnessaoepotlong": "lingerpotswiftness2", + "swiftnessaoepotextended": "lingerpotswiftness2", + "swiftnessaoepotex": "lingerpotswiftness2", + "swiftnessaoepotlevel2": "lingerpotswiftness2", + "swiftaoepot2": "lingerpotswiftness2", + "swiftaoepotlong": "lingerpotswiftness2", + "swiftaoepotextended": "lingerpotswiftness2", + "swiftaoepotex": "lingerpotswiftness2", + "swiftaoepotlevel2": "lingerpotswiftness2", + "speedaoepot2": "lingerpotswiftness2", + "speedaoepotlong": "lingerpotswiftness2", + "speedaoepotextended": "lingerpotswiftness2", + "speedaoepotex": "lingerpotswiftness2", + "speedaoepotlevel2": "lingerpotswiftness2", + "areapotionswiftness2": "lingerpotswiftness2", + "areapotionswiftnesslong": "lingerpotswiftness2", + "areapotionswiftnessextended": "lingerpotswiftness2", + "areapotionswiftnessex": "lingerpotswiftness2", + "areapotionswiftnesslevel2": "lingerpotswiftness2", + "areapotionswift2": "lingerpotswiftness2", + "areapotionswiftlong": "lingerpotswiftness2", + "areapotionswiftextended": "lingerpotswiftness2", + "areapotionswiftex": "lingerpotswiftness2", + "areapotionswiftlevel2": "lingerpotswiftness2", + "areapotionspeed2": "lingerpotswiftness2", + "areapotionspeedlong": "lingerpotswiftness2", + "areapotionspeedextended": "lingerpotswiftness2", + "areapotionspeedex": "lingerpotswiftness2", + "areapotionspeedlevel2": "lingerpotswiftness2", + "swiftnessareapotion2": "lingerpotswiftness2", + "swiftnessareapotionlong": "lingerpotswiftness2", + "swiftnessareapotionextended": "lingerpotswiftness2", + "swiftnessareapotionex": "lingerpotswiftness2", + "swiftnessareapotionlevel2": "lingerpotswiftness2", + "swiftareapotion2": "lingerpotswiftness2", + "swiftareapotionlong": "lingerpotswiftness2", + "swiftareapotionextended": "lingerpotswiftness2", + "swiftareapotionex": "lingerpotswiftness2", + "swiftareapotionlevel2": "lingerpotswiftness2", + "speedareapotion2": "lingerpotswiftness2", + "speedareapotionlong": "lingerpotswiftness2", + "speedareapotionextended": "lingerpotswiftness2", + "speedareapotionex": "lingerpotswiftness2", + "speedareapotionlevel2": "lingerpotswiftness2", + "areapotswiftness2": "lingerpotswiftness2", + "areapotswiftnesslong": "lingerpotswiftness2", + "areapotswiftnessextended": "lingerpotswiftness2", + "areapotswiftnessex": "lingerpotswiftness2", + "areapotswiftnesslevel2": "lingerpotswiftness2", + "areapotswift2": "lingerpotswiftness2", + "areapotswiftlong": "lingerpotswiftness2", + "areapotswiftextended": "lingerpotswiftness2", + "areapotswiftex": "lingerpotswiftness2", + "areapotswiftlevel2": "lingerpotswiftness2", + "areapotspeed2": "lingerpotswiftness2", + "areapotspeedlong": "lingerpotswiftness2", + "areapotspeedextended": "lingerpotswiftness2", + "areapotspeedex": "lingerpotswiftness2", + "areapotspeedlevel2": "lingerpotswiftness2", + "swiftnessareapot2": "lingerpotswiftness2", + "swiftnessareapotlong": "lingerpotswiftness2", + "swiftnessareapotextended": "lingerpotswiftness2", + "swiftnessareapotex": "lingerpotswiftness2", + "swiftnessareapotlevel2": "lingerpotswiftness2", + "swiftareapot2": "lingerpotswiftness2", + "swiftareapotlong": "lingerpotswiftness2", + "swiftareapotextended": "lingerpotswiftness2", + "swiftareapotex": "lingerpotswiftness2", + "swiftareapotlevel2": "lingerpotswiftness2", + "speedareapot2": "lingerpotswiftness2", + "speedareapotlong": "lingerpotswiftness2", + "speedareapotextended": "lingerpotswiftness2", + "speedareapotex": "lingerpotswiftness2", + "speedareapotlevel2": "lingerpotswiftness2", + "cloudpotionswiftness2": "lingerpotswiftness2", + "cloudpotionswiftnesslong": "lingerpotswiftness2", + "cloudpotionswiftnessextended": "lingerpotswiftness2", + "cloudpotionswiftnessex": "lingerpotswiftness2", + "cloudpotionswiftnesslevel2": "lingerpotswiftness2", + "cloudpotionswift2": "lingerpotswiftness2", + "cloudpotionswiftlong": "lingerpotswiftness2", + "cloudpotionswiftextended": "lingerpotswiftness2", + "cloudpotionswiftex": "lingerpotswiftness2", + "cloudpotionswiftlevel2": "lingerpotswiftness2", + "cloudpotionspeed2": "lingerpotswiftness2", + "cloudpotionspeedlong": "lingerpotswiftness2", + "cloudpotionspeedextended": "lingerpotswiftness2", + "cloudpotionspeedex": "lingerpotswiftness2", + "cloudpotionspeedlevel2": "lingerpotswiftness2", + "swiftnesscloudpotion2": "lingerpotswiftness2", + "swiftnesscloudpotionlong": "lingerpotswiftness2", + "swiftnesscloudpotionextended": "lingerpotswiftness2", + "swiftnesscloudpotionex": "lingerpotswiftness2", + "swiftnesscloudpotionlevel2": "lingerpotswiftness2", + "swiftcloudpotion2": "lingerpotswiftness2", + "swiftcloudpotionlong": "lingerpotswiftness2", + "swiftcloudpotionextended": "lingerpotswiftness2", + "swiftcloudpotionex": "lingerpotswiftness2", + "swiftcloudpotionlevel2": "lingerpotswiftness2", + "speedcloudpotion2": "lingerpotswiftness2", + "speedcloudpotionlong": "lingerpotswiftness2", + "speedcloudpotionextended": "lingerpotswiftness2", + "speedcloudpotionex": "lingerpotswiftness2", + "speedcloudpotionlevel2": "lingerpotswiftness2", + "cloudpotswiftness2": "lingerpotswiftness2", + "cloudpotswiftnesslong": "lingerpotswiftness2", + "cloudpotswiftnessextended": "lingerpotswiftness2", + "cloudpotswiftnessex": "lingerpotswiftness2", + "cloudpotswiftnesslevel2": "lingerpotswiftness2", + "cloudpotswift2": "lingerpotswiftness2", + "cloudpotswiftlong": "lingerpotswiftness2", + "cloudpotswiftextended": "lingerpotswiftness2", + "cloudpotswiftex": "lingerpotswiftness2", + "cloudpotswiftlevel2": "lingerpotswiftness2", + "cloudpotspeed2": "lingerpotswiftness2", + "cloudpotspeedlong": "lingerpotswiftness2", + "cloudpotspeedextended": "lingerpotswiftness2", + "cloudpotspeedex": "lingerpotswiftness2", + "cloudpotspeedlevel2": "lingerpotswiftness2", + "swiftnesscloudpot2": "lingerpotswiftness2", + "swiftnesscloudpotlong": "lingerpotswiftness2", + "swiftnesscloudpotextended": "lingerpotswiftness2", + "swiftnesscloudpotex": "lingerpotswiftness2", + "swiftnesscloudpotlevel2": "lingerpotswiftness2", + "swiftcloudpot2": "lingerpotswiftness2", + "swiftcloudpotlong": "lingerpotswiftness2", + "swiftcloudpotextended": "lingerpotswiftness2", + "swiftcloudpotex": "lingerpotswiftness2", + "swiftcloudpotlevel2": "lingerpotswiftness2", + "speedcloudpot2": "lingerpotswiftness2", + "speedcloudpotlong": "lingerpotswiftness2", + "speedcloudpotextended": "lingerpotswiftness2", + "speedcloudpotex": "lingerpotswiftness2", + "speedcloudpotlevel2": "lingerpotswiftness2", + "arrowswiftness2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_swiftness", + "bukkitType": "swiftness", + "isStrong": false, + "isLong": true + } + }, + "arrowswiftnesslong": "arrowswiftness2", + "arrowswiftnessextended": "arrowswiftness2", + "arrowswiftnessex": "arrowswiftness2", + "arrowswiftnesslevel2": "arrowswiftness2", + "arrowswift2": "arrowswiftness2", + "arrowswiftlong": "arrowswiftness2", + "arrowswiftextended": "arrowswiftness2", + "arrowswiftex": "arrowswiftness2", + "arrowswiftlevel2": "arrowswiftness2", + "arrowspeed2": "arrowswiftness2", + "arrowspeedlong": "arrowswiftness2", + "arrowspeedextended": "arrowswiftness2", + "arrowspeedex": "arrowswiftness2", + "arrowspeedlevel2": "arrowswiftness2", + "swiftnessarrow2": "arrowswiftness2", + "swiftnessarrowlong": "arrowswiftness2", + "swiftnessarrowextended": "arrowswiftness2", + "swiftnessarrowex": "arrowswiftness2", + "swiftnessarrowlevel2": "arrowswiftness2", + "swiftarrow2": "arrowswiftness2", + "swiftarrowlong": "arrowswiftness2", + "swiftarrowextended": "arrowswiftness2", + "swiftarrowex": "arrowswiftness2", + "swiftarrowlevel2": "arrowswiftness2", + "speedarrow2": "arrowswiftness2", + "speedarrowlong": "arrowswiftness2", + "speedarrowextended": "arrowswiftness2", + "speedarrowex": "arrowswiftness2", + "speedarrowlevel2": "arrowswiftness2", + "slownesspotion": { + "material": "POTION", + "potionData": { + "vanillaType": "slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": false + } + }, + "slowpotion": "slownesspotion", + "slownesspot": "slownesspotion", + "slowpot": "slownesspotion", + "potionofslowness": "slownesspotion", + "potionofslow": "slownesspotion", + "potofslowness": "slownesspotion", + "potofslow": "slownesspotion", + "splashslownesspotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": false + } + }, + "splashslowpotion": "splashslownesspotion", + "splslownesspotion": "splashslownesspotion", + "splslowpotion": "splashslownesspotion", + "slownesssplashpotion": "splashslownesspotion", + "slowsplashpotion": "splashslownesspotion", + "splashslownesspot": "splashslownesspotion", + "splashslowpot": "splashslownesspotion", + "splslownesspot": "splashslownesspotion", + "splslowpot": "splashslownesspotion", + "slownesssplashpot": "splashslownesspotion", + "slowsplashpot": "splashslownesspotion", + "lingerpotslowness": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": false + } + }, + "lingerpotslow": "lingerpotslowness", + "slownesslingerpot": "lingerpotslowness", + "slowlingerpot": "lingerpotslowness", + "aoepotionslowness": "lingerpotslowness", + "aoepotionslow": "lingerpotslowness", + "slownessaoepoiont": "lingerpotslowness", + "slowaoepoiont": "lingerpotslowness", + "aoepotslowness": "lingerpotslowness", + "aoepotslow": "lingerpotslowness", + "slownessaoepot": "lingerpotslowness", + "slowaoepot": "lingerpotslowness", + "areapotionslowness": "lingerpotslowness", + "areapotionslow": "lingerpotslowness", + "slownessareapotion": "lingerpotslowness", + "slowareapotion": "lingerpotslowness", + "areapotslowness": "lingerpotslowness", + "areapotslow": "lingerpotslowness", + "slownessareapot": "lingerpotslowness", + "slowareapot": "lingerpotslowness", + "cloudpotionslowness": "lingerpotslowness", + "cloudpotionslow": "lingerpotslowness", + "slownesscloudpotion": "lingerpotslowness", + "slowcloudpotion": "lingerpotslowness", + "cloudpotslowness": "lingerpotslowness", + "cloudpotslow": "lingerpotslowness", + "slownesscloudpot": "lingerpotslowness", + "slowcloudpot": "lingerpotslowness", + "arrowslowness": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": false + } + }, + "arrowslow": "arrowslowness", + "slownessarrow": "arrowslowness", + "slowarrow": "arrowslowness", + "slowness2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": true + } + }, + "slownesslongpotion": "slowness2potion", + "slownessextendedpotion": "slowness2potion", + "slownessexpotion": "slowness2potion", + "slownesslevel2potion": "slowness2potion", + "slow2potion": "slowness2potion", + "slowlongpotion": "slowness2potion", + "slowextendedpotion": "slowness2potion", + "slowexpotion": "slowness2potion", + "slowlevel2potion": "slowness2potion", + "slowness2pot": "slowness2potion", + "slownesslongpot": "slowness2potion", + "slownessextendedpot": "slowness2potion", + "slownessexpot": "slowness2potion", + "slownesslevel2pot": "slowness2potion", + "slow2pot": "slowness2potion", + "slowlongpot": "slowness2potion", + "slowextendedpot": "slowness2potion", + "slowexpot": "slowness2potion", + "slowlevel2pot": "slowness2potion", + "potionofslowness2": "slowness2potion", + "potionofslownesslong": "slowness2potion", + "potionofslownessextended": "slowness2potion", + "potionofslownessex": "slowness2potion", + "potionofslownesslevel2": "slowness2potion", + "potionofslow2": "slowness2potion", + "potionofslowlong": "slowness2potion", + "potionofslowextended": "slowness2potion", + "potionofslowex": "slowness2potion", + "potionofslowlevel2": "slowness2potion", + "potofslowness2": "slowness2potion", + "potofslownesslong": "slowness2potion", + "potofslownessextended": "slowness2potion", + "potofslownessex": "slowness2potion", + "potofslownesslevel2": "slowness2potion", + "potofslow2": "slowness2potion", + "potofslowlong": "slowness2potion", + "potofslowextended": "slowness2potion", + "potofslowex": "slowness2potion", + "potofslowlevel2": "slowness2potion", + "splashslowness2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": true + } + }, + "splashslownesslongpotion": "splashslowness2potion", + "splashslownessextendedpotion": "splashslowness2potion", + "splashslownessexpotion": "splashslowness2potion", + "splashslownesslevel2potion": "splashslowness2potion", + "splashslow2potion": "splashslowness2potion", + "splashslowlongpotion": "splashslowness2potion", + "splashslowextendedpotion": "splashslowness2potion", + "splashslowexpotion": "splashslowness2potion", + "splashslowlevel2potion": "splashslowness2potion", + "splslowness2potion": "splashslowness2potion", + "splslownesslongpotion": "splashslowness2potion", + "splslownessextendedpotion": "splashslowness2potion", + "splslownessexpotion": "splashslowness2potion", + "splslownesslevel2potion": "splashslowness2potion", + "splslow2potion": "splashslowness2potion", + "splslowlongpotion": "splashslowness2potion", + "splslowextendedpotion": "splashslowness2potion", + "splslowexpotion": "splashslowness2potion", + "splslowlevel2potion": "splashslowness2potion", + "slowness2splashpotion": "splashslowness2potion", + "slownesslongsplashpotion": "splashslowness2potion", + "slownessextendedsplashpotion": "splashslowness2potion", + "slownessexsplashpotion": "splashslowness2potion", + "slownesslevel2splashpotion": "splashslowness2potion", + "slow2splashpotion": "splashslowness2potion", + "slowlongsplashpotion": "splashslowness2potion", + "slowextendedsplashpotion": "splashslowness2potion", + "slowexsplashpotion": "splashslowness2potion", + "slowlevel2splashpotion": "splashslowness2potion", + "splashslowness2pot": "splashslowness2potion", + "splashslownesslongpot": "splashslowness2potion", + "splashslownessextendedpot": "splashslowness2potion", + "splashslownessexpot": "splashslowness2potion", + "splashslownesslevel2pot": "splashslowness2potion", + "splashslow2pot": "splashslowness2potion", + "splashslowlongpot": "splashslowness2potion", + "splashslowextendedpot": "splashslowness2potion", + "splashslowexpot": "splashslowness2potion", + "splashslowlevel2pot": "splashslowness2potion", + "splslowness2pot": "splashslowness2potion", + "splslownesslongpot": "splashslowness2potion", + "splslownessextendedpot": "splashslowness2potion", + "splslownessexpot": "splashslowness2potion", + "splslownesslevel2pot": "splashslowness2potion", + "splslow2pot": "splashslowness2potion", + "splslowlongpot": "splashslowness2potion", + "splslowextendedpot": "splashslowness2potion", + "splslowexpot": "splashslowness2potion", + "splslowlevel2pot": "splashslowness2potion", + "slowness2splashpot": "splashslowness2potion", + "slownesslongsplashpot": "splashslowness2potion", + "slownessextendedsplashpot": "splashslowness2potion", + "slownessexsplashpot": "splashslowness2potion", + "slownesslevel2splashpot": "splashslowness2potion", + "slow2splashpot": "splashslowness2potion", + "slowlongsplashpot": "splashslowness2potion", + "slowextendedsplashpot": "splashslowness2potion", + "slowexsplashpot": "splashslowness2potion", + "slowlevel2splashpot": "splashslowness2potion", + "lingerpotslowness2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": true + } + }, + "lingerpotslownesslong": "lingerpotslowness2", + "lingerpotslownessextended": "lingerpotslowness2", + "lingerpotslownessex": "lingerpotslowness2", + "lingerpotslownesslevel2": "lingerpotslowness2", + "lingerpotslow2": "lingerpotslowness2", + "lingerpotslowlong": "lingerpotslowness2", + "lingerpotslowextended": "lingerpotslowness2", + "lingerpotslowex": "lingerpotslowness2", + "lingerpotslowlevel2": "lingerpotslowness2", + "slownesslingerpot2": "lingerpotslowness2", + "slownesslingerpotlong": "lingerpotslowness2", + "slownesslingerpotextended": "lingerpotslowness2", + "slownesslingerpotex": "lingerpotslowness2", + "slownesslingerpotlevel2": "lingerpotslowness2", + "slowlingerpot2": "lingerpotslowness2", + "slowlingerpotlong": "lingerpotslowness2", + "slowlingerpotextended": "lingerpotslowness2", + "slowlingerpotex": "lingerpotslowness2", + "slowlingerpotlevel2": "lingerpotslowness2", + "aoepotionslowness2": "lingerpotslowness2", + "aoepotionslownesslong": "lingerpotslowness2", + "aoepotionslownessextended": "lingerpotslowness2", + "aoepotionslownessex": "lingerpotslowness2", + "aoepotionslownesslevel2": "lingerpotslowness2", + "aoepotionslow2": "lingerpotslowness2", + "aoepotionslowlong": "lingerpotslowness2", + "aoepotionslowextended": "lingerpotslowness2", + "aoepotionslowex": "lingerpotslowness2", + "aoepotionslowlevel2": "lingerpotslowness2", + "slownessaoepoiont2": "lingerpotslowness2", + "slownessaoepoiontlong": "lingerpotslowness2", + "slownessaoepoiontextended": "lingerpotslowness2", + "slownessaoepoiontex": "lingerpotslowness2", + "slownessaoepoiontlevel2": "lingerpotslowness2", + "slowaoepoiont2": "lingerpotslowness2", + "slowaoepoiontlong": "lingerpotslowness2", + "slowaoepoiontextended": "lingerpotslowness2", + "slowaoepoiontex": "lingerpotslowness2", + "slowaoepoiontlevel2": "lingerpotslowness2", + "aoepotslowness2": "lingerpotslowness2", + "aoepotslownesslong": "lingerpotslowness2", + "aoepotslownessextended": "lingerpotslowness2", + "aoepotslownessex": "lingerpotslowness2", + "aoepotslownesslevel2": "lingerpotslowness2", + "aoepotslow2": "lingerpotslowness2", + "aoepotslowlong": "lingerpotslowness2", + "aoepotslowextended": "lingerpotslowness2", + "aoepotslowex": "lingerpotslowness2", + "aoepotslowlevel2": "lingerpotslowness2", + "slownessaoepot2": "lingerpotslowness2", + "slownessaoepotlong": "lingerpotslowness2", + "slownessaoepotextended": "lingerpotslowness2", + "slownessaoepotex": "lingerpotslowness2", + "slownessaoepotlevel2": "lingerpotslowness2", + "slowaoepot2": "lingerpotslowness2", + "slowaoepotlong": "lingerpotslowness2", + "slowaoepotextended": "lingerpotslowness2", + "slowaoepotex": "lingerpotslowness2", + "slowaoepotlevel2": "lingerpotslowness2", + "areapotionslowness2": "lingerpotslowness2", + "areapotionslownesslong": "lingerpotslowness2", + "areapotionslownessextended": "lingerpotslowness2", + "areapotionslownessex": "lingerpotslowness2", + "areapotionslownesslevel2": "lingerpotslowness2", + "areapotionslow2": "lingerpotslowness2", + "areapotionslowlong": "lingerpotslowness2", + "areapotionslowextended": "lingerpotslowness2", + "areapotionslowex": "lingerpotslowness2", + "areapotionslowlevel2": "lingerpotslowness2", + "slownessareapotion2": "lingerpotslowness2", + "slownessareapotionlong": "lingerpotslowness2", + "slownessareapotionextended": "lingerpotslowness2", + "slownessareapotionex": "lingerpotslowness2", + "slownessareapotionlevel2": "lingerpotslowness2", + "slowareapotion2": "lingerpotslowness2", + "slowareapotionlong": "lingerpotslowness2", + "slowareapotionextended": "lingerpotslowness2", + "slowareapotionex": "lingerpotslowness2", + "slowareapotionlevel2": "lingerpotslowness2", + "areapotslowness2": "lingerpotslowness2", + "areapotslownesslong": "lingerpotslowness2", + "areapotslownessextended": "lingerpotslowness2", + "areapotslownessex": "lingerpotslowness2", + "areapotslownesslevel2": "lingerpotslowness2", + "areapotslow2": "lingerpotslowness2", + "areapotslowlong": "lingerpotslowness2", + "areapotslowextended": "lingerpotslowness2", + "areapotslowex": "lingerpotslowness2", + "areapotslowlevel2": "lingerpotslowness2", + "slownessareapot2": "lingerpotslowness2", + "slownessareapotlong": "lingerpotslowness2", + "slownessareapotextended": "lingerpotslowness2", + "slownessareapotex": "lingerpotslowness2", + "slownessareapotlevel2": "lingerpotslowness2", + "slowareapot2": "lingerpotslowness2", + "slowareapotlong": "lingerpotslowness2", + "slowareapotextended": "lingerpotslowness2", + "slowareapotex": "lingerpotslowness2", + "slowareapotlevel2": "lingerpotslowness2", + "cloudpotionslowness2": "lingerpotslowness2", + "cloudpotionslownesslong": "lingerpotslowness2", + "cloudpotionslownessextended": "lingerpotslowness2", + "cloudpotionslownessex": "lingerpotslowness2", + "cloudpotionslownesslevel2": "lingerpotslowness2", + "cloudpotionslow2": "lingerpotslowness2", + "cloudpotionslowlong": "lingerpotslowness2", + "cloudpotionslowextended": "lingerpotslowness2", + "cloudpotionslowex": "lingerpotslowness2", + "cloudpotionslowlevel2": "lingerpotslowness2", + "slownesscloudpotion2": "lingerpotslowness2", + "slownesscloudpotionlong": "lingerpotslowness2", + "slownesscloudpotionextended": "lingerpotslowness2", + "slownesscloudpotionex": "lingerpotslowness2", + "slownesscloudpotionlevel2": "lingerpotslowness2", + "slowcloudpotion2": "lingerpotslowness2", + "slowcloudpotionlong": "lingerpotslowness2", + "slowcloudpotionextended": "lingerpotslowness2", + "slowcloudpotionex": "lingerpotslowness2", + "slowcloudpotionlevel2": "lingerpotslowness2", + "cloudpotslowness2": "lingerpotslowness2", + "cloudpotslownesslong": "lingerpotslowness2", + "cloudpotslownessextended": "lingerpotslowness2", + "cloudpotslownessex": "lingerpotslowness2", + "cloudpotslownesslevel2": "lingerpotslowness2", + "cloudpotslow2": "lingerpotslowness2", + "cloudpotslowlong": "lingerpotslowness2", + "cloudpotslowextended": "lingerpotslowness2", + "cloudpotslowex": "lingerpotslowness2", + "cloudpotslowlevel2": "lingerpotslowness2", + "slownesscloudpot2": "lingerpotslowness2", + "slownesscloudpotlong": "lingerpotslowness2", + "slownesscloudpotextended": "lingerpotslowness2", + "slownesscloudpotex": "lingerpotslowness2", + "slownesscloudpotlevel2": "lingerpotslowness2", + "slowcloudpot2": "lingerpotslowness2", + "slowcloudpotlong": "lingerpotslowness2", + "slowcloudpotextended": "lingerpotslowness2", + "slowcloudpotex": "lingerpotslowness2", + "slowcloudpotlevel2": "lingerpotslowness2", + "arrowslowness2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_slowness", + "bukkitType": "slowness", + "isStrong": false, + "isLong": true + } + }, + "arrowslownesslong": "arrowslowness2", + "arrowslownessextended": "arrowslowness2", + "arrowslownessex": "arrowslowness2", + "arrowslownesslevel2": "arrowslowness2", + "arrowslow2": "arrowslowness2", + "arrowslowlong": "arrowslowness2", + "arrowslowextended": "arrowslowness2", + "arrowslowex": "arrowslowness2", + "arrowslowlevel2": "arrowslowness2", + "slownessarrow2": "arrowslowness2", + "slownessarrowlong": "arrowslowness2", + "slownessarrowextended": "arrowslowness2", + "slownessarrowex": "arrowslowness2", + "slownessarrowlevel2": "arrowslowness2", + "slowarrow2": "arrowslowness2", + "slowarrowlong": "arrowslowness2", + "slowarrowextended": "arrowslowness2", + "slowarrowex": "arrowslowness2", + "slowarrowlevel2": "arrowslowness2", + "waterbreathingpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": false + } + }, + "wbpotion": "waterbreathingpotion", + "waterbreathpotion": "waterbreathingpotion", + "breathingpotion": "waterbreathingpotion", + "breathpotion": "waterbreathingpotion", + "waterbreathingpot": "waterbreathingpotion", + "wbpot": "waterbreathingpotion", + "waterbreathpot": "waterbreathingpotion", + "breathingpot": "waterbreathingpotion", + "breathpot": "waterbreathingpotion", + "potionofwaterbreathing": "waterbreathingpotion", + "potionofwb": "waterbreathingpotion", + "potionofwaterbreath": "waterbreathingpotion", + "potionofbreathing": "waterbreathingpotion", + "potionofbreath": "waterbreathingpotion", + "potofwaterbreathing": "waterbreathingpotion", + "potofwb": "waterbreathingpotion", + "potofwaterbreath": "waterbreathingpotion", + "potofbreathing": "waterbreathingpotion", + "potofbreath": "waterbreathingpotion", + "splashwaterbreathingpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": false + } + }, + "splashwbpotion": "splashwaterbreathingpotion", + "splashwaterbreathpotion": "splashwaterbreathingpotion", + "splashbreathingpotion": "splashwaterbreathingpotion", + "splashbreathpotion": "splashwaterbreathingpotion", + "splwaterbreathingpotion": "splashwaterbreathingpotion", + "splwbpotion": "splashwaterbreathingpotion", + "splwaterbreathpotion": "splashwaterbreathingpotion", + "splbreathingpotion": "splashwaterbreathingpotion", + "splbreathpotion": "splashwaterbreathingpotion", + "waterbreathingsplashpotion": "splashwaterbreathingpotion", + "wbsplashpotion": "splashwaterbreathingpotion", + "waterbreathsplashpotion": "splashwaterbreathingpotion", + "breathingsplashpotion": "splashwaterbreathingpotion", + "breathsplashpotion": "splashwaterbreathingpotion", + "splashwaterbreathingpot": "splashwaterbreathingpotion", + "splashwbpot": "splashwaterbreathingpotion", + "splashwaterbreathpot": "splashwaterbreathingpotion", + "splashbreathingpot": "splashwaterbreathingpotion", + "splashbreathpot": "splashwaterbreathingpotion", + "splwaterbreathingpot": "splashwaterbreathingpotion", + "splwbpot": "splashwaterbreathingpotion", + "splwaterbreathpot": "splashwaterbreathingpotion", + "splbreathingpot": "splashwaterbreathingpotion", + "splbreathpot": "splashwaterbreathingpotion", + "waterbreathingsplashpot": "splashwaterbreathingpotion", + "wbsplashpot": "splashwaterbreathingpotion", + "waterbreathsplashpot": "splashwaterbreathingpotion", + "breathingsplashpot": "splashwaterbreathingpotion", + "breathsplashpot": "splashwaterbreathingpotion", + "lingerpotwaterbreathing": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": false + } + }, + "lingerpotwb": "lingerpotwaterbreathing", + "lingerpotwaterbreath": "lingerpotwaterbreathing", + "lingerpotbreathing": "lingerpotwaterbreathing", + "lingerpotbreath": "lingerpotwaterbreathing", + "waterbreathinglingerpot": "lingerpotwaterbreathing", + "wblingerpot": "lingerpotwaterbreathing", + "waterbreathlingerpot": "lingerpotwaterbreathing", + "breathinglingerpot": "lingerpotwaterbreathing", + "breathlingerpot": "lingerpotwaterbreathing", + "aoepotionwaterbreathing": "lingerpotwaterbreathing", + "aoepotionwb": "lingerpotwaterbreathing", + "aoepotionwaterbreath": "lingerpotwaterbreathing", + "aoepotionbreathing": "lingerpotwaterbreathing", + "aoepotionbreath": "lingerpotwaterbreathing", + "waterbreathingaoepoiont": "lingerpotwaterbreathing", + "wbaoepoiont": "lingerpotwaterbreathing", + "waterbreathaoepoiont": "lingerpotwaterbreathing", + "breathingaoepoiont": "lingerpotwaterbreathing", + "breathaoepoiont": "lingerpotwaterbreathing", + "aoepotwaterbreathing": "lingerpotwaterbreathing", + "aoepotwb": "lingerpotwaterbreathing", + "aoepotwaterbreath": "lingerpotwaterbreathing", + "aoepotbreathing": "lingerpotwaterbreathing", + "aoepotbreath": "lingerpotwaterbreathing", + "waterbreathingaoepot": "lingerpotwaterbreathing", + "wbaoepot": "lingerpotwaterbreathing", + "waterbreathaoepot": "lingerpotwaterbreathing", + "breathingaoepot": "lingerpotwaterbreathing", + "breathaoepot": "lingerpotwaterbreathing", + "areapotionwaterbreathing": "lingerpotwaterbreathing", + "areapotionwb": "lingerpotwaterbreathing", + "areapotionwaterbreath": "lingerpotwaterbreathing", + "areapotionbreathing": "lingerpotwaterbreathing", + "areapotionbreath": "lingerpotwaterbreathing", + "waterbreathingareapotion": "lingerpotwaterbreathing", + "wbareapotion": "lingerpotwaterbreathing", + "waterbreathareapotion": "lingerpotwaterbreathing", + "breathingareapotion": "lingerpotwaterbreathing", + "breathareapotion": "lingerpotwaterbreathing", + "areapotwaterbreathing": "lingerpotwaterbreathing", + "areapotwb": "lingerpotwaterbreathing", + "areapotwaterbreath": "lingerpotwaterbreathing", + "areapotbreathing": "lingerpotwaterbreathing", + "areapotbreath": "lingerpotwaterbreathing", + "waterbreathingareapot": "lingerpotwaterbreathing", + "wbareapot": "lingerpotwaterbreathing", + "waterbreathareapot": "lingerpotwaterbreathing", + "breathingareapot": "lingerpotwaterbreathing", + "breathareapot": "lingerpotwaterbreathing", + "cloudpotionwaterbreathing": "lingerpotwaterbreathing", + "cloudpotionwb": "lingerpotwaterbreathing", + "cloudpotionwaterbreath": "lingerpotwaterbreathing", + "cloudpotionbreathing": "lingerpotwaterbreathing", + "cloudpotionbreath": "lingerpotwaterbreathing", + "waterbreathingcloudpotion": "lingerpotwaterbreathing", + "wbcloudpotion": "lingerpotwaterbreathing", + "waterbreathcloudpotion": "lingerpotwaterbreathing", + "breathingcloudpotion": "lingerpotwaterbreathing", + "breathcloudpotion": "lingerpotwaterbreathing", + "cloudpotwaterbreathing": "lingerpotwaterbreathing", + "cloudpotwb": "lingerpotwaterbreathing", + "cloudpotwaterbreath": "lingerpotwaterbreathing", + "cloudpotbreathing": "lingerpotwaterbreathing", + "cloudpotbreath": "lingerpotwaterbreathing", + "waterbreathingcloudpot": "lingerpotwaterbreathing", + "wbcloudpot": "lingerpotwaterbreathing", + "waterbreathcloudpot": "lingerpotwaterbreathing", + "breathingcloudpot": "lingerpotwaterbreathing", + "breathcloudpot": "lingerpotwaterbreathing", + "arrowwaterbreathing": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": false + } + }, + "arrowwb": "arrowwaterbreathing", + "arrowwaterbreath": "arrowwaterbreathing", + "arrowbreathing": "arrowwaterbreathing", + "arrowbreath": "arrowwaterbreathing", + "waterbreathingarrow": "arrowwaterbreathing", + "wbarrow": "arrowwaterbreathing", + "waterbreatharrow": "arrowwaterbreathing", + "breathingarrow": "arrowwaterbreathing", + "breatharrow": "arrowwaterbreathing", + "waterbreathing2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": true + } + }, + "waterbreathinglongpotion": "waterbreathing2potion", + "waterbreathingextendedpotion": "waterbreathing2potion", + "waterbreathingexpotion": "waterbreathing2potion", + "waterbreathinglevel2potion": "waterbreathing2potion", + "wb2potion": "waterbreathing2potion", + "wblongpotion": "waterbreathing2potion", + "wbextendedpotion": "waterbreathing2potion", + "wbexpotion": "waterbreathing2potion", + "wblevel2potion": "waterbreathing2potion", + "waterbreath2potion": "waterbreathing2potion", + "waterbreathlongpotion": "waterbreathing2potion", + "waterbreathextendedpotion": "waterbreathing2potion", + "waterbreathexpotion": "waterbreathing2potion", + "waterbreathlevel2potion": "waterbreathing2potion", + "breathing2potion": "waterbreathing2potion", + "breathinglongpotion": "waterbreathing2potion", + "breathingextendedpotion": "waterbreathing2potion", + "breathingexpotion": "waterbreathing2potion", + "breathinglevel2potion": "waterbreathing2potion", + "breath2potion": "waterbreathing2potion", + "breathlongpotion": "waterbreathing2potion", + "breathextendedpotion": "waterbreathing2potion", + "breathexpotion": "waterbreathing2potion", + "breathlevel2potion": "waterbreathing2potion", + "waterbreathing2pot": "waterbreathing2potion", + "waterbreathinglongpot": "waterbreathing2potion", + "waterbreathingextendedpot": "waterbreathing2potion", + "waterbreathingexpot": "waterbreathing2potion", + "waterbreathinglevel2pot": "waterbreathing2potion", + "wb2pot": "waterbreathing2potion", + "wblongpot": "waterbreathing2potion", + "wbextendedpot": "waterbreathing2potion", + "wbexpot": "waterbreathing2potion", + "wblevel2pot": "waterbreathing2potion", + "waterbreath2pot": "waterbreathing2potion", + "waterbreathlongpot": "waterbreathing2potion", + "waterbreathextendedpot": "waterbreathing2potion", + "waterbreathexpot": "waterbreathing2potion", + "waterbreathlevel2pot": "waterbreathing2potion", + "breathing2pot": "waterbreathing2potion", + "breathinglongpot": "waterbreathing2potion", + "breathingextendedpot": "waterbreathing2potion", + "breathingexpot": "waterbreathing2potion", + "breathinglevel2pot": "waterbreathing2potion", + "breath2pot": "waterbreathing2potion", + "breathlongpot": "waterbreathing2potion", + "breathextendedpot": "waterbreathing2potion", + "breathexpot": "waterbreathing2potion", + "breathlevel2pot": "waterbreathing2potion", + "potionofwaterbreathing2": "waterbreathing2potion", + "potionofwaterbreathinglong": "waterbreathing2potion", + "potionofwaterbreathingextended": "waterbreathing2potion", + "potionofwaterbreathingex": "waterbreathing2potion", + "potionofwaterbreathinglevel2": "waterbreathing2potion", + "potionofwb2": "waterbreathing2potion", + "potionofwblong": "waterbreathing2potion", + "potionofwbextended": "waterbreathing2potion", + "potionofwbex": "waterbreathing2potion", + "potionofwblevel2": "waterbreathing2potion", + "potionofwaterbreath2": "waterbreathing2potion", + "potionofwaterbreathlong": "waterbreathing2potion", + "potionofwaterbreathextended": "waterbreathing2potion", + "potionofwaterbreathex": "waterbreathing2potion", + "potionofwaterbreathlevel2": "waterbreathing2potion", + "potionofbreathing2": "waterbreathing2potion", + "potionofbreathinglong": "waterbreathing2potion", + "potionofbreathingextended": "waterbreathing2potion", + "potionofbreathingex": "waterbreathing2potion", + "potionofbreathinglevel2": "waterbreathing2potion", + "potionofbreath2": "waterbreathing2potion", + "potionofbreathlong": "waterbreathing2potion", + "potionofbreathextended": "waterbreathing2potion", + "potionofbreathex": "waterbreathing2potion", + "potionofbreathlevel2": "waterbreathing2potion", + "potofwaterbreathing2": "waterbreathing2potion", + "potofwaterbreathinglong": "waterbreathing2potion", + "potofwaterbreathingextended": "waterbreathing2potion", + "potofwaterbreathingex": "waterbreathing2potion", + "potofwaterbreathinglevel2": "waterbreathing2potion", + "potofwb2": "waterbreathing2potion", + "potofwblong": "waterbreathing2potion", + "potofwbextended": "waterbreathing2potion", + "potofwbex": "waterbreathing2potion", + "potofwblevel2": "waterbreathing2potion", + "potofwaterbreath2": "waterbreathing2potion", + "potofwaterbreathlong": "waterbreathing2potion", + "potofwaterbreathextended": "waterbreathing2potion", + "potofwaterbreathex": "waterbreathing2potion", + "potofwaterbreathlevel2": "waterbreathing2potion", + "potofbreathing2": "waterbreathing2potion", + "potofbreathinglong": "waterbreathing2potion", + "potofbreathingextended": "waterbreathing2potion", + "potofbreathingex": "waterbreathing2potion", + "potofbreathinglevel2": "waterbreathing2potion", + "potofbreath2": "waterbreathing2potion", + "potofbreathlong": "waterbreathing2potion", + "potofbreathextended": "waterbreathing2potion", + "potofbreathex": "waterbreathing2potion", + "potofbreathlevel2": "waterbreathing2potion", + "splashwaterbreathing2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": true + } + }, + "splashwaterbreathinglongpotion": "splashwaterbreathing2potion", + "splashwaterbreathingextendedpotion": "splashwaterbreathing2potion", + "splashwaterbreathingexpotion": "splashwaterbreathing2potion", + "splashwaterbreathinglevel2potion": "splashwaterbreathing2potion", + "splashwb2potion": "splashwaterbreathing2potion", + "splashwblongpotion": "splashwaterbreathing2potion", + "splashwbextendedpotion": "splashwaterbreathing2potion", + "splashwbexpotion": "splashwaterbreathing2potion", + "splashwblevel2potion": "splashwaterbreathing2potion", + "splashwaterbreath2potion": "splashwaterbreathing2potion", + "splashwaterbreathlongpotion": "splashwaterbreathing2potion", + "splashwaterbreathextendedpotion": "splashwaterbreathing2potion", + "splashwaterbreathexpotion": "splashwaterbreathing2potion", + "splashwaterbreathlevel2potion": "splashwaterbreathing2potion", + "splashbreathing2potion": "splashwaterbreathing2potion", + "splashbreathinglongpotion": "splashwaterbreathing2potion", + "splashbreathingextendedpotion": "splashwaterbreathing2potion", + "splashbreathingexpotion": "splashwaterbreathing2potion", + "splashbreathinglevel2potion": "splashwaterbreathing2potion", + "splashbreath2potion": "splashwaterbreathing2potion", + "splashbreathlongpotion": "splashwaterbreathing2potion", + "splashbreathextendedpotion": "splashwaterbreathing2potion", + "splashbreathexpotion": "splashwaterbreathing2potion", + "splashbreathlevel2potion": "splashwaterbreathing2potion", + "splwaterbreathing2potion": "splashwaterbreathing2potion", + "splwaterbreathinglongpotion": "splashwaterbreathing2potion", + "splwaterbreathingextendedpotion": "splashwaterbreathing2potion", + "splwaterbreathingexpotion": "splashwaterbreathing2potion", + "splwaterbreathinglevel2potion": "splashwaterbreathing2potion", + "splwb2potion": "splashwaterbreathing2potion", + "splwblongpotion": "splashwaterbreathing2potion", + "splwbextendedpotion": "splashwaterbreathing2potion", + "splwbexpotion": "splashwaterbreathing2potion", + "splwblevel2potion": "splashwaterbreathing2potion", + "splwaterbreath2potion": "splashwaterbreathing2potion", + "splwaterbreathlongpotion": "splashwaterbreathing2potion", + "splwaterbreathextendedpotion": "splashwaterbreathing2potion", + "splwaterbreathexpotion": "splashwaterbreathing2potion", + "splwaterbreathlevel2potion": "splashwaterbreathing2potion", + "splbreathing2potion": "splashwaterbreathing2potion", + "splbreathinglongpotion": "splashwaterbreathing2potion", + "splbreathingextendedpotion": "splashwaterbreathing2potion", + "splbreathingexpotion": "splashwaterbreathing2potion", + "splbreathinglevel2potion": "splashwaterbreathing2potion", + "splbreath2potion": "splashwaterbreathing2potion", + "splbreathlongpotion": "splashwaterbreathing2potion", + "splbreathextendedpotion": "splashwaterbreathing2potion", + "splbreathexpotion": "splashwaterbreathing2potion", + "splbreathlevel2potion": "splashwaterbreathing2potion", + "waterbreathing2splashpotion": "splashwaterbreathing2potion", + "waterbreathinglongsplashpotion": "splashwaterbreathing2potion", + "waterbreathingextendedsplashpotion": "splashwaterbreathing2potion", + "waterbreathingexsplashpotion": "splashwaterbreathing2potion", + "waterbreathinglevel2splashpotion": "splashwaterbreathing2potion", + "wb2splashpotion": "splashwaterbreathing2potion", + "wblongsplashpotion": "splashwaterbreathing2potion", + "wbextendedsplashpotion": "splashwaterbreathing2potion", + "wbexsplashpotion": "splashwaterbreathing2potion", + "wblevel2splashpotion": "splashwaterbreathing2potion", + "waterbreath2splashpotion": "splashwaterbreathing2potion", + "waterbreathlongsplashpotion": "splashwaterbreathing2potion", + "waterbreathextendedsplashpotion": "splashwaterbreathing2potion", + "waterbreathexsplashpotion": "splashwaterbreathing2potion", + "waterbreathlevel2splashpotion": "splashwaterbreathing2potion", + "breathing2splashpotion": "splashwaterbreathing2potion", + "breathinglongsplashpotion": "splashwaterbreathing2potion", + "breathingextendedsplashpotion": "splashwaterbreathing2potion", + "breathingexsplashpotion": "splashwaterbreathing2potion", + "breathinglevel2splashpotion": "splashwaterbreathing2potion", + "breath2splashpotion": "splashwaterbreathing2potion", + "breathlongsplashpotion": "splashwaterbreathing2potion", + "breathextendedsplashpotion": "splashwaterbreathing2potion", + "breathexsplashpotion": "splashwaterbreathing2potion", + "breathlevel2splashpotion": "splashwaterbreathing2potion", + "splashwaterbreathing2pot": "splashwaterbreathing2potion", + "splashwaterbreathinglongpot": "splashwaterbreathing2potion", + "splashwaterbreathingextendedpot": "splashwaterbreathing2potion", + "splashwaterbreathingexpot": "splashwaterbreathing2potion", + "splashwaterbreathinglevel2pot": "splashwaterbreathing2potion", + "splashwb2pot": "splashwaterbreathing2potion", + "splashwblongpot": "splashwaterbreathing2potion", + "splashwbextendedpot": "splashwaterbreathing2potion", + "splashwbexpot": "splashwaterbreathing2potion", + "splashwblevel2pot": "splashwaterbreathing2potion", + "splashwaterbreath2pot": "splashwaterbreathing2potion", + "splashwaterbreathlongpot": "splashwaterbreathing2potion", + "splashwaterbreathextendedpot": "splashwaterbreathing2potion", + "splashwaterbreathexpot": "splashwaterbreathing2potion", + "splashwaterbreathlevel2pot": "splashwaterbreathing2potion", + "splashbreathing2pot": "splashwaterbreathing2potion", + "splashbreathinglongpot": "splashwaterbreathing2potion", + "splashbreathingextendedpot": "splashwaterbreathing2potion", + "splashbreathingexpot": "splashwaterbreathing2potion", + "splashbreathinglevel2pot": "splashwaterbreathing2potion", + "splashbreath2pot": "splashwaterbreathing2potion", + "splashbreathlongpot": "splashwaterbreathing2potion", + "splashbreathextendedpot": "splashwaterbreathing2potion", + "splashbreathexpot": "splashwaterbreathing2potion", + "splashbreathlevel2pot": "splashwaterbreathing2potion", + "splwaterbreathing2pot": "splashwaterbreathing2potion", + "splwaterbreathinglongpot": "splashwaterbreathing2potion", + "splwaterbreathingextendedpot": "splashwaterbreathing2potion", + "splwaterbreathingexpot": "splashwaterbreathing2potion", + "splwaterbreathinglevel2pot": "splashwaterbreathing2potion", + "splwb2pot": "splashwaterbreathing2potion", + "splwblongpot": "splashwaterbreathing2potion", + "splwbextendedpot": "splashwaterbreathing2potion", + "splwbexpot": "splashwaterbreathing2potion", + "splwblevel2pot": "splashwaterbreathing2potion", + "splwaterbreath2pot": "splashwaterbreathing2potion", + "splwaterbreathlongpot": "splashwaterbreathing2potion", + "splwaterbreathextendedpot": "splashwaterbreathing2potion", + "splwaterbreathexpot": "splashwaterbreathing2potion", + "splwaterbreathlevel2pot": "splashwaterbreathing2potion", + "splbreathing2pot": "splashwaterbreathing2potion", + "splbreathinglongpot": "splashwaterbreathing2potion", + "splbreathingextendedpot": "splashwaterbreathing2potion", + "splbreathingexpot": "splashwaterbreathing2potion", + "splbreathinglevel2pot": "splashwaterbreathing2potion", + "splbreath2pot": "splashwaterbreathing2potion", + "splbreathlongpot": "splashwaterbreathing2potion", + "splbreathextendedpot": "splashwaterbreathing2potion", + "splbreathexpot": "splashwaterbreathing2potion", + "splbreathlevel2pot": "splashwaterbreathing2potion", + "waterbreathing2splashpot": "splashwaterbreathing2potion", + "waterbreathinglongsplashpot": "splashwaterbreathing2potion", + "waterbreathingextendedsplashpot": "splashwaterbreathing2potion", + "waterbreathingexsplashpot": "splashwaterbreathing2potion", + "waterbreathinglevel2splashpot": "splashwaterbreathing2potion", + "wb2splashpot": "splashwaterbreathing2potion", + "wblongsplashpot": "splashwaterbreathing2potion", + "wbextendedsplashpot": "splashwaterbreathing2potion", + "wbexsplashpot": "splashwaterbreathing2potion", + "wblevel2splashpot": "splashwaterbreathing2potion", + "waterbreath2splashpot": "splashwaterbreathing2potion", + "waterbreathlongsplashpot": "splashwaterbreathing2potion", + "waterbreathextendedsplashpot": "splashwaterbreathing2potion", + "waterbreathexsplashpot": "splashwaterbreathing2potion", + "waterbreathlevel2splashpot": "splashwaterbreathing2potion", + "breathing2splashpot": "splashwaterbreathing2potion", + "breathinglongsplashpot": "splashwaterbreathing2potion", + "breathingextendedsplashpot": "splashwaterbreathing2potion", + "breathingexsplashpot": "splashwaterbreathing2potion", + "breathinglevel2splashpot": "splashwaterbreathing2potion", + "breath2splashpot": "splashwaterbreathing2potion", + "breathlongsplashpot": "splashwaterbreathing2potion", + "breathextendedsplashpot": "splashwaterbreathing2potion", + "breathexsplashpot": "splashwaterbreathing2potion", + "breathlevel2splashpot": "splashwaterbreathing2potion", + "lingerpotwaterbreathing2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": true + } + }, + "lingerpotwaterbreathinglong": "lingerpotwaterbreathing2", + "lingerpotwaterbreathingextended": "lingerpotwaterbreathing2", + "lingerpotwaterbreathingex": "lingerpotwaterbreathing2", + "lingerpotwaterbreathinglevel2": "lingerpotwaterbreathing2", + "lingerpotwb2": "lingerpotwaterbreathing2", + "lingerpotwblong": "lingerpotwaterbreathing2", + "lingerpotwbextended": "lingerpotwaterbreathing2", + "lingerpotwbex": "lingerpotwaterbreathing2", + "lingerpotwblevel2": "lingerpotwaterbreathing2", + "lingerpotwaterbreath2": "lingerpotwaterbreathing2", + "lingerpotwaterbreathlong": "lingerpotwaterbreathing2", + "lingerpotwaterbreathextended": "lingerpotwaterbreathing2", + "lingerpotwaterbreathex": "lingerpotwaterbreathing2", + "lingerpotwaterbreathlevel2": "lingerpotwaterbreathing2", + "lingerpotbreathing2": "lingerpotwaterbreathing2", + "lingerpotbreathinglong": "lingerpotwaterbreathing2", + "lingerpotbreathingextended": "lingerpotwaterbreathing2", + "lingerpotbreathingex": "lingerpotwaterbreathing2", + "lingerpotbreathinglevel2": "lingerpotwaterbreathing2", + "lingerpotbreath2": "lingerpotwaterbreathing2", + "lingerpotbreathlong": "lingerpotwaterbreathing2", + "lingerpotbreathextended": "lingerpotwaterbreathing2", + "lingerpotbreathex": "lingerpotwaterbreathing2", + "lingerpotbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathinglingerpot2": "lingerpotwaterbreathing2", + "waterbreathinglingerpotlong": "lingerpotwaterbreathing2", + "waterbreathinglingerpotextended": "lingerpotwaterbreathing2", + "waterbreathinglingerpotex": "lingerpotwaterbreathing2", + "waterbreathinglingerpotlevel2": "lingerpotwaterbreathing2", + "wblingerpot2": "lingerpotwaterbreathing2", + "wblingerpotlong": "lingerpotwaterbreathing2", + "wblingerpotextended": "lingerpotwaterbreathing2", + "wblingerpotex": "lingerpotwaterbreathing2", + "wblingerpotlevel2": "lingerpotwaterbreathing2", + "waterbreathlingerpot2": "lingerpotwaterbreathing2", + "waterbreathlingerpotlong": "lingerpotwaterbreathing2", + "waterbreathlingerpotextended": "lingerpotwaterbreathing2", + "waterbreathlingerpotex": "lingerpotwaterbreathing2", + "waterbreathlingerpotlevel2": "lingerpotwaterbreathing2", + "breathinglingerpot2": "lingerpotwaterbreathing2", + "breathinglingerpotlong": "lingerpotwaterbreathing2", + "breathinglingerpotextended": "lingerpotwaterbreathing2", + "breathinglingerpotex": "lingerpotwaterbreathing2", + "breathinglingerpotlevel2": "lingerpotwaterbreathing2", + "breathlingerpot2": "lingerpotwaterbreathing2", + "breathlingerpotlong": "lingerpotwaterbreathing2", + "breathlingerpotextended": "lingerpotwaterbreathing2", + "breathlingerpotex": "lingerpotwaterbreathing2", + "breathlingerpotlevel2": "lingerpotwaterbreathing2", + "aoepotionwaterbreathing2": "lingerpotwaterbreathing2", + "aoepotionwaterbreathinglong": "lingerpotwaterbreathing2", + "aoepotionwaterbreathingextended": "lingerpotwaterbreathing2", + "aoepotionwaterbreathingex": "lingerpotwaterbreathing2", + "aoepotionwaterbreathinglevel2": "lingerpotwaterbreathing2", + "aoepotionwb2": "lingerpotwaterbreathing2", + "aoepotionwblong": "lingerpotwaterbreathing2", + "aoepotionwbextended": "lingerpotwaterbreathing2", + "aoepotionwbex": "lingerpotwaterbreathing2", + "aoepotionwblevel2": "lingerpotwaterbreathing2", + "aoepotionwaterbreath2": "lingerpotwaterbreathing2", + "aoepotionwaterbreathlong": "lingerpotwaterbreathing2", + "aoepotionwaterbreathextended": "lingerpotwaterbreathing2", + "aoepotionwaterbreathex": "lingerpotwaterbreathing2", + "aoepotionwaterbreathlevel2": "lingerpotwaterbreathing2", + "aoepotionbreathing2": "lingerpotwaterbreathing2", + "aoepotionbreathinglong": "lingerpotwaterbreathing2", + "aoepotionbreathingextended": "lingerpotwaterbreathing2", + "aoepotionbreathingex": "lingerpotwaterbreathing2", + "aoepotionbreathinglevel2": "lingerpotwaterbreathing2", + "aoepotionbreath2": "lingerpotwaterbreathing2", + "aoepotionbreathlong": "lingerpotwaterbreathing2", + "aoepotionbreathextended": "lingerpotwaterbreathing2", + "aoepotionbreathex": "lingerpotwaterbreathing2", + "aoepotionbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingaoepoiont2": "lingerpotwaterbreathing2", + "waterbreathingaoepoiontlong": "lingerpotwaterbreathing2", + "waterbreathingaoepoiontextended": "lingerpotwaterbreathing2", + "waterbreathingaoepoiontex": "lingerpotwaterbreathing2", + "waterbreathingaoepoiontlevel2": "lingerpotwaterbreathing2", + "wbaoepoiont2": "lingerpotwaterbreathing2", + "wbaoepoiontlong": "lingerpotwaterbreathing2", + "wbaoepoiontextended": "lingerpotwaterbreathing2", + "wbaoepoiontex": "lingerpotwaterbreathing2", + "wbaoepoiontlevel2": "lingerpotwaterbreathing2", + "waterbreathaoepoiont2": "lingerpotwaterbreathing2", + "waterbreathaoepoiontlong": "lingerpotwaterbreathing2", + "waterbreathaoepoiontextended": "lingerpotwaterbreathing2", + "waterbreathaoepoiontex": "lingerpotwaterbreathing2", + "waterbreathaoepoiontlevel2": "lingerpotwaterbreathing2", + "breathingaoepoiont2": "lingerpotwaterbreathing2", + "breathingaoepoiontlong": "lingerpotwaterbreathing2", + "breathingaoepoiontextended": "lingerpotwaterbreathing2", + "breathingaoepoiontex": "lingerpotwaterbreathing2", + "breathingaoepoiontlevel2": "lingerpotwaterbreathing2", + "breathaoepoiont2": "lingerpotwaterbreathing2", + "breathaoepoiontlong": "lingerpotwaterbreathing2", + "breathaoepoiontextended": "lingerpotwaterbreathing2", + "breathaoepoiontex": "lingerpotwaterbreathing2", + "breathaoepoiontlevel2": "lingerpotwaterbreathing2", + "aoepotwaterbreathing2": "lingerpotwaterbreathing2", + "aoepotwaterbreathinglong": "lingerpotwaterbreathing2", + "aoepotwaterbreathingextended": "lingerpotwaterbreathing2", + "aoepotwaterbreathingex": "lingerpotwaterbreathing2", + "aoepotwaterbreathinglevel2": "lingerpotwaterbreathing2", + "aoepotwb2": "lingerpotwaterbreathing2", + "aoepotwblong": "lingerpotwaterbreathing2", + "aoepotwbextended": "lingerpotwaterbreathing2", + "aoepotwbex": "lingerpotwaterbreathing2", + "aoepotwblevel2": "lingerpotwaterbreathing2", + "aoepotwaterbreath2": "lingerpotwaterbreathing2", + "aoepotwaterbreathlong": "lingerpotwaterbreathing2", + "aoepotwaterbreathextended": "lingerpotwaterbreathing2", + "aoepotwaterbreathex": "lingerpotwaterbreathing2", + "aoepotwaterbreathlevel2": "lingerpotwaterbreathing2", + "aoepotbreathing2": "lingerpotwaterbreathing2", + "aoepotbreathinglong": "lingerpotwaterbreathing2", + "aoepotbreathingextended": "lingerpotwaterbreathing2", + "aoepotbreathingex": "lingerpotwaterbreathing2", + "aoepotbreathinglevel2": "lingerpotwaterbreathing2", + "aoepotbreath2": "lingerpotwaterbreathing2", + "aoepotbreathlong": "lingerpotwaterbreathing2", + "aoepotbreathextended": "lingerpotwaterbreathing2", + "aoepotbreathex": "lingerpotwaterbreathing2", + "aoepotbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingaoepot2": "lingerpotwaterbreathing2", + "waterbreathingaoepotlong": "lingerpotwaterbreathing2", + "waterbreathingaoepotextended": "lingerpotwaterbreathing2", + "waterbreathingaoepotex": "lingerpotwaterbreathing2", + "waterbreathingaoepotlevel2": "lingerpotwaterbreathing2", + "wbaoepot2": "lingerpotwaterbreathing2", + "wbaoepotlong": "lingerpotwaterbreathing2", + "wbaoepotextended": "lingerpotwaterbreathing2", + "wbaoepotex": "lingerpotwaterbreathing2", + "wbaoepotlevel2": "lingerpotwaterbreathing2", + "waterbreathaoepot2": "lingerpotwaterbreathing2", + "waterbreathaoepotlong": "lingerpotwaterbreathing2", + "waterbreathaoepotextended": "lingerpotwaterbreathing2", + "waterbreathaoepotex": "lingerpotwaterbreathing2", + "waterbreathaoepotlevel2": "lingerpotwaterbreathing2", + "breathingaoepot2": "lingerpotwaterbreathing2", + "breathingaoepotlong": "lingerpotwaterbreathing2", + "breathingaoepotextended": "lingerpotwaterbreathing2", + "breathingaoepotex": "lingerpotwaterbreathing2", + "breathingaoepotlevel2": "lingerpotwaterbreathing2", + "breathaoepot2": "lingerpotwaterbreathing2", + "breathaoepotlong": "lingerpotwaterbreathing2", + "breathaoepotextended": "lingerpotwaterbreathing2", + "breathaoepotex": "lingerpotwaterbreathing2", + "breathaoepotlevel2": "lingerpotwaterbreathing2", + "areapotionwaterbreathing2": "lingerpotwaterbreathing2", + "areapotionwaterbreathinglong": "lingerpotwaterbreathing2", + "areapotionwaterbreathingextended": "lingerpotwaterbreathing2", + "areapotionwaterbreathingex": "lingerpotwaterbreathing2", + "areapotionwaterbreathinglevel2": "lingerpotwaterbreathing2", + "areapotionwb2": "lingerpotwaterbreathing2", + "areapotionwblong": "lingerpotwaterbreathing2", + "areapotionwbextended": "lingerpotwaterbreathing2", + "areapotionwbex": "lingerpotwaterbreathing2", + "areapotionwblevel2": "lingerpotwaterbreathing2", + "areapotionwaterbreath2": "lingerpotwaterbreathing2", + "areapotionwaterbreathlong": "lingerpotwaterbreathing2", + "areapotionwaterbreathextended": "lingerpotwaterbreathing2", + "areapotionwaterbreathex": "lingerpotwaterbreathing2", + "areapotionwaterbreathlevel2": "lingerpotwaterbreathing2", + "areapotionbreathing2": "lingerpotwaterbreathing2", + "areapotionbreathinglong": "lingerpotwaterbreathing2", + "areapotionbreathingextended": "lingerpotwaterbreathing2", + "areapotionbreathingex": "lingerpotwaterbreathing2", + "areapotionbreathinglevel2": "lingerpotwaterbreathing2", + "areapotionbreath2": "lingerpotwaterbreathing2", + "areapotionbreathlong": "lingerpotwaterbreathing2", + "areapotionbreathextended": "lingerpotwaterbreathing2", + "areapotionbreathex": "lingerpotwaterbreathing2", + "areapotionbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingareapotion2": "lingerpotwaterbreathing2", + "waterbreathingareapotionlong": "lingerpotwaterbreathing2", + "waterbreathingareapotionextended": "lingerpotwaterbreathing2", + "waterbreathingareapotionex": "lingerpotwaterbreathing2", + "waterbreathingareapotionlevel2": "lingerpotwaterbreathing2", + "wbareapotion2": "lingerpotwaterbreathing2", + "wbareapotionlong": "lingerpotwaterbreathing2", + "wbareapotionextended": "lingerpotwaterbreathing2", + "wbareapotionex": "lingerpotwaterbreathing2", + "wbareapotionlevel2": "lingerpotwaterbreathing2", + "waterbreathareapotion2": "lingerpotwaterbreathing2", + "waterbreathareapotionlong": "lingerpotwaterbreathing2", + "waterbreathareapotionextended": "lingerpotwaterbreathing2", + "waterbreathareapotionex": "lingerpotwaterbreathing2", + "waterbreathareapotionlevel2": "lingerpotwaterbreathing2", + "breathingareapotion2": "lingerpotwaterbreathing2", + "breathingareapotionlong": "lingerpotwaterbreathing2", + "breathingareapotionextended": "lingerpotwaterbreathing2", + "breathingareapotionex": "lingerpotwaterbreathing2", + "breathingareapotionlevel2": "lingerpotwaterbreathing2", + "breathareapotion2": "lingerpotwaterbreathing2", + "breathareapotionlong": "lingerpotwaterbreathing2", + "breathareapotionextended": "lingerpotwaterbreathing2", + "breathareapotionex": "lingerpotwaterbreathing2", + "breathareapotionlevel2": "lingerpotwaterbreathing2", + "areapotwaterbreathing2": "lingerpotwaterbreathing2", + "areapotwaterbreathinglong": "lingerpotwaterbreathing2", + "areapotwaterbreathingextended": "lingerpotwaterbreathing2", + "areapotwaterbreathingex": "lingerpotwaterbreathing2", + "areapotwaterbreathinglevel2": "lingerpotwaterbreathing2", + "areapotwb2": "lingerpotwaterbreathing2", + "areapotwblong": "lingerpotwaterbreathing2", + "areapotwbextended": "lingerpotwaterbreathing2", + "areapotwbex": "lingerpotwaterbreathing2", + "areapotwblevel2": "lingerpotwaterbreathing2", + "areapotwaterbreath2": "lingerpotwaterbreathing2", + "areapotwaterbreathlong": "lingerpotwaterbreathing2", + "areapotwaterbreathextended": "lingerpotwaterbreathing2", + "areapotwaterbreathex": "lingerpotwaterbreathing2", + "areapotwaterbreathlevel2": "lingerpotwaterbreathing2", + "areapotbreathing2": "lingerpotwaterbreathing2", + "areapotbreathinglong": "lingerpotwaterbreathing2", + "areapotbreathingextended": "lingerpotwaterbreathing2", + "areapotbreathingex": "lingerpotwaterbreathing2", + "areapotbreathinglevel2": "lingerpotwaterbreathing2", + "areapotbreath2": "lingerpotwaterbreathing2", + "areapotbreathlong": "lingerpotwaterbreathing2", + "areapotbreathextended": "lingerpotwaterbreathing2", + "areapotbreathex": "lingerpotwaterbreathing2", + "areapotbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingareapot2": "lingerpotwaterbreathing2", + "waterbreathingareapotlong": "lingerpotwaterbreathing2", + "waterbreathingareapotextended": "lingerpotwaterbreathing2", + "waterbreathingareapotex": "lingerpotwaterbreathing2", + "waterbreathingareapotlevel2": "lingerpotwaterbreathing2", + "wbareapot2": "lingerpotwaterbreathing2", + "wbareapotlong": "lingerpotwaterbreathing2", + "wbareapotextended": "lingerpotwaterbreathing2", + "wbareapotex": "lingerpotwaterbreathing2", + "wbareapotlevel2": "lingerpotwaterbreathing2", + "waterbreathareapot2": "lingerpotwaterbreathing2", + "waterbreathareapotlong": "lingerpotwaterbreathing2", + "waterbreathareapotextended": "lingerpotwaterbreathing2", + "waterbreathareapotex": "lingerpotwaterbreathing2", + "waterbreathareapotlevel2": "lingerpotwaterbreathing2", + "breathingareapot2": "lingerpotwaterbreathing2", + "breathingareapotlong": "lingerpotwaterbreathing2", + "breathingareapotextended": "lingerpotwaterbreathing2", + "breathingareapotex": "lingerpotwaterbreathing2", + "breathingareapotlevel2": "lingerpotwaterbreathing2", + "breathareapot2": "lingerpotwaterbreathing2", + "breathareapotlong": "lingerpotwaterbreathing2", + "breathareapotextended": "lingerpotwaterbreathing2", + "breathareapotex": "lingerpotwaterbreathing2", + "breathareapotlevel2": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathing2": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathinglong": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathingextended": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathingex": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathinglevel2": "lingerpotwaterbreathing2", + "cloudpotionwb2": "lingerpotwaterbreathing2", + "cloudpotionwblong": "lingerpotwaterbreathing2", + "cloudpotionwbextended": "lingerpotwaterbreathing2", + "cloudpotionwbex": "lingerpotwaterbreathing2", + "cloudpotionwblevel2": "lingerpotwaterbreathing2", + "cloudpotionwaterbreath2": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathlong": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathextended": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathex": "lingerpotwaterbreathing2", + "cloudpotionwaterbreathlevel2": "lingerpotwaterbreathing2", + "cloudpotionbreathing2": "lingerpotwaterbreathing2", + "cloudpotionbreathinglong": "lingerpotwaterbreathing2", + "cloudpotionbreathingextended": "lingerpotwaterbreathing2", + "cloudpotionbreathingex": "lingerpotwaterbreathing2", + "cloudpotionbreathinglevel2": "lingerpotwaterbreathing2", + "cloudpotionbreath2": "lingerpotwaterbreathing2", + "cloudpotionbreathlong": "lingerpotwaterbreathing2", + "cloudpotionbreathextended": "lingerpotwaterbreathing2", + "cloudpotionbreathex": "lingerpotwaterbreathing2", + "cloudpotionbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingcloudpotion2": "lingerpotwaterbreathing2", + "waterbreathingcloudpotionlong": "lingerpotwaterbreathing2", + "waterbreathingcloudpotionextended": "lingerpotwaterbreathing2", + "waterbreathingcloudpotionex": "lingerpotwaterbreathing2", + "waterbreathingcloudpotionlevel2": "lingerpotwaterbreathing2", + "wbcloudpotion2": "lingerpotwaterbreathing2", + "wbcloudpotionlong": "lingerpotwaterbreathing2", + "wbcloudpotionextended": "lingerpotwaterbreathing2", + "wbcloudpotionex": "lingerpotwaterbreathing2", + "wbcloudpotionlevel2": "lingerpotwaterbreathing2", + "waterbreathcloudpotion2": "lingerpotwaterbreathing2", + "waterbreathcloudpotionlong": "lingerpotwaterbreathing2", + "waterbreathcloudpotionextended": "lingerpotwaterbreathing2", + "waterbreathcloudpotionex": "lingerpotwaterbreathing2", + "waterbreathcloudpotionlevel2": "lingerpotwaterbreathing2", + "breathingcloudpotion2": "lingerpotwaterbreathing2", + "breathingcloudpotionlong": "lingerpotwaterbreathing2", + "breathingcloudpotionextended": "lingerpotwaterbreathing2", + "breathingcloudpotionex": "lingerpotwaterbreathing2", + "breathingcloudpotionlevel2": "lingerpotwaterbreathing2", + "breathcloudpotion2": "lingerpotwaterbreathing2", + "breathcloudpotionlong": "lingerpotwaterbreathing2", + "breathcloudpotionextended": "lingerpotwaterbreathing2", + "breathcloudpotionex": "lingerpotwaterbreathing2", + "breathcloudpotionlevel2": "lingerpotwaterbreathing2", + "cloudpotwaterbreathing2": "lingerpotwaterbreathing2", + "cloudpotwaterbreathinglong": "lingerpotwaterbreathing2", + "cloudpotwaterbreathingextended": "lingerpotwaterbreathing2", + "cloudpotwaterbreathingex": "lingerpotwaterbreathing2", + "cloudpotwaterbreathinglevel2": "lingerpotwaterbreathing2", + "cloudpotwb2": "lingerpotwaterbreathing2", + "cloudpotwblong": "lingerpotwaterbreathing2", + "cloudpotwbextended": "lingerpotwaterbreathing2", + "cloudpotwbex": "lingerpotwaterbreathing2", + "cloudpotwblevel2": "lingerpotwaterbreathing2", + "cloudpotwaterbreath2": "lingerpotwaterbreathing2", + "cloudpotwaterbreathlong": "lingerpotwaterbreathing2", + "cloudpotwaterbreathextended": "lingerpotwaterbreathing2", + "cloudpotwaterbreathex": "lingerpotwaterbreathing2", + "cloudpotwaterbreathlevel2": "lingerpotwaterbreathing2", + "cloudpotbreathing2": "lingerpotwaterbreathing2", + "cloudpotbreathinglong": "lingerpotwaterbreathing2", + "cloudpotbreathingextended": "lingerpotwaterbreathing2", + "cloudpotbreathingex": "lingerpotwaterbreathing2", + "cloudpotbreathinglevel2": "lingerpotwaterbreathing2", + "cloudpotbreath2": "lingerpotwaterbreathing2", + "cloudpotbreathlong": "lingerpotwaterbreathing2", + "cloudpotbreathextended": "lingerpotwaterbreathing2", + "cloudpotbreathex": "lingerpotwaterbreathing2", + "cloudpotbreathlevel2": "lingerpotwaterbreathing2", + "waterbreathingcloudpot2": "lingerpotwaterbreathing2", + "waterbreathingcloudpotlong": "lingerpotwaterbreathing2", + "waterbreathingcloudpotextended": "lingerpotwaterbreathing2", + "waterbreathingcloudpotex": "lingerpotwaterbreathing2", + "waterbreathingcloudpotlevel2": "lingerpotwaterbreathing2", + "wbcloudpot2": "lingerpotwaterbreathing2", + "wbcloudpotlong": "lingerpotwaterbreathing2", + "wbcloudpotextended": "lingerpotwaterbreathing2", + "wbcloudpotex": "lingerpotwaterbreathing2", + "wbcloudpotlevel2": "lingerpotwaterbreathing2", + "waterbreathcloudpot2": "lingerpotwaterbreathing2", + "waterbreathcloudpotlong": "lingerpotwaterbreathing2", + "waterbreathcloudpotextended": "lingerpotwaterbreathing2", + "waterbreathcloudpotex": "lingerpotwaterbreathing2", + "waterbreathcloudpotlevel2": "lingerpotwaterbreathing2", + "breathingcloudpot2": "lingerpotwaterbreathing2", + "breathingcloudpotlong": "lingerpotwaterbreathing2", + "breathingcloudpotextended": "lingerpotwaterbreathing2", + "breathingcloudpotex": "lingerpotwaterbreathing2", + "breathingcloudpotlevel2": "lingerpotwaterbreathing2", + "breathcloudpot2": "lingerpotwaterbreathing2", + "breathcloudpotlong": "lingerpotwaterbreathing2", + "breathcloudpotextended": "lingerpotwaterbreathing2", + "breathcloudpotex": "lingerpotwaterbreathing2", + "breathcloudpotlevel2": "lingerpotwaterbreathing2", + "arrowwaterbreathing2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_water_breathing", + "bukkitType": "water_breathing", + "isStrong": false, + "isLong": true + } + }, + "arrowwaterbreathinglong": "arrowwaterbreathing2", + "arrowwaterbreathingextended": "arrowwaterbreathing2", + "arrowwaterbreathingex": "arrowwaterbreathing2", + "arrowwaterbreathinglevel2": "arrowwaterbreathing2", + "arrowwb2": "arrowwaterbreathing2", + "arrowwblong": "arrowwaterbreathing2", + "arrowwbextended": "arrowwaterbreathing2", + "arrowwbex": "arrowwaterbreathing2", + "arrowwblevel2": "arrowwaterbreathing2", + "arrowwaterbreath2": "arrowwaterbreathing2", + "arrowwaterbreathlong": "arrowwaterbreathing2", + "arrowwaterbreathextended": "arrowwaterbreathing2", + "arrowwaterbreathex": "arrowwaterbreathing2", + "arrowwaterbreathlevel2": "arrowwaterbreathing2", + "arrowbreathing2": "arrowwaterbreathing2", + "arrowbreathinglong": "arrowwaterbreathing2", + "arrowbreathingextended": "arrowwaterbreathing2", + "arrowbreathingex": "arrowwaterbreathing2", + "arrowbreathinglevel2": "arrowwaterbreathing2", + "arrowbreath2": "arrowwaterbreathing2", + "arrowbreathlong": "arrowwaterbreathing2", + "arrowbreathextended": "arrowwaterbreathing2", + "arrowbreathex": "arrowwaterbreathing2", + "arrowbreathlevel2": "arrowwaterbreathing2", + "waterbreathingarrow2": "arrowwaterbreathing2", + "waterbreathingarrowlong": "arrowwaterbreathing2", + "waterbreathingarrowextended": "arrowwaterbreathing2", + "waterbreathingarrowex": "arrowwaterbreathing2", + "waterbreathingarrowlevel2": "arrowwaterbreathing2", + "wbarrow2": "arrowwaterbreathing2", + "wbarrowlong": "arrowwaterbreathing2", + "wbarrowextended": "arrowwaterbreathing2", + "wbarrowex": "arrowwaterbreathing2", + "wbarrowlevel2": "arrowwaterbreathing2", + "waterbreatharrow2": "arrowwaterbreathing2", + "waterbreatharrowlong": "arrowwaterbreathing2", + "waterbreatharrowextended": "arrowwaterbreathing2", + "waterbreatharrowex": "arrowwaterbreathing2", + "waterbreatharrowlevel2": "arrowwaterbreathing2", + "breathingarrow2": "arrowwaterbreathing2", + "breathingarrowlong": "arrowwaterbreathing2", + "breathingarrowextended": "arrowwaterbreathing2", + "breathingarrowex": "arrowwaterbreathing2", + "breathingarrowlevel2": "arrowwaterbreathing2", + "breatharrow2": "arrowwaterbreathing2", + "breatharrowlong": "arrowwaterbreathing2", + "breatharrowextended": "arrowwaterbreathing2", + "breatharrowex": "arrowwaterbreathing2", + "breatharrowlevel2": "arrowwaterbreathing2", + "healingpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "healing", + "bukkitType": "healing", + "isStrong": false, + "isLong": false + } + }, + "healpotion": "healingpotion", + "lifepotion": "healingpotion", + "hpotion": "healingpotion", + "healingpot": "healingpotion", + "healpot": "healingpotion", + "lifepot": "healingpotion", + "hpot": "healingpotion", + "potionofhealing": "healingpotion", + "potionofheal": "healingpotion", + "potionoflife": "healingpotion", + "potionofh": "healingpotion", + "potofhealing": "healingpotion", + "potofheal": "healingpotion", + "potoflife": "healingpotion", + "potofh": "healingpotion", + "splashhealingpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "healing", + "bukkitType": "healing", + "isStrong": false, + "isLong": false + } + }, + "splashhealpotion": "splashhealingpotion", + "splashlifepotion": "splashhealingpotion", + "splashhpotion": "splashhealingpotion", + "splhealingpotion": "splashhealingpotion", + "splhealpotion": "splashhealingpotion", + "spllifepotion": "splashhealingpotion", + "splhpotion": "splashhealingpotion", + "healingsplashpotion": "splashhealingpotion", + "healsplashpotion": "splashhealingpotion", + "lifesplashpotion": "splashhealingpotion", + "hsplashpotion": "splashhealingpotion", + "splashhealingpot": "splashhealingpotion", + "splashhealpot": "splashhealingpotion", + "splashlifepot": "splashhealingpotion", + "splashhpot": "splashhealingpotion", + "splhealingpot": "splashhealingpotion", + "splhealpot": "splashhealingpotion", + "spllifepot": "splashhealingpotion", + "splhpot": "splashhealingpotion", + "healingsplashpot": "splashhealingpotion", + "healsplashpot": "splashhealingpotion", + "lifesplashpot": "splashhealingpotion", + "hsplashpot": "splashhealingpotion", + "lingerpothealing": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "healing", + "bukkitType": "healing", + "isStrong": false, + "isLong": false + } + }, + "lingerpotheal": "lingerpothealing", + "lingerpotlife": "lingerpothealing", + "lingerpoth": "lingerpothealing", + "healinglingerpot": "lingerpothealing", + "heallingerpot": "lingerpothealing", + "lifelingerpot": "lingerpothealing", + "hlingerpot": "lingerpothealing", + "aoepotionhealing": "lingerpothealing", + "aoepotionheal": "lingerpothealing", + "aoepotionlife": "lingerpothealing", + "aoepotionh": "lingerpothealing", + "healingaoepoiont": "lingerpothealing", + "healaoepoiont": "lingerpothealing", + "lifeaoepoiont": "lingerpothealing", + "haoepoiont": "lingerpothealing", + "aoepothealing": "lingerpothealing", + "aoepotheal": "lingerpothealing", + "aoepotlife": "lingerpothealing", + "aoepoth": "lingerpothealing", + "healingaoepot": "lingerpothealing", + "healaoepot": "lingerpothealing", + "lifeaoepot": "lingerpothealing", + "haoepot": "lingerpothealing", + "areapotionhealing": "lingerpothealing", + "areapotionheal": "lingerpothealing", + "areapotionlife": "lingerpothealing", + "areapotionh": "lingerpothealing", + "healingareapotion": "lingerpothealing", + "healareapotion": "lingerpothealing", + "lifeareapotion": "lingerpothealing", + "hareapotion": "lingerpothealing", + "areapothealing": "lingerpothealing", + "areapotheal": "lingerpothealing", + "areapotlife": "lingerpothealing", + "areapoth": "lingerpothealing", + "healingareapot": "lingerpothealing", + "healareapot": "lingerpothealing", + "lifeareapot": "lingerpothealing", + "hareapot": "lingerpothealing", + "cloudpotionhealing": "lingerpothealing", + "cloudpotionheal": "lingerpothealing", + "cloudpotionlife": "lingerpothealing", + "cloudpotionh": "lingerpothealing", + "healingcloudpotion": "lingerpothealing", + "healcloudpotion": "lingerpothealing", + "lifecloudpotion": "lingerpothealing", + "hcloudpotion": "lingerpothealing", + "cloudpothealing": "lingerpothealing", + "cloudpotheal": "lingerpothealing", + "cloudpotlife": "lingerpothealing", + "cloudpoth": "lingerpothealing", + "healingcloudpot": "lingerpothealing", + "healcloudpot": "lingerpothealing", + "lifecloudpot": "lingerpothealing", + "hcloudpot": "lingerpothealing", + "arrowhealing": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "healing", + "bukkitType": "healing", + "isStrong": false, + "isLong": false + } + }, + "arrowheal": "arrowhealing", + "arrowlife": "arrowhealing", + "arrowh": "arrowhealing", + "healingarrow": "arrowhealing", + "healarrow": "arrowhealing", + "lifearrow": "arrowhealing", + "harrow": "arrowhealing", + "healingiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_healing", + "bukkitType": "healing", + "isStrong": true, + "isLong": false + } + }, + "healingstrongpotion": "healingiipotion", + "healingleveliipotion": "healingiipotion", + "healiipotion": "healingiipotion", + "healstrongpotion": "healingiipotion", + "healleveliipotion": "healingiipotion", + "lifeiipotion": "healingiipotion", + "lifestrongpotion": "healingiipotion", + "lifeleveliipotion": "healingiipotion", + "hiipotion": "healingiipotion", + "hstrongpotion": "healingiipotion", + "hleveliipotion": "healingiipotion", + "healingiipot": "healingiipotion", + "healingstrongpot": "healingiipotion", + "healingleveliipot": "healingiipotion", + "healiipot": "healingiipotion", + "healstrongpot": "healingiipotion", + "healleveliipot": "healingiipotion", + "lifeiipot": "healingiipotion", + "lifestrongpot": "healingiipotion", + "lifeleveliipot": "healingiipotion", + "hiipot": "healingiipotion", + "hstrongpot": "healingiipotion", + "hleveliipot": "healingiipotion", + "potionofhealingii": "healingiipotion", + "potionofhealingstrong": "healingiipotion", + "potionofhealinglevelii": "healingiipotion", + "potionofhealii": "healingiipotion", + "potionofhealstrong": "healingiipotion", + "potionofheallevelii": "healingiipotion", + "potionoflifeii": "healingiipotion", + "potionoflifestrong": "healingiipotion", + "potionoflifelevelii": "healingiipotion", + "potionofhii": "healingiipotion", + "potionofhstrong": "healingiipotion", + "potionofhlevelii": "healingiipotion", + "potofhealingii": "healingiipotion", + "potofhealingstrong": "healingiipotion", + "potofhealinglevelii": "healingiipotion", + "potofhealii": "healingiipotion", + "potofhealstrong": "healingiipotion", + "potofheallevelii": "healingiipotion", + "potoflifeii": "healingiipotion", + "potoflifestrong": "healingiipotion", + "potoflifelevelii": "healingiipotion", + "potofhii": "healingiipotion", + "potofhstrong": "healingiipotion", + "potofhlevelii": "healingiipotion", + "splashhealingiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_healing", + "bukkitType": "healing", + "isStrong": true, + "isLong": false + } + }, + "splashhealingstrongpotion": "splashhealingiipotion", + "splashhealingleveliipotion": "splashhealingiipotion", + "splashhealiipotion": "splashhealingiipotion", + "splashhealstrongpotion": "splashhealingiipotion", + "splashhealleveliipotion": "splashhealingiipotion", + "splashlifeiipotion": "splashhealingiipotion", + "splashlifestrongpotion": "splashhealingiipotion", + "splashlifeleveliipotion": "splashhealingiipotion", + "splashhiipotion": "splashhealingiipotion", + "splashhstrongpotion": "splashhealingiipotion", + "splashhleveliipotion": "splashhealingiipotion", + "splhealingiipotion": "splashhealingiipotion", + "splhealingstrongpotion": "splashhealingiipotion", + "splhealingleveliipotion": "splashhealingiipotion", + "splhealiipotion": "splashhealingiipotion", + "splhealstrongpotion": "splashhealingiipotion", + "splhealleveliipotion": "splashhealingiipotion", + "spllifeiipotion": "splashhealingiipotion", + "spllifestrongpotion": "splashhealingiipotion", + "spllifeleveliipotion": "splashhealingiipotion", + "splhiipotion": "splashhealingiipotion", + "splhstrongpotion": "splashhealingiipotion", + "splhleveliipotion": "splashhealingiipotion", + "healingiisplashpotion": "splashhealingiipotion", + "healingstrongsplashpotion": "splashhealingiipotion", + "healingleveliisplashpotion": "splashhealingiipotion", + "healiisplashpotion": "splashhealingiipotion", + "healstrongsplashpotion": "splashhealingiipotion", + "healleveliisplashpotion": "splashhealingiipotion", + "lifeiisplashpotion": "splashhealingiipotion", + "lifestrongsplashpotion": "splashhealingiipotion", + "lifeleveliisplashpotion": "splashhealingiipotion", + "hiisplashpotion": "splashhealingiipotion", + "hstrongsplashpotion": "splashhealingiipotion", + "hleveliisplashpotion": "splashhealingiipotion", + "splashhealingiipot": "splashhealingiipotion", + "splashhealingstrongpot": "splashhealingiipotion", + "splashhealingleveliipot": "splashhealingiipotion", + "splashhealiipot": "splashhealingiipotion", + "splashhealstrongpot": "splashhealingiipotion", + "splashhealleveliipot": "splashhealingiipotion", + "splashlifeiipot": "splashhealingiipotion", + "splashlifestrongpot": "splashhealingiipotion", + "splashlifeleveliipot": "splashhealingiipotion", + "splashhiipot": "splashhealingiipotion", + "splashhstrongpot": "splashhealingiipotion", + "splashhleveliipot": "splashhealingiipotion", + "splhealingiipot": "splashhealingiipotion", + "splhealingstrongpot": "splashhealingiipotion", + "splhealingleveliipot": "splashhealingiipotion", + "splhealiipot": "splashhealingiipotion", + "splhealstrongpot": "splashhealingiipotion", + "splhealleveliipot": "splashhealingiipotion", + "spllifeiipot": "splashhealingiipotion", + "spllifestrongpot": "splashhealingiipotion", + "spllifeleveliipot": "splashhealingiipotion", + "splhiipot": "splashhealingiipotion", + "splhstrongpot": "splashhealingiipotion", + "splhleveliipot": "splashhealingiipotion", + "healingiisplashpot": "splashhealingiipotion", + "healingstrongsplashpot": "splashhealingiipotion", + "healingleveliisplashpot": "splashhealingiipotion", + "healiisplashpot": "splashhealingiipotion", + "healstrongsplashpot": "splashhealingiipotion", + "healleveliisplashpot": "splashhealingiipotion", + "lifeiisplashpot": "splashhealingiipotion", + "lifestrongsplashpot": "splashhealingiipotion", + "lifeleveliisplashpot": "splashhealingiipotion", + "hiisplashpot": "splashhealingiipotion", + "hstrongsplashpot": "splashhealingiipotion", + "hleveliisplashpot": "splashhealingiipotion", + "lingerpothealingii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_healing", + "bukkitType": "healing", + "isStrong": true, + "isLong": false + } + }, + "lingerpothealingstrong": "lingerpothealingii", + "lingerpothealinglevelii": "lingerpothealingii", + "lingerpothealii": "lingerpothealingii", + "lingerpothealstrong": "lingerpothealingii", + "lingerpotheallevelii": "lingerpothealingii", + "lingerpotlifeii": "lingerpothealingii", + "lingerpotlifestrong": "lingerpothealingii", + "lingerpotlifelevelii": "lingerpothealingii", + "lingerpothii": "lingerpothealingii", + "lingerpothstrong": "lingerpothealingii", + "lingerpothlevelii": "lingerpothealingii", + "healinglingerpotii": "lingerpothealingii", + "healinglingerpotstrong": "lingerpothealingii", + "healinglingerpotlevelii": "lingerpothealingii", + "heallingerpotii": "lingerpothealingii", + "heallingerpotstrong": "lingerpothealingii", + "heallingerpotlevelii": "lingerpothealingii", + "lifelingerpotii": "lingerpothealingii", + "lifelingerpotstrong": "lingerpothealingii", + "lifelingerpotlevelii": "lingerpothealingii", + "hlingerpotii": "lingerpothealingii", + "hlingerpotstrong": "lingerpothealingii", + "hlingerpotlevelii": "lingerpothealingii", + "aoepotionhealingii": "lingerpothealingii", + "aoepotionhealingstrong": "lingerpothealingii", + "aoepotionhealinglevelii": "lingerpothealingii", + "aoepotionhealii": "lingerpothealingii", + "aoepotionhealstrong": "lingerpothealingii", + "aoepotionheallevelii": "lingerpothealingii", + "aoepotionlifeii": "lingerpothealingii", + "aoepotionlifestrong": "lingerpothealingii", + "aoepotionlifelevelii": "lingerpothealingii", + "aoepotionhii": "lingerpothealingii", + "aoepotionhstrong": "lingerpothealingii", + "aoepotionhlevelii": "lingerpothealingii", + "healingaoepoiontii": "lingerpothealingii", + "healingaoepoiontstrong": "lingerpothealingii", + "healingaoepoiontlevelii": "lingerpothealingii", + "healaoepoiontii": "lingerpothealingii", + "healaoepoiontstrong": "lingerpothealingii", + "healaoepoiontlevelii": "lingerpothealingii", + "lifeaoepoiontii": "lingerpothealingii", + "lifeaoepoiontstrong": "lingerpothealingii", + "lifeaoepoiontlevelii": "lingerpothealingii", + "haoepoiontii": "lingerpothealingii", + "haoepoiontstrong": "lingerpothealingii", + "haoepoiontlevelii": "lingerpothealingii", + "aoepothealingii": "lingerpothealingii", + "aoepothealingstrong": "lingerpothealingii", + "aoepothealinglevelii": "lingerpothealingii", + "aoepothealii": "lingerpothealingii", + "aoepothealstrong": "lingerpothealingii", + "aoepotheallevelii": "lingerpothealingii", + "aoepotlifeii": "lingerpothealingii", + "aoepotlifestrong": "lingerpothealingii", + "aoepotlifelevelii": "lingerpothealingii", + "aoepothii": "lingerpothealingii", + "aoepothstrong": "lingerpothealingii", + "aoepothlevelii": "lingerpothealingii", + "healingaoepotii": "lingerpothealingii", + "healingaoepotstrong": "lingerpothealingii", + "healingaoepotlevelii": "lingerpothealingii", + "healaoepotii": "lingerpothealingii", + "healaoepotstrong": "lingerpothealingii", + "healaoepotlevelii": "lingerpothealingii", + "lifeaoepotii": "lingerpothealingii", + "lifeaoepotstrong": "lingerpothealingii", + "lifeaoepotlevelii": "lingerpothealingii", + "haoepotii": "lingerpothealingii", + "haoepotstrong": "lingerpothealingii", + "haoepotlevelii": "lingerpothealingii", + "areapotionhealingii": "lingerpothealingii", + "areapotionhealingstrong": "lingerpothealingii", + "areapotionhealinglevelii": "lingerpothealingii", + "areapotionhealii": "lingerpothealingii", + "areapotionhealstrong": "lingerpothealingii", + "areapotionheallevelii": "lingerpothealingii", + "areapotionlifeii": "lingerpothealingii", + "areapotionlifestrong": "lingerpothealingii", + "areapotionlifelevelii": "lingerpothealingii", + "areapotionhii": "lingerpothealingii", + "areapotionhstrong": "lingerpothealingii", + "areapotionhlevelii": "lingerpothealingii", + "healingareapotionii": "lingerpothealingii", + "healingareapotionstrong": "lingerpothealingii", + "healingareapotionlevelii": "lingerpothealingii", + "healareapotionii": "lingerpothealingii", + "healareapotionstrong": "lingerpothealingii", + "healareapotionlevelii": "lingerpothealingii", + "lifeareapotionii": "lingerpothealingii", + "lifeareapotionstrong": "lingerpothealingii", + "lifeareapotionlevelii": "lingerpothealingii", + "hareapotionii": "lingerpothealingii", + "hareapotionstrong": "lingerpothealingii", + "hareapotionlevelii": "lingerpothealingii", + "areapothealingii": "lingerpothealingii", + "areapothealingstrong": "lingerpothealingii", + "areapothealinglevelii": "lingerpothealingii", + "areapothealii": "lingerpothealingii", + "areapothealstrong": "lingerpothealingii", + "areapotheallevelii": "lingerpothealingii", + "areapotlifeii": "lingerpothealingii", + "areapotlifestrong": "lingerpothealingii", + "areapotlifelevelii": "lingerpothealingii", + "areapothii": "lingerpothealingii", + "areapothstrong": "lingerpothealingii", + "areapothlevelii": "lingerpothealingii", + "healingareapotii": "lingerpothealingii", + "healingareapotstrong": "lingerpothealingii", + "healingareapotlevelii": "lingerpothealingii", + "healareapotii": "lingerpothealingii", + "healareapotstrong": "lingerpothealingii", + "healareapotlevelii": "lingerpothealingii", + "lifeareapotii": "lingerpothealingii", + "lifeareapotstrong": "lingerpothealingii", + "lifeareapotlevelii": "lingerpothealingii", + "hareapotii": "lingerpothealingii", + "hareapotstrong": "lingerpothealingii", + "hareapotlevelii": "lingerpothealingii", + "cloudpotionhealingii": "lingerpothealingii", + "cloudpotionhealingstrong": "lingerpothealingii", + "cloudpotionhealinglevelii": "lingerpothealingii", + "cloudpotionhealii": "lingerpothealingii", + "cloudpotionhealstrong": "lingerpothealingii", + "cloudpotionheallevelii": "lingerpothealingii", + "cloudpotionlifeii": "lingerpothealingii", + "cloudpotionlifestrong": "lingerpothealingii", + "cloudpotionlifelevelii": "lingerpothealingii", + "cloudpotionhii": "lingerpothealingii", + "cloudpotionhstrong": "lingerpothealingii", + "cloudpotionhlevelii": "lingerpothealingii", + "healingcloudpotionii": "lingerpothealingii", + "healingcloudpotionstrong": "lingerpothealingii", + "healingcloudpotionlevelii": "lingerpothealingii", + "healcloudpotionii": "lingerpothealingii", + "healcloudpotionstrong": "lingerpothealingii", + "healcloudpotionlevelii": "lingerpothealingii", + "lifecloudpotionii": "lingerpothealingii", + "lifecloudpotionstrong": "lingerpothealingii", + "lifecloudpotionlevelii": "lingerpothealingii", + "hcloudpotionii": "lingerpothealingii", + "hcloudpotionstrong": "lingerpothealingii", + "hcloudpotionlevelii": "lingerpothealingii", + "cloudpothealingii": "lingerpothealingii", + "cloudpothealingstrong": "lingerpothealingii", + "cloudpothealinglevelii": "lingerpothealingii", + "cloudpothealii": "lingerpothealingii", + "cloudpothealstrong": "lingerpothealingii", + "cloudpotheallevelii": "lingerpothealingii", + "cloudpotlifeii": "lingerpothealingii", + "cloudpotlifestrong": "lingerpothealingii", + "cloudpotlifelevelii": "lingerpothealingii", + "cloudpothii": "lingerpothealingii", + "cloudpothstrong": "lingerpothealingii", + "cloudpothlevelii": "lingerpothealingii", + "healingcloudpotii": "lingerpothealingii", + "healingcloudpotstrong": "lingerpothealingii", + "healingcloudpotlevelii": "lingerpothealingii", + "healcloudpotii": "lingerpothealingii", + "healcloudpotstrong": "lingerpothealingii", + "healcloudpotlevelii": "lingerpothealingii", + "lifecloudpotii": "lingerpothealingii", + "lifecloudpotstrong": "lingerpothealingii", + "lifecloudpotlevelii": "lingerpothealingii", + "hcloudpotii": "lingerpothealingii", + "hcloudpotstrong": "lingerpothealingii", + "hcloudpotlevelii": "lingerpothealingii", + "arrowhealingii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_healing", + "bukkitType": "healing", + "isStrong": true, + "isLong": false + } + }, + "arrowhealingstrong": "arrowhealingii", + "arrowhealinglevelii": "arrowhealingii", + "arrowhealii": "arrowhealingii", + "arrowhealstrong": "arrowhealingii", + "arrowheallevelii": "arrowhealingii", + "arrowlifeii": "arrowhealingii", + "arrowlifestrong": "arrowhealingii", + "arrowlifelevelii": "arrowhealingii", + "arrowhii": "arrowhealingii", + "arrowhstrong": "arrowhealingii", + "arrowhlevelii": "arrowhealingii", + "healingarrowii": "arrowhealingii", + "healingarrowstrong": "arrowhealingii", + "healingarrowlevelii": "arrowhealingii", + "healarrowii": "arrowhealingii", + "healarrowstrong": "arrowhealingii", + "healarrowlevelii": "arrowhealingii", + "lifearrowii": "arrowhealingii", + "lifearrowstrong": "arrowhealingii", + "lifearrowlevelii": "arrowhealingii", + "harrowii": "arrowhealingii", + "harrowstrong": "arrowhealingii", + "harrowlevelii": "arrowhealingii", + "harmingpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "harming", + "bukkitType": "harming", + "isStrong": false, + "isLong": false + } + }, + "damagepotion": "harmingpotion", + "dmgpotion": "harmingpotion", + "dpotion": "harmingpotion", + "harmingpot": "harmingpotion", + "damagepot": "harmingpotion", + "dmgpot": "harmingpotion", + "dpot": "harmingpotion", + "potionofharming": "harmingpotion", + "potionofdamage": "harmingpotion", + "potionofdmg": "harmingpotion", + "potionofd": "harmingpotion", + "potofharming": "harmingpotion", + "potofdamage": "harmingpotion", + "potofdmg": "harmingpotion", + "potofd": "harmingpotion", + "splashharmingpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "harming", + "bukkitType": "harming", + "isStrong": false, + "isLong": false + } + }, + "splashdamagepotion": "splashharmingpotion", + "splashdmgpotion": "splashharmingpotion", + "splashdpotion": "splashharmingpotion", + "splharmingpotion": "splashharmingpotion", + "spldamagepotion": "splashharmingpotion", + "spldmgpotion": "splashharmingpotion", + "spldpotion": "splashharmingpotion", + "harmingsplashpotion": "splashharmingpotion", + "damagesplashpotion": "splashharmingpotion", + "dmgsplashpotion": "splashharmingpotion", + "dsplashpotion": "splashharmingpotion", + "splashharmingpot": "splashharmingpotion", + "splashdamagepot": "splashharmingpotion", + "splashdmgpot": "splashharmingpotion", + "splashdpot": "splashharmingpotion", + "splharmingpot": "splashharmingpotion", + "spldamagepot": "splashharmingpotion", + "spldmgpot": "splashharmingpotion", + "spldpot": "splashharmingpotion", + "harmingsplashpot": "splashharmingpotion", + "damagesplashpot": "splashharmingpotion", + "dmgsplashpot": "splashharmingpotion", + "dsplashpot": "splashharmingpotion", + "lingerpotharming": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "harming", + "bukkitType": "harming", + "isStrong": false, + "isLong": false + } + }, + "lingerpotdamage": "lingerpotharming", + "lingerpotdmg": "lingerpotharming", + "lingerpotd": "lingerpotharming", + "harminglingerpot": "lingerpotharming", + "damagelingerpot": "lingerpotharming", + "dmglingerpot": "lingerpotharming", + "dlingerpot": "lingerpotharming", + "aoepotionharming": "lingerpotharming", + "aoepotiondamage": "lingerpotharming", + "aoepotiondmg": "lingerpotharming", + "aoepotiond": "lingerpotharming", + "harmingaoepoiont": "lingerpotharming", + "damageaoepoiont": "lingerpotharming", + "dmgaoepoiont": "lingerpotharming", + "daoepoiont": "lingerpotharming", + "aoepotharming": "lingerpotharming", + "aoepotdamage": "lingerpotharming", + "aoepotdmg": "lingerpotharming", + "aoepotd": "lingerpotharming", + "harmingaoepot": "lingerpotharming", + "damageaoepot": "lingerpotharming", + "dmgaoepot": "lingerpotharming", + "daoepot": "lingerpotharming", + "areapotionharming": "lingerpotharming", + "areapotiondamage": "lingerpotharming", + "areapotiondmg": "lingerpotharming", + "areapotiond": "lingerpotharming", + "harmingareapotion": "lingerpotharming", + "damageareapotion": "lingerpotharming", + "dmgareapotion": "lingerpotharming", + "dareapotion": "lingerpotharming", + "areapotharming": "lingerpotharming", + "areapotdamage": "lingerpotharming", + "areapotdmg": "lingerpotharming", + "areapotd": "lingerpotharming", + "harmingareapot": "lingerpotharming", + "damageareapot": "lingerpotharming", + "dmgareapot": "lingerpotharming", + "dareapot": "lingerpotharming", + "cloudpotionharming": "lingerpotharming", + "cloudpotiondamage": "lingerpotharming", + "cloudpotiondmg": "lingerpotharming", + "cloudpotiond": "lingerpotharming", + "harmingcloudpotion": "lingerpotharming", + "damagecloudpotion": "lingerpotharming", + "dmgcloudpotion": "lingerpotharming", + "dcloudpotion": "lingerpotharming", + "cloudpotharming": "lingerpotharming", + "cloudpotdamage": "lingerpotharming", + "cloudpotdmg": "lingerpotharming", + "cloudpotd": "lingerpotharming", + "harmingcloudpot": "lingerpotharming", + "damagecloudpot": "lingerpotharming", + "dmgcloudpot": "lingerpotharming", + "dcloudpot": "lingerpotharming", + "arrowharming": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "harming", + "bukkitType": "harming", + "isStrong": false, + "isLong": false + } + }, + "arrowdamage": "arrowharming", + "arrowdmg": "arrowharming", + "arrowd": "arrowharming", + "harmingarrow": "arrowharming", + "damagearrow": "arrowharming", + "dmgarrow": "arrowharming", + "darrow": "arrowharming", + "harmingiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_harming", + "bukkitType": "harming", + "isStrong": true, + "isLong": false + } + }, + "harmingstrongpotion": "harmingiipotion", + "harmingleveliipotion": "harmingiipotion", + "damageiipotion": "harmingiipotion", + "damagestrongpotion": "harmingiipotion", + "damageleveliipotion": "harmingiipotion", + "dmgiipotion": "harmingiipotion", + "dmgstrongpotion": "harmingiipotion", + "dmgleveliipotion": "harmingiipotion", + "diipotion": "harmingiipotion", + "dstrongpotion": "harmingiipotion", + "dleveliipotion": "harmingiipotion", + "harmingiipot": "harmingiipotion", + "harmingstrongpot": "harmingiipotion", + "harmingleveliipot": "harmingiipotion", + "damageiipot": "harmingiipotion", + "damagestrongpot": "harmingiipotion", + "damageleveliipot": "harmingiipotion", + "dmgiipot": "harmingiipotion", + "dmgstrongpot": "harmingiipotion", + "dmgleveliipot": "harmingiipotion", + "diipot": "harmingiipotion", + "dstrongpot": "harmingiipotion", + "dleveliipot": "harmingiipotion", + "potionofharmingii": "harmingiipotion", + "potionofharmingstrong": "harmingiipotion", + "potionofharminglevelii": "harmingiipotion", + "potionofdamageii": "harmingiipotion", + "potionofdamagestrong": "harmingiipotion", + "potionofdamagelevelii": "harmingiipotion", + "potionofdmgii": "harmingiipotion", + "potionofdmgstrong": "harmingiipotion", + "potionofdmglevelii": "harmingiipotion", + "potionofdii": "harmingiipotion", + "potionofdstrong": "harmingiipotion", + "potionofdlevelii": "harmingiipotion", + "potofharmingii": "harmingiipotion", + "potofharmingstrong": "harmingiipotion", + "potofharminglevelii": "harmingiipotion", + "potofdamageii": "harmingiipotion", + "potofdamagestrong": "harmingiipotion", + "potofdamagelevelii": "harmingiipotion", + "potofdmgii": "harmingiipotion", + "potofdmgstrong": "harmingiipotion", + "potofdmglevelii": "harmingiipotion", + "potofdii": "harmingiipotion", + "potofdstrong": "harmingiipotion", + "potofdlevelii": "harmingiipotion", + "splashharmingiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_harming", + "bukkitType": "harming", + "isStrong": true, + "isLong": false + } + }, + "splashharmingstrongpotion": "splashharmingiipotion", + "splashharmingleveliipotion": "splashharmingiipotion", + "splashdamageiipotion": "splashharmingiipotion", + "splashdamagestrongpotion": "splashharmingiipotion", + "splashdamageleveliipotion": "splashharmingiipotion", + "splashdmgiipotion": "splashharmingiipotion", + "splashdmgstrongpotion": "splashharmingiipotion", + "splashdmgleveliipotion": "splashharmingiipotion", + "splashdiipotion": "splashharmingiipotion", + "splashdstrongpotion": "splashharmingiipotion", + "splashdleveliipotion": "splashharmingiipotion", + "splharmingiipotion": "splashharmingiipotion", + "splharmingstrongpotion": "splashharmingiipotion", + "splharmingleveliipotion": "splashharmingiipotion", + "spldamageiipotion": "splashharmingiipotion", + "spldamagestrongpotion": "splashharmingiipotion", + "spldamageleveliipotion": "splashharmingiipotion", + "spldmgiipotion": "splashharmingiipotion", + "spldmgstrongpotion": "splashharmingiipotion", + "spldmgleveliipotion": "splashharmingiipotion", + "spldiipotion": "splashharmingiipotion", + "spldstrongpotion": "splashharmingiipotion", + "spldleveliipotion": "splashharmingiipotion", + "harmingiisplashpotion": "splashharmingiipotion", + "harmingstrongsplashpotion": "splashharmingiipotion", + "harmingleveliisplashpotion": "splashharmingiipotion", + "damageiisplashpotion": "splashharmingiipotion", + "damagestrongsplashpotion": "splashharmingiipotion", + "damageleveliisplashpotion": "splashharmingiipotion", + "dmgiisplashpotion": "splashharmingiipotion", + "dmgstrongsplashpotion": "splashharmingiipotion", + "dmgleveliisplashpotion": "splashharmingiipotion", + "diisplashpotion": "splashharmingiipotion", + "dstrongsplashpotion": "splashharmingiipotion", + "dleveliisplashpotion": "splashharmingiipotion", + "splashharmingiipot": "splashharmingiipotion", + "splashharmingstrongpot": "splashharmingiipotion", + "splashharmingleveliipot": "splashharmingiipotion", + "splashdamageiipot": "splashharmingiipotion", + "splashdamagestrongpot": "splashharmingiipotion", + "splashdamageleveliipot": "splashharmingiipotion", + "splashdmgiipot": "splashharmingiipotion", + "splashdmgstrongpot": "splashharmingiipotion", + "splashdmgleveliipot": "splashharmingiipotion", + "splashdiipot": "splashharmingiipotion", + "splashdstrongpot": "splashharmingiipotion", + "splashdleveliipot": "splashharmingiipotion", + "splharmingiipot": "splashharmingiipotion", + "splharmingstrongpot": "splashharmingiipotion", + "splharmingleveliipot": "splashharmingiipotion", + "spldamageiipot": "splashharmingiipotion", + "spldamagestrongpot": "splashharmingiipotion", + "spldamageleveliipot": "splashharmingiipotion", + "spldmgiipot": "splashharmingiipotion", + "spldmgstrongpot": "splashharmingiipotion", + "spldmgleveliipot": "splashharmingiipotion", + "spldiipot": "splashharmingiipotion", + "spldstrongpot": "splashharmingiipotion", + "spldleveliipot": "splashharmingiipotion", + "harmingiisplashpot": "splashharmingiipotion", + "harmingstrongsplashpot": "splashharmingiipotion", + "harmingleveliisplashpot": "splashharmingiipotion", + "damageiisplashpot": "splashharmingiipotion", + "damagestrongsplashpot": "splashharmingiipotion", + "damageleveliisplashpot": "splashharmingiipotion", + "dmgiisplashpot": "splashharmingiipotion", + "dmgstrongsplashpot": "splashharmingiipotion", + "dmgleveliisplashpot": "splashharmingiipotion", + "diisplashpot": "splashharmingiipotion", + "dstrongsplashpot": "splashharmingiipotion", + "dleveliisplashpot": "splashharmingiipotion", + "lingerpotharmingii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_harming", + "bukkitType": "harming", + "isStrong": true, + "isLong": false + } + }, + "lingerpotharmingstrong": "lingerpotharmingii", + "lingerpotharminglevelii": "lingerpotharmingii", + "lingerpotdamageii": "lingerpotharmingii", + "lingerpotdamagestrong": "lingerpotharmingii", + "lingerpotdamagelevelii": "lingerpotharmingii", + "lingerpotdmgii": "lingerpotharmingii", + "lingerpotdmgstrong": "lingerpotharmingii", + "lingerpotdmglevelii": "lingerpotharmingii", + "lingerpotdii": "lingerpotharmingii", + "lingerpotdstrong": "lingerpotharmingii", + "lingerpotdlevelii": "lingerpotharmingii", + "harminglingerpotii": "lingerpotharmingii", + "harminglingerpotstrong": "lingerpotharmingii", + "harminglingerpotlevelii": "lingerpotharmingii", + "damagelingerpotii": "lingerpotharmingii", + "damagelingerpotstrong": "lingerpotharmingii", + "damagelingerpotlevelii": "lingerpotharmingii", + "dmglingerpotii": "lingerpotharmingii", + "dmglingerpotstrong": "lingerpotharmingii", + "dmglingerpotlevelii": "lingerpotharmingii", + "dlingerpotii": "lingerpotharmingii", + "dlingerpotstrong": "lingerpotharmingii", + "dlingerpotlevelii": "lingerpotharmingii", + "aoepotionharmingii": "lingerpotharmingii", + "aoepotionharmingstrong": "lingerpotharmingii", + "aoepotionharminglevelii": "lingerpotharmingii", + "aoepotiondamageii": "lingerpotharmingii", + "aoepotiondamagestrong": "lingerpotharmingii", + "aoepotiondamagelevelii": "lingerpotharmingii", + "aoepotiondmgii": "lingerpotharmingii", + "aoepotiondmgstrong": "lingerpotharmingii", + "aoepotiondmglevelii": "lingerpotharmingii", + "aoepotiondii": "lingerpotharmingii", + "aoepotiondstrong": "lingerpotharmingii", + "aoepotiondlevelii": "lingerpotharmingii", + "harmingaoepoiontii": "lingerpotharmingii", + "harmingaoepoiontstrong": "lingerpotharmingii", + "harmingaoepoiontlevelii": "lingerpotharmingii", + "damageaoepoiontii": "lingerpotharmingii", + "damageaoepoiontstrong": "lingerpotharmingii", + "damageaoepoiontlevelii": "lingerpotharmingii", + "dmgaoepoiontii": "lingerpotharmingii", + "dmgaoepoiontstrong": "lingerpotharmingii", + "dmgaoepoiontlevelii": "lingerpotharmingii", + "daoepoiontii": "lingerpotharmingii", + "daoepoiontstrong": "lingerpotharmingii", + "daoepoiontlevelii": "lingerpotharmingii", + "aoepotharmingii": "lingerpotharmingii", + "aoepotharmingstrong": "lingerpotharmingii", + "aoepotharminglevelii": "lingerpotharmingii", + "aoepotdamageii": "lingerpotharmingii", + "aoepotdamagestrong": "lingerpotharmingii", + "aoepotdamagelevelii": "lingerpotharmingii", + "aoepotdmgii": "lingerpotharmingii", + "aoepotdmgstrong": "lingerpotharmingii", + "aoepotdmglevelii": "lingerpotharmingii", + "aoepotdii": "lingerpotharmingii", + "aoepotdstrong": "lingerpotharmingii", + "aoepotdlevelii": "lingerpotharmingii", + "harmingaoepotii": "lingerpotharmingii", + "harmingaoepotstrong": "lingerpotharmingii", + "harmingaoepotlevelii": "lingerpotharmingii", + "damageaoepotii": "lingerpotharmingii", + "damageaoepotstrong": "lingerpotharmingii", + "damageaoepotlevelii": "lingerpotharmingii", + "dmgaoepotii": "lingerpotharmingii", + "dmgaoepotstrong": "lingerpotharmingii", + "dmgaoepotlevelii": "lingerpotharmingii", + "daoepotii": "lingerpotharmingii", + "daoepotstrong": "lingerpotharmingii", + "daoepotlevelii": "lingerpotharmingii", + "areapotionharmingii": "lingerpotharmingii", + "areapotionharmingstrong": "lingerpotharmingii", + "areapotionharminglevelii": "lingerpotharmingii", + "areapotiondamageii": "lingerpotharmingii", + "areapotiondamagestrong": "lingerpotharmingii", + "areapotiondamagelevelii": "lingerpotharmingii", + "areapotiondmgii": "lingerpotharmingii", + "areapotiondmgstrong": "lingerpotharmingii", + "areapotiondmglevelii": "lingerpotharmingii", + "areapotiondii": "lingerpotharmingii", + "areapotiondstrong": "lingerpotharmingii", + "areapotiondlevelii": "lingerpotharmingii", + "harmingareapotionii": "lingerpotharmingii", + "harmingareapotionstrong": "lingerpotharmingii", + "harmingareapotionlevelii": "lingerpotharmingii", + "damageareapotionii": "lingerpotharmingii", + "damageareapotionstrong": "lingerpotharmingii", + "damageareapotionlevelii": "lingerpotharmingii", + "dmgareapotionii": "lingerpotharmingii", + "dmgareapotionstrong": "lingerpotharmingii", + "dmgareapotionlevelii": "lingerpotharmingii", + "dareapotionii": "lingerpotharmingii", + "dareapotionstrong": "lingerpotharmingii", + "dareapotionlevelii": "lingerpotharmingii", + "areapotharmingii": "lingerpotharmingii", + "areapotharmingstrong": "lingerpotharmingii", + "areapotharminglevelii": "lingerpotharmingii", + "areapotdamageii": "lingerpotharmingii", + "areapotdamagestrong": "lingerpotharmingii", + "areapotdamagelevelii": "lingerpotharmingii", + "areapotdmgii": "lingerpotharmingii", + "areapotdmgstrong": "lingerpotharmingii", + "areapotdmglevelii": "lingerpotharmingii", + "areapotdii": "lingerpotharmingii", + "areapotdstrong": "lingerpotharmingii", + "areapotdlevelii": "lingerpotharmingii", + "harmingareapotii": "lingerpotharmingii", + "harmingareapotstrong": "lingerpotharmingii", + "harmingareapotlevelii": "lingerpotharmingii", + "damageareapotii": "lingerpotharmingii", + "damageareapotstrong": "lingerpotharmingii", + "damageareapotlevelii": "lingerpotharmingii", + "dmgareapotii": "lingerpotharmingii", + "dmgareapotstrong": "lingerpotharmingii", + "dmgareapotlevelii": "lingerpotharmingii", + "dareapotii": "lingerpotharmingii", + "dareapotstrong": "lingerpotharmingii", + "dareapotlevelii": "lingerpotharmingii", + "cloudpotionharmingii": "lingerpotharmingii", + "cloudpotionharmingstrong": "lingerpotharmingii", + "cloudpotionharminglevelii": "lingerpotharmingii", + "cloudpotiondamageii": "lingerpotharmingii", + "cloudpotiondamagestrong": "lingerpotharmingii", + "cloudpotiondamagelevelii": "lingerpotharmingii", + "cloudpotiondmgii": "lingerpotharmingii", + "cloudpotiondmgstrong": "lingerpotharmingii", + "cloudpotiondmglevelii": "lingerpotharmingii", + "cloudpotiondii": "lingerpotharmingii", + "cloudpotiondstrong": "lingerpotharmingii", + "cloudpotiondlevelii": "lingerpotharmingii", + "harmingcloudpotionii": "lingerpotharmingii", + "harmingcloudpotionstrong": "lingerpotharmingii", + "harmingcloudpotionlevelii": "lingerpotharmingii", + "damagecloudpotionii": "lingerpotharmingii", + "damagecloudpotionstrong": "lingerpotharmingii", + "damagecloudpotionlevelii": "lingerpotharmingii", + "dmgcloudpotionii": "lingerpotharmingii", + "dmgcloudpotionstrong": "lingerpotharmingii", + "dmgcloudpotionlevelii": "lingerpotharmingii", + "dcloudpotionii": "lingerpotharmingii", + "dcloudpotionstrong": "lingerpotharmingii", + "dcloudpotionlevelii": "lingerpotharmingii", + "cloudpotharmingii": "lingerpotharmingii", + "cloudpotharmingstrong": "lingerpotharmingii", + "cloudpotharminglevelii": "lingerpotharmingii", + "cloudpotdamageii": "lingerpotharmingii", + "cloudpotdamagestrong": "lingerpotharmingii", + "cloudpotdamagelevelii": "lingerpotharmingii", + "cloudpotdmgii": "lingerpotharmingii", + "cloudpotdmgstrong": "lingerpotharmingii", + "cloudpotdmglevelii": "lingerpotharmingii", + "cloudpotdii": "lingerpotharmingii", + "cloudpotdstrong": "lingerpotharmingii", + "cloudpotdlevelii": "lingerpotharmingii", + "harmingcloudpotii": "lingerpotharmingii", + "harmingcloudpotstrong": "lingerpotharmingii", + "harmingcloudpotlevelii": "lingerpotharmingii", + "damagecloudpotii": "lingerpotharmingii", + "damagecloudpotstrong": "lingerpotharmingii", + "damagecloudpotlevelii": "lingerpotharmingii", + "dmgcloudpotii": "lingerpotharmingii", + "dmgcloudpotstrong": "lingerpotharmingii", + "dmgcloudpotlevelii": "lingerpotharmingii", + "dcloudpotii": "lingerpotharmingii", + "dcloudpotstrong": "lingerpotharmingii", + "dcloudpotlevelii": "lingerpotharmingii", + "arrowharmingii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_harming", + "bukkitType": "harming", + "isStrong": true, + "isLong": false + } + }, + "arrowharmingstrong": "arrowharmingii", + "arrowharminglevelii": "arrowharmingii", + "arrowdamageii": "arrowharmingii", + "arrowdamagestrong": "arrowharmingii", + "arrowdamagelevelii": "arrowharmingii", + "arrowdmgii": "arrowharmingii", + "arrowdmgstrong": "arrowharmingii", + "arrowdmglevelii": "arrowharmingii", + "arrowdii": "arrowharmingii", + "arrowdstrong": "arrowharmingii", + "arrowdlevelii": "arrowharmingii", + "harmingarrowii": "arrowharmingii", + "harmingarrowstrong": "arrowharmingii", + "harmingarrowlevelii": "arrowharmingii", + "damagearrowii": "arrowharmingii", + "damagearrowstrong": "arrowharmingii", + "damagearrowlevelii": "arrowharmingii", + "dmgarrowii": "arrowharmingii", + "dmgarrowstrong": "arrowharmingii", + "dmgarrowlevelii": "arrowharmingii", + "darrowii": "arrowharmingii", + "darrowstrong": "arrowharmingii", + "darrowlevelii": "arrowharmingii", + "poisonpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": false + } + }, + "acidpotion": "poisonpotion", + "ppotion": "poisonpotion", + "poisonpot": "poisonpotion", + "acidpot": "poisonpotion", + "ppot": "poisonpotion", + "potionofpoison": "poisonpotion", + "potionofacid": "poisonpotion", + "potionofp": "poisonpotion", + "potofpoison": "poisonpotion", + "potofacid": "poisonpotion", + "potofp": "poisonpotion", + "splashpoisonpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": false + } + }, + "splashacidpotion": "splashpoisonpotion", + "splashppotion": "splashpoisonpotion", + "splpoisonpotion": "splashpoisonpotion", + "splacidpotion": "splashpoisonpotion", + "splppotion": "splashpoisonpotion", + "poisonsplashpotion": "splashpoisonpotion", + "acidsplashpotion": "splashpoisonpotion", + "psplashpotion": "splashpoisonpotion", + "splashpoisonpot": "splashpoisonpotion", + "splashacidpot": "splashpoisonpotion", + "splashppot": "splashpoisonpotion", + "splpoisonpot": "splashpoisonpotion", + "splacidpot": "splashpoisonpotion", + "splppot": "splashpoisonpotion", + "poisonsplashpot": "splashpoisonpotion", + "acidsplashpot": "splashpoisonpotion", + "psplashpot": "splashpoisonpotion", + "lingerpotpoison": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": false + } + }, + "lingerpotacid": "lingerpotpoison", + "lingerpotp": "lingerpotpoison", + "poisonlingerpot": "lingerpotpoison", + "acidlingerpot": "lingerpotpoison", + "plingerpot": "lingerpotpoison", + "aoepotionpoison": "lingerpotpoison", + "aoepotionacid": "lingerpotpoison", + "aoepotionp": "lingerpotpoison", + "poisonaoepoiont": "lingerpotpoison", + "acidaoepoiont": "lingerpotpoison", + "paoepoiont": "lingerpotpoison", + "aoepotpoison": "lingerpotpoison", + "aoepotacid": "lingerpotpoison", + "aoepotp": "lingerpotpoison", + "poisonaoepot": "lingerpotpoison", + "acidaoepot": "lingerpotpoison", + "paoepot": "lingerpotpoison", + "areapotionpoison": "lingerpotpoison", + "areapotionacid": "lingerpotpoison", + "areapotionp": "lingerpotpoison", + "poisonareapotion": "lingerpotpoison", + "acidareapotion": "lingerpotpoison", + "pareapotion": "lingerpotpoison", + "areapotpoison": "lingerpotpoison", + "areapotacid": "lingerpotpoison", + "areapotp": "lingerpotpoison", + "poisonareapot": "lingerpotpoison", + "acidareapot": "lingerpotpoison", + "pareapot": "lingerpotpoison", + "cloudpotionpoison": "lingerpotpoison", + "cloudpotionacid": "lingerpotpoison", + "cloudpotionp": "lingerpotpoison", + "poisoncloudpotion": "lingerpotpoison", + "acidcloudpotion": "lingerpotpoison", + "pcloudpotion": "lingerpotpoison", + "cloudpotpoison": "lingerpotpoison", + "cloudpotacid": "lingerpotpoison", + "cloudpotp": "lingerpotpoison", + "poisoncloudpot": "lingerpotpoison", + "acidcloudpot": "lingerpotpoison", + "pcloudpot": "lingerpotpoison", + "arrowpoison": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": false + } + }, + "arrowacid": "arrowpoison", + "arrowp": "arrowpoison", + "poisonarrow": "arrowpoison", + "acidarrow": "arrowpoison", + "parrow": "arrowpoison", + "poisoniipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_poison", + "bukkitType": "poison", + "isStrong": true, + "isLong": false + } + }, + "poisonstrongpotion": "poisoniipotion", + "poisonleveliipotion": "poisoniipotion", + "acidiipotion": "poisoniipotion", + "acidstrongpotion": "poisoniipotion", + "acidleveliipotion": "poisoniipotion", + "piipotion": "poisoniipotion", + "pstrongpotion": "poisoniipotion", + "pleveliipotion": "poisoniipotion", + "poisoniipot": "poisoniipotion", + "poisonstrongpot": "poisoniipotion", + "poisonleveliipot": "poisoniipotion", + "acidiipot": "poisoniipotion", + "acidstrongpot": "poisoniipotion", + "acidleveliipot": "poisoniipotion", + "piipot": "poisoniipotion", + "pstrongpot": "poisoniipotion", + "pleveliipot": "poisoniipotion", + "potionofpoisonii": "poisoniipotion", + "potionofpoisonstrong": "poisoniipotion", + "potionofpoisonlevelii": "poisoniipotion", + "potionofacidii": "poisoniipotion", + "potionofacidstrong": "poisoniipotion", + "potionofacidlevelii": "poisoniipotion", + "potionofpii": "poisoniipotion", + "potionofpstrong": "poisoniipotion", + "potionofplevelii": "poisoniipotion", + "potofpoisonii": "poisoniipotion", + "potofpoisonstrong": "poisoniipotion", + "potofpoisonlevelii": "poisoniipotion", + "potofacidii": "poisoniipotion", + "potofacidstrong": "poisoniipotion", + "potofacidlevelii": "poisoniipotion", + "potofpii": "poisoniipotion", + "potofpstrong": "poisoniipotion", + "potofplevelii": "poisoniipotion", + "splashpoisoniipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_poison", + "bukkitType": "poison", + "isStrong": true, + "isLong": false + } + }, + "splashpoisonstrongpotion": "splashpoisoniipotion", + "splashpoisonleveliipotion": "splashpoisoniipotion", + "splashacidiipotion": "splashpoisoniipotion", + "splashacidstrongpotion": "splashpoisoniipotion", + "splashacidleveliipotion": "splashpoisoniipotion", + "splashpiipotion": "splashpoisoniipotion", + "splashpstrongpotion": "splashpoisoniipotion", + "splashpleveliipotion": "splashpoisoniipotion", + "splpoisoniipotion": "splashpoisoniipotion", + "splpoisonstrongpotion": "splashpoisoniipotion", + "splpoisonleveliipotion": "splashpoisoniipotion", + "splacidiipotion": "splashpoisoniipotion", + "splacidstrongpotion": "splashpoisoniipotion", + "splacidleveliipotion": "splashpoisoniipotion", + "splpiipotion": "splashpoisoniipotion", + "splpstrongpotion": "splashpoisoniipotion", + "splpleveliipotion": "splashpoisoniipotion", + "poisoniisplashpotion": "splashpoisoniipotion", + "poisonstrongsplashpotion": "splashpoisoniipotion", + "poisonleveliisplashpotion": "splashpoisoniipotion", + "acidiisplashpotion": "splashpoisoniipotion", + "acidstrongsplashpotion": "splashpoisoniipotion", + "acidleveliisplashpotion": "splashpoisoniipotion", + "piisplashpotion": "splashpoisoniipotion", + "pstrongsplashpotion": "splashpoisoniipotion", + "pleveliisplashpotion": "splashpoisoniipotion", + "splashpoisoniipot": "splashpoisoniipotion", + "splashpoisonstrongpot": "splashpoisoniipotion", + "splashpoisonleveliipot": "splashpoisoniipotion", + "splashacidiipot": "splashpoisoniipotion", + "splashacidstrongpot": "splashpoisoniipotion", + "splashacidleveliipot": "splashpoisoniipotion", + "splashpiipot": "splashpoisoniipotion", + "splashpstrongpot": "splashpoisoniipotion", + "splashpleveliipot": "splashpoisoniipotion", + "splpoisoniipot": "splashpoisoniipotion", + "splpoisonstrongpot": "splashpoisoniipotion", + "splpoisonleveliipot": "splashpoisoniipotion", + "splacidiipot": "splashpoisoniipotion", + "splacidstrongpot": "splashpoisoniipotion", + "splacidleveliipot": "splashpoisoniipotion", + "splpiipot": "splashpoisoniipotion", + "splpstrongpot": "splashpoisoniipotion", + "splpleveliipot": "splashpoisoniipotion", + "poisoniisplashpot": "splashpoisoniipotion", + "poisonstrongsplashpot": "splashpoisoniipotion", + "poisonleveliisplashpot": "splashpoisoniipotion", + "acidiisplashpot": "splashpoisoniipotion", + "acidstrongsplashpot": "splashpoisoniipotion", + "acidleveliisplashpot": "splashpoisoniipotion", + "piisplashpot": "splashpoisoniipotion", + "pstrongsplashpot": "splashpoisoniipotion", + "pleveliisplashpot": "splashpoisoniipotion", + "lingerpotpoisonii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_poison", + "bukkitType": "poison", + "isStrong": true, + "isLong": false + } + }, + "lingerpotpoisonstrong": "lingerpotpoisonii", + "lingerpotpoisonlevelii": "lingerpotpoisonii", + "lingerpotacidii": "lingerpotpoisonii", + "lingerpotacidstrong": "lingerpotpoisonii", + "lingerpotacidlevelii": "lingerpotpoisonii", + "lingerpotpii": "lingerpotpoisonii", + "lingerpotpstrong": "lingerpotpoisonii", + "lingerpotplevelii": "lingerpotpoisonii", + "poisonlingerpotii": "lingerpotpoisonii", + "poisonlingerpotstrong": "lingerpotpoisonii", + "poisonlingerpotlevelii": "lingerpotpoisonii", + "acidlingerpotii": "lingerpotpoisonii", + "acidlingerpotstrong": "lingerpotpoisonii", + "acidlingerpotlevelii": "lingerpotpoisonii", + "plingerpotii": "lingerpotpoisonii", + "plingerpotstrong": "lingerpotpoisonii", + "plingerpotlevelii": "lingerpotpoisonii", + "aoepotionpoisonii": "lingerpotpoisonii", + "aoepotionpoisonstrong": "lingerpotpoisonii", + "aoepotionpoisonlevelii": "lingerpotpoisonii", + "aoepotionacidii": "lingerpotpoisonii", + "aoepotionacidstrong": "lingerpotpoisonii", + "aoepotionacidlevelii": "lingerpotpoisonii", + "aoepotionpii": "lingerpotpoisonii", + "aoepotionpstrong": "lingerpotpoisonii", + "aoepotionplevelii": "lingerpotpoisonii", + "poisonaoepoiontii": "lingerpotpoisonii", + "poisonaoepoiontstrong": "lingerpotpoisonii", + "poisonaoepoiontlevelii": "lingerpotpoisonii", + "acidaoepoiontii": "lingerpotpoisonii", + "acidaoepoiontstrong": "lingerpotpoisonii", + "acidaoepoiontlevelii": "lingerpotpoisonii", + "paoepoiontii": "lingerpotpoisonii", + "paoepoiontstrong": "lingerpotpoisonii", + "paoepoiontlevelii": "lingerpotpoisonii", + "aoepotpoisonii": "lingerpotpoisonii", + "aoepotpoisonstrong": "lingerpotpoisonii", + "aoepotpoisonlevelii": "lingerpotpoisonii", + "aoepotacidii": "lingerpotpoisonii", + "aoepotacidstrong": "lingerpotpoisonii", + "aoepotacidlevelii": "lingerpotpoisonii", + "aoepotpii": "lingerpotpoisonii", + "aoepotpstrong": "lingerpotpoisonii", + "aoepotplevelii": "lingerpotpoisonii", + "poisonaoepotii": "lingerpotpoisonii", + "poisonaoepotstrong": "lingerpotpoisonii", + "poisonaoepotlevelii": "lingerpotpoisonii", + "acidaoepotii": "lingerpotpoisonii", + "acidaoepotstrong": "lingerpotpoisonii", + "acidaoepotlevelii": "lingerpotpoisonii", + "paoepotii": "lingerpotpoisonii", + "paoepotstrong": "lingerpotpoisonii", + "paoepotlevelii": "lingerpotpoisonii", + "areapotionpoisonii": "lingerpotpoisonii", + "areapotionpoisonstrong": "lingerpotpoisonii", + "areapotionpoisonlevelii": "lingerpotpoisonii", + "areapotionacidii": "lingerpotpoisonii", + "areapotionacidstrong": "lingerpotpoisonii", + "areapotionacidlevelii": "lingerpotpoisonii", + "areapotionpii": "lingerpotpoisonii", + "areapotionpstrong": "lingerpotpoisonii", + "areapotionplevelii": "lingerpotpoisonii", + "poisonareapotionii": "lingerpotpoisonii", + "poisonareapotionstrong": "lingerpotpoisonii", + "poisonareapotionlevelii": "lingerpotpoisonii", + "acidareapotionii": "lingerpotpoisonii", + "acidareapotionstrong": "lingerpotpoisonii", + "acidareapotionlevelii": "lingerpotpoisonii", + "pareapotionii": "lingerpotpoisonii", + "pareapotionstrong": "lingerpotpoisonii", + "pareapotionlevelii": "lingerpotpoisonii", + "areapotpoisonii": "lingerpotpoisonii", + "areapotpoisonstrong": "lingerpotpoisonii", + "areapotpoisonlevelii": "lingerpotpoisonii", + "areapotacidii": "lingerpotpoisonii", + "areapotacidstrong": "lingerpotpoisonii", + "areapotacidlevelii": "lingerpotpoisonii", + "areapotpii": "lingerpotpoisonii", + "areapotpstrong": "lingerpotpoisonii", + "areapotplevelii": "lingerpotpoisonii", + "poisonareapotii": "lingerpotpoisonii", + "poisonareapotstrong": "lingerpotpoisonii", + "poisonareapotlevelii": "lingerpotpoisonii", + "acidareapotii": "lingerpotpoisonii", + "acidareapotstrong": "lingerpotpoisonii", + "acidareapotlevelii": "lingerpotpoisonii", + "pareapotii": "lingerpotpoisonii", + "pareapotstrong": "lingerpotpoisonii", + "pareapotlevelii": "lingerpotpoisonii", + "cloudpotionpoisonii": "lingerpotpoisonii", + "cloudpotionpoisonstrong": "lingerpotpoisonii", + "cloudpotionpoisonlevelii": "lingerpotpoisonii", + "cloudpotionacidii": "lingerpotpoisonii", + "cloudpotionacidstrong": "lingerpotpoisonii", + "cloudpotionacidlevelii": "lingerpotpoisonii", + "cloudpotionpii": "lingerpotpoisonii", + "cloudpotionpstrong": "lingerpotpoisonii", + "cloudpotionplevelii": "lingerpotpoisonii", + "poisoncloudpotionii": "lingerpotpoisonii", + "poisoncloudpotionstrong": "lingerpotpoisonii", + "poisoncloudpotionlevelii": "lingerpotpoisonii", + "acidcloudpotionii": "lingerpotpoisonii", + "acidcloudpotionstrong": "lingerpotpoisonii", + "acidcloudpotionlevelii": "lingerpotpoisonii", + "pcloudpotionii": "lingerpotpoisonii", + "pcloudpotionstrong": "lingerpotpoisonii", + "pcloudpotionlevelii": "lingerpotpoisonii", + "cloudpotpoisonii": "lingerpotpoisonii", + "cloudpotpoisonstrong": "lingerpotpoisonii", + "cloudpotpoisonlevelii": "lingerpotpoisonii", + "cloudpotacidii": "lingerpotpoisonii", + "cloudpotacidstrong": "lingerpotpoisonii", + "cloudpotacidlevelii": "lingerpotpoisonii", + "cloudpotpii": "lingerpotpoisonii", + "cloudpotpstrong": "lingerpotpoisonii", + "cloudpotplevelii": "lingerpotpoisonii", + "poisoncloudpotii": "lingerpotpoisonii", + "poisoncloudpotstrong": "lingerpotpoisonii", + "poisoncloudpotlevelii": "lingerpotpoisonii", + "acidcloudpotii": "lingerpotpoisonii", + "acidcloudpotstrong": "lingerpotpoisonii", + "acidcloudpotlevelii": "lingerpotpoisonii", + "pcloudpotii": "lingerpotpoisonii", + "pcloudpotstrong": "lingerpotpoisonii", + "pcloudpotlevelii": "lingerpotpoisonii", + "arrowpoisonii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_poison", + "bukkitType": "poison", + "isStrong": true, + "isLong": false + } + }, + "arrowpoisonstrong": "arrowpoisonii", + "arrowpoisonlevelii": "arrowpoisonii", + "arrowacidii": "arrowpoisonii", + "arrowacidstrong": "arrowpoisonii", + "arrowacidlevelii": "arrowpoisonii", + "arrowpii": "arrowpoisonii", + "arrowpstrong": "arrowpoisonii", + "arrowplevelii": "arrowpoisonii", + "poisonarrowii": "arrowpoisonii", + "poisonarrowstrong": "arrowpoisonii", + "poisonarrowlevelii": "arrowpoisonii", + "acidarrowii": "arrowpoisonii", + "acidarrowstrong": "arrowpoisonii", + "acidarrowlevelii": "arrowpoisonii", + "parrowii": "arrowpoisonii", + "parrowstrong": "arrowpoisonii", + "parrowlevelii": "arrowpoisonii", + "poison2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": true + } + }, + "poisonlongpotion": "poison2potion", + "poisonextendedpotion": "poison2potion", + "poisonexpotion": "poison2potion", + "poisonlevel2potion": "poison2potion", + "acid2potion": "poison2potion", + "acidlongpotion": "poison2potion", + "acidextendedpotion": "poison2potion", + "acidexpotion": "poison2potion", + "acidlevel2potion": "poison2potion", + "p2potion": "poison2potion", + "plongpotion": "poison2potion", + "pextendedpotion": "poison2potion", + "pexpotion": "poison2potion", + "plevel2potion": "poison2potion", + "poison2pot": "poison2potion", + "poisonlongpot": "poison2potion", + "poisonextendedpot": "poison2potion", + "poisonexpot": "poison2potion", + "poisonlevel2pot": "poison2potion", + "acid2pot": "poison2potion", + "acidlongpot": "poison2potion", + "acidextendedpot": "poison2potion", + "acidexpot": "poison2potion", + "acidlevel2pot": "poison2potion", + "p2pot": "poison2potion", + "plongpot": "poison2potion", + "pextendedpot": "poison2potion", + "pexpot": "poison2potion", + "plevel2pot": "poison2potion", + "potionofpoison2": "poison2potion", + "potionofpoisonlong": "poison2potion", + "potionofpoisonextended": "poison2potion", + "potionofpoisonex": "poison2potion", + "potionofpoisonlevel2": "poison2potion", + "potionofacid2": "poison2potion", + "potionofacidlong": "poison2potion", + "potionofacidextended": "poison2potion", + "potionofacidex": "poison2potion", + "potionofacidlevel2": "poison2potion", + "potionofp2": "poison2potion", + "potionofplong": "poison2potion", + "potionofpextended": "poison2potion", + "potionofpex": "poison2potion", + "potionofplevel2": "poison2potion", + "potofpoison2": "poison2potion", + "potofpoisonlong": "poison2potion", + "potofpoisonextended": "poison2potion", + "potofpoisonex": "poison2potion", + "potofpoisonlevel2": "poison2potion", + "potofacid2": "poison2potion", + "potofacidlong": "poison2potion", + "potofacidextended": "poison2potion", + "potofacidex": "poison2potion", + "potofacidlevel2": "poison2potion", + "potofp2": "poison2potion", + "potofplong": "poison2potion", + "potofpextended": "poison2potion", + "potofpex": "poison2potion", + "potofplevel2": "poison2potion", + "splashpoison2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": true + } + }, + "splashpoisonlongpotion": "splashpoison2potion", + "splashpoisonextendedpotion": "splashpoison2potion", + "splashpoisonexpotion": "splashpoison2potion", + "splashpoisonlevel2potion": "splashpoison2potion", + "splashacid2potion": "splashpoison2potion", + "splashacidlongpotion": "splashpoison2potion", + "splashacidextendedpotion": "splashpoison2potion", + "splashacidexpotion": "splashpoison2potion", + "splashacidlevel2potion": "splashpoison2potion", + "splashp2potion": "splashpoison2potion", + "splashplongpotion": "splashpoison2potion", + "splashpextendedpotion": "splashpoison2potion", + "splashpexpotion": "splashpoison2potion", + "splashplevel2potion": "splashpoison2potion", + "splpoison2potion": "splashpoison2potion", + "splpoisonlongpotion": "splashpoison2potion", + "splpoisonextendedpotion": "splashpoison2potion", + "splpoisonexpotion": "splashpoison2potion", + "splpoisonlevel2potion": "splashpoison2potion", + "splacid2potion": "splashpoison2potion", + "splacidlongpotion": "splashpoison2potion", + "splacidextendedpotion": "splashpoison2potion", + "splacidexpotion": "splashpoison2potion", + "splacidlevel2potion": "splashpoison2potion", + "splp2potion": "splashpoison2potion", + "splplongpotion": "splashpoison2potion", + "splpextendedpotion": "splashpoison2potion", + "splpexpotion": "splashpoison2potion", + "splplevel2potion": "splashpoison2potion", + "poison2splashpotion": "splashpoison2potion", + "poisonlongsplashpotion": "splashpoison2potion", + "poisonextendedsplashpotion": "splashpoison2potion", + "poisonexsplashpotion": "splashpoison2potion", + "poisonlevel2splashpotion": "splashpoison2potion", + "acid2splashpotion": "splashpoison2potion", + "acidlongsplashpotion": "splashpoison2potion", + "acidextendedsplashpotion": "splashpoison2potion", + "acidexsplashpotion": "splashpoison2potion", + "acidlevel2splashpotion": "splashpoison2potion", + "p2splashpotion": "splashpoison2potion", + "plongsplashpotion": "splashpoison2potion", + "pextendedsplashpotion": "splashpoison2potion", + "pexsplashpotion": "splashpoison2potion", + "plevel2splashpotion": "splashpoison2potion", + "splashpoison2pot": "splashpoison2potion", + "splashpoisonlongpot": "splashpoison2potion", + "splashpoisonextendedpot": "splashpoison2potion", + "splashpoisonexpot": "splashpoison2potion", + "splashpoisonlevel2pot": "splashpoison2potion", + "splashacid2pot": "splashpoison2potion", + "splashacidlongpot": "splashpoison2potion", + "splashacidextendedpot": "splashpoison2potion", + "splashacidexpot": "splashpoison2potion", + "splashacidlevel2pot": "splashpoison2potion", + "splashp2pot": "splashpoison2potion", + "splashplongpot": "splashpoison2potion", + "splashpextendedpot": "splashpoison2potion", + "splashpexpot": "splashpoison2potion", + "splashplevel2pot": "splashpoison2potion", + "splpoison2pot": "splashpoison2potion", + "splpoisonlongpot": "splashpoison2potion", + "splpoisonextendedpot": "splashpoison2potion", + "splpoisonexpot": "splashpoison2potion", + "splpoisonlevel2pot": "splashpoison2potion", + "splacid2pot": "splashpoison2potion", + "splacidlongpot": "splashpoison2potion", + "splacidextendedpot": "splashpoison2potion", + "splacidexpot": "splashpoison2potion", + "splacidlevel2pot": "splashpoison2potion", + "splp2pot": "splashpoison2potion", + "splplongpot": "splashpoison2potion", + "splpextendedpot": "splashpoison2potion", + "splpexpot": "splashpoison2potion", + "splplevel2pot": "splashpoison2potion", + "poison2splashpot": "splashpoison2potion", + "poisonlongsplashpot": "splashpoison2potion", + "poisonextendedsplashpot": "splashpoison2potion", + "poisonexsplashpot": "splashpoison2potion", + "poisonlevel2splashpot": "splashpoison2potion", + "acid2splashpot": "splashpoison2potion", + "acidlongsplashpot": "splashpoison2potion", + "acidextendedsplashpot": "splashpoison2potion", + "acidexsplashpot": "splashpoison2potion", + "acidlevel2splashpot": "splashpoison2potion", + "p2splashpot": "splashpoison2potion", + "plongsplashpot": "splashpoison2potion", + "pextendedsplashpot": "splashpoison2potion", + "pexsplashpot": "splashpoison2potion", + "plevel2splashpot": "splashpoison2potion", + "lingerpotpoison2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": true + } + }, + "lingerpotpoisonlong": "lingerpotpoison2", + "lingerpotpoisonextended": "lingerpotpoison2", + "lingerpotpoisonex": "lingerpotpoison2", + "lingerpotpoisonlevel2": "lingerpotpoison2", + "lingerpotacid2": "lingerpotpoison2", + "lingerpotacidlong": "lingerpotpoison2", + "lingerpotacidextended": "lingerpotpoison2", + "lingerpotacidex": "lingerpotpoison2", + "lingerpotacidlevel2": "lingerpotpoison2", + "lingerpotp2": "lingerpotpoison2", + "lingerpotplong": "lingerpotpoison2", + "lingerpotpextended": "lingerpotpoison2", + "lingerpotpex": "lingerpotpoison2", + "lingerpotplevel2": "lingerpotpoison2", + "poisonlingerpot2": "lingerpotpoison2", + "poisonlingerpotlong": "lingerpotpoison2", + "poisonlingerpotextended": "lingerpotpoison2", + "poisonlingerpotex": "lingerpotpoison2", + "poisonlingerpotlevel2": "lingerpotpoison2", + "acidlingerpot2": "lingerpotpoison2", + "acidlingerpotlong": "lingerpotpoison2", + "acidlingerpotextended": "lingerpotpoison2", + "acidlingerpotex": "lingerpotpoison2", + "acidlingerpotlevel2": "lingerpotpoison2", + "plingerpot2": "lingerpotpoison2", + "plingerpotlong": "lingerpotpoison2", + "plingerpotextended": "lingerpotpoison2", + "plingerpotex": "lingerpotpoison2", + "plingerpotlevel2": "lingerpotpoison2", + "aoepotionpoison2": "lingerpotpoison2", + "aoepotionpoisonlong": "lingerpotpoison2", + "aoepotionpoisonextended": "lingerpotpoison2", + "aoepotionpoisonex": "lingerpotpoison2", + "aoepotionpoisonlevel2": "lingerpotpoison2", + "aoepotionacid2": "lingerpotpoison2", + "aoepotionacidlong": "lingerpotpoison2", + "aoepotionacidextended": "lingerpotpoison2", + "aoepotionacidex": "lingerpotpoison2", + "aoepotionacidlevel2": "lingerpotpoison2", + "aoepotionp2": "lingerpotpoison2", + "aoepotionplong": "lingerpotpoison2", + "aoepotionpextended": "lingerpotpoison2", + "aoepotionpex": "lingerpotpoison2", + "aoepotionplevel2": "lingerpotpoison2", + "poisonaoepoiont2": "lingerpotpoison2", + "poisonaoepoiontlong": "lingerpotpoison2", + "poisonaoepoiontextended": "lingerpotpoison2", + "poisonaoepoiontex": "lingerpotpoison2", + "poisonaoepoiontlevel2": "lingerpotpoison2", + "acidaoepoiont2": "lingerpotpoison2", + "acidaoepoiontlong": "lingerpotpoison2", + "acidaoepoiontextended": "lingerpotpoison2", + "acidaoepoiontex": "lingerpotpoison2", + "acidaoepoiontlevel2": "lingerpotpoison2", + "paoepoiont2": "lingerpotpoison2", + "paoepoiontlong": "lingerpotpoison2", + "paoepoiontextended": "lingerpotpoison2", + "paoepoiontex": "lingerpotpoison2", + "paoepoiontlevel2": "lingerpotpoison2", + "aoepotpoison2": "lingerpotpoison2", + "aoepotpoisonlong": "lingerpotpoison2", + "aoepotpoisonextended": "lingerpotpoison2", + "aoepotpoisonex": "lingerpotpoison2", + "aoepotpoisonlevel2": "lingerpotpoison2", + "aoepotacid2": "lingerpotpoison2", + "aoepotacidlong": "lingerpotpoison2", + "aoepotacidextended": "lingerpotpoison2", + "aoepotacidex": "lingerpotpoison2", + "aoepotacidlevel2": "lingerpotpoison2", + "aoepotp2": "lingerpotpoison2", + "aoepotplong": "lingerpotpoison2", + "aoepotpextended": "lingerpotpoison2", + "aoepotpex": "lingerpotpoison2", + "aoepotplevel2": "lingerpotpoison2", + "poisonaoepot2": "lingerpotpoison2", + "poisonaoepotlong": "lingerpotpoison2", + "poisonaoepotextended": "lingerpotpoison2", + "poisonaoepotex": "lingerpotpoison2", + "poisonaoepotlevel2": "lingerpotpoison2", + "acidaoepot2": "lingerpotpoison2", + "acidaoepotlong": "lingerpotpoison2", + "acidaoepotextended": "lingerpotpoison2", + "acidaoepotex": "lingerpotpoison2", + "acidaoepotlevel2": "lingerpotpoison2", + "paoepot2": "lingerpotpoison2", + "paoepotlong": "lingerpotpoison2", + "paoepotextended": "lingerpotpoison2", + "paoepotex": "lingerpotpoison2", + "paoepotlevel2": "lingerpotpoison2", + "areapotionpoison2": "lingerpotpoison2", + "areapotionpoisonlong": "lingerpotpoison2", + "areapotionpoisonextended": "lingerpotpoison2", + "areapotionpoisonex": "lingerpotpoison2", + "areapotionpoisonlevel2": "lingerpotpoison2", + "areapotionacid2": "lingerpotpoison2", + "areapotionacidlong": "lingerpotpoison2", + "areapotionacidextended": "lingerpotpoison2", + "areapotionacidex": "lingerpotpoison2", + "areapotionacidlevel2": "lingerpotpoison2", + "areapotionp2": "lingerpotpoison2", + "areapotionplong": "lingerpotpoison2", + "areapotionpextended": "lingerpotpoison2", + "areapotionpex": "lingerpotpoison2", + "areapotionplevel2": "lingerpotpoison2", + "poisonareapotion2": "lingerpotpoison2", + "poisonareapotionlong": "lingerpotpoison2", + "poisonareapotionextended": "lingerpotpoison2", + "poisonareapotionex": "lingerpotpoison2", + "poisonareapotionlevel2": "lingerpotpoison2", + "acidareapotion2": "lingerpotpoison2", + "acidareapotionlong": "lingerpotpoison2", + "acidareapotionextended": "lingerpotpoison2", + "acidareapotionex": "lingerpotpoison2", + "acidareapotionlevel2": "lingerpotpoison2", + "pareapotion2": "lingerpotpoison2", + "pareapotionlong": "lingerpotpoison2", + "pareapotionextended": "lingerpotpoison2", + "pareapotionex": "lingerpotpoison2", + "pareapotionlevel2": "lingerpotpoison2", + "areapotpoison2": "lingerpotpoison2", + "areapotpoisonlong": "lingerpotpoison2", + "areapotpoisonextended": "lingerpotpoison2", + "areapotpoisonex": "lingerpotpoison2", + "areapotpoisonlevel2": "lingerpotpoison2", + "areapotacid2": "lingerpotpoison2", + "areapotacidlong": "lingerpotpoison2", + "areapotacidextended": "lingerpotpoison2", + "areapotacidex": "lingerpotpoison2", + "areapotacidlevel2": "lingerpotpoison2", + "areapotp2": "lingerpotpoison2", + "areapotplong": "lingerpotpoison2", + "areapotpextended": "lingerpotpoison2", + "areapotpex": "lingerpotpoison2", + "areapotplevel2": "lingerpotpoison2", + "poisonareapot2": "lingerpotpoison2", + "poisonareapotlong": "lingerpotpoison2", + "poisonareapotextended": "lingerpotpoison2", + "poisonareapotex": "lingerpotpoison2", + "poisonareapotlevel2": "lingerpotpoison2", + "acidareapot2": "lingerpotpoison2", + "acidareapotlong": "lingerpotpoison2", + "acidareapotextended": "lingerpotpoison2", + "acidareapotex": "lingerpotpoison2", + "acidareapotlevel2": "lingerpotpoison2", + "pareapot2": "lingerpotpoison2", + "pareapotlong": "lingerpotpoison2", + "pareapotextended": "lingerpotpoison2", + "pareapotex": "lingerpotpoison2", + "pareapotlevel2": "lingerpotpoison2", + "cloudpotionpoison2": "lingerpotpoison2", + "cloudpotionpoisonlong": "lingerpotpoison2", + "cloudpotionpoisonextended": "lingerpotpoison2", + "cloudpotionpoisonex": "lingerpotpoison2", + "cloudpotionpoisonlevel2": "lingerpotpoison2", + "cloudpotionacid2": "lingerpotpoison2", + "cloudpotionacidlong": "lingerpotpoison2", + "cloudpotionacidextended": "lingerpotpoison2", + "cloudpotionacidex": "lingerpotpoison2", + "cloudpotionacidlevel2": "lingerpotpoison2", + "cloudpotionp2": "lingerpotpoison2", + "cloudpotionplong": "lingerpotpoison2", + "cloudpotionpextended": "lingerpotpoison2", + "cloudpotionpex": "lingerpotpoison2", + "cloudpotionplevel2": "lingerpotpoison2", + "poisoncloudpotion2": "lingerpotpoison2", + "poisoncloudpotionlong": "lingerpotpoison2", + "poisoncloudpotionextended": "lingerpotpoison2", + "poisoncloudpotionex": "lingerpotpoison2", + "poisoncloudpotionlevel2": "lingerpotpoison2", + "acidcloudpotion2": "lingerpotpoison2", + "acidcloudpotionlong": "lingerpotpoison2", + "acidcloudpotionextended": "lingerpotpoison2", + "acidcloudpotionex": "lingerpotpoison2", + "acidcloudpotionlevel2": "lingerpotpoison2", + "pcloudpotion2": "lingerpotpoison2", + "pcloudpotionlong": "lingerpotpoison2", + "pcloudpotionextended": "lingerpotpoison2", + "pcloudpotionex": "lingerpotpoison2", + "pcloudpotionlevel2": "lingerpotpoison2", + "cloudpotpoison2": "lingerpotpoison2", + "cloudpotpoisonlong": "lingerpotpoison2", + "cloudpotpoisonextended": "lingerpotpoison2", + "cloudpotpoisonex": "lingerpotpoison2", + "cloudpotpoisonlevel2": "lingerpotpoison2", + "cloudpotacid2": "lingerpotpoison2", + "cloudpotacidlong": "lingerpotpoison2", + "cloudpotacidextended": "lingerpotpoison2", + "cloudpotacidex": "lingerpotpoison2", + "cloudpotacidlevel2": "lingerpotpoison2", + "cloudpotp2": "lingerpotpoison2", + "cloudpotplong": "lingerpotpoison2", + "cloudpotpextended": "lingerpotpoison2", + "cloudpotpex": "lingerpotpoison2", + "cloudpotplevel2": "lingerpotpoison2", + "poisoncloudpot2": "lingerpotpoison2", + "poisoncloudpotlong": "lingerpotpoison2", + "poisoncloudpotextended": "lingerpotpoison2", + "poisoncloudpotex": "lingerpotpoison2", + "poisoncloudpotlevel2": "lingerpotpoison2", + "acidcloudpot2": "lingerpotpoison2", + "acidcloudpotlong": "lingerpotpoison2", + "acidcloudpotextended": "lingerpotpoison2", + "acidcloudpotex": "lingerpotpoison2", + "acidcloudpotlevel2": "lingerpotpoison2", + "pcloudpot2": "lingerpotpoison2", + "pcloudpotlong": "lingerpotpoison2", + "pcloudpotextended": "lingerpotpoison2", + "pcloudpotex": "lingerpotpoison2", + "pcloudpotlevel2": "lingerpotpoison2", + "arrowpoison2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_poison", + "bukkitType": "poison", + "isStrong": false, + "isLong": true + } + }, + "arrowpoisonlong": "arrowpoison2", + "arrowpoisonextended": "arrowpoison2", + "arrowpoisonex": "arrowpoison2", + "arrowpoisonlevel2": "arrowpoison2", + "arrowacid2": "arrowpoison2", + "arrowacidlong": "arrowpoison2", + "arrowacidextended": "arrowpoison2", + "arrowacidex": "arrowpoison2", + "arrowacidlevel2": "arrowpoison2", + "arrowp2": "arrowpoison2", + "arrowplong": "arrowpoison2", + "arrowpextended": "arrowpoison2", + "arrowpex": "arrowpoison2", + "arrowplevel2": "arrowpoison2", + "poisonarrow2": "arrowpoison2", + "poisonarrowlong": "arrowpoison2", + "poisonarrowextended": "arrowpoison2", + "poisonarrowex": "arrowpoison2", + "poisonarrowlevel2": "arrowpoison2", + "acidarrow2": "arrowpoison2", + "acidarrowlong": "arrowpoison2", + "acidarrowextended": "arrowpoison2", + "acidarrowex": "arrowpoison2", + "acidarrowlevel2": "arrowpoison2", + "parrow2": "arrowpoison2", + "parrowlong": "arrowpoison2", + "parrowextended": "arrowpoison2", + "parrowex": "arrowpoison2", + "parrowlevel2": "arrowpoison2", + "regenerationpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": false + } + }, + "regeneratepotion": "regenerationpotion", + "regenpotion": "regenerationpotion", + "regenerationpot": "regenerationpotion", + "regeneratepot": "regenerationpotion", + "regenpot": "regenerationpotion", + "potionofregeneration": "regenerationpotion", + "potionofregenerate": "regenerationpotion", + "potionofregen": "regenerationpotion", + "potofregeneration": "regenerationpotion", + "potofregenerate": "regenerationpotion", + "potofregen": "regenerationpotion", + "splashregenerationpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": false + } + }, + "splashregeneratepotion": "splashregenerationpotion", + "splashregenpotion": "splashregenerationpotion", + "splregenerationpotion": "splashregenerationpotion", + "splregeneratepotion": "splashregenerationpotion", + "splregenpotion": "splashregenerationpotion", + "regenerationsplashpotion": "splashregenerationpotion", + "regeneratesplashpotion": "splashregenerationpotion", + "regensplashpotion": "splashregenerationpotion", + "splashregenerationpot": "splashregenerationpotion", + "splashregeneratepot": "splashregenerationpotion", + "splashregenpot": "splashregenerationpotion", + "splregenerationpot": "splashregenerationpotion", + "splregeneratepot": "splashregenerationpotion", + "splregenpot": "splashregenerationpotion", + "regenerationsplashpot": "splashregenerationpotion", + "regeneratesplashpot": "splashregenerationpotion", + "regensplashpot": "splashregenerationpotion", + "lingerpotregeneration": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": false + } + }, + "lingerpotregenerate": "lingerpotregeneration", + "lingerpotregen": "lingerpotregeneration", + "regenerationlingerpot": "lingerpotregeneration", + "regeneratelingerpot": "lingerpotregeneration", + "regenlingerpot": "lingerpotregeneration", + "aoepotionregeneration": "lingerpotregeneration", + "aoepotionregenerate": "lingerpotregeneration", + "aoepotionregen": "lingerpotregeneration", + "regenerationaoepoiont": "lingerpotregeneration", + "regenerateaoepoiont": "lingerpotregeneration", + "regenaoepoiont": "lingerpotregeneration", + "aoepotregeneration": "lingerpotregeneration", + "aoepotregenerate": "lingerpotregeneration", + "aoepotregen": "lingerpotregeneration", + "regenerationaoepot": "lingerpotregeneration", + "regenerateaoepot": "lingerpotregeneration", + "regenaoepot": "lingerpotregeneration", + "areapotionregeneration": "lingerpotregeneration", + "areapotionregenerate": "lingerpotregeneration", + "areapotionregen": "lingerpotregeneration", + "regenerationareapotion": "lingerpotregeneration", + "regenerateareapotion": "lingerpotregeneration", + "regenareapotion": "lingerpotregeneration", + "areapotregeneration": "lingerpotregeneration", + "areapotregenerate": "lingerpotregeneration", + "areapotregen": "lingerpotregeneration", + "regenerationareapot": "lingerpotregeneration", + "regenerateareapot": "lingerpotregeneration", + "regenareapot": "lingerpotregeneration", + "cloudpotionregeneration": "lingerpotregeneration", + "cloudpotionregenerate": "lingerpotregeneration", + "cloudpotionregen": "lingerpotregeneration", + "regenerationcloudpotion": "lingerpotregeneration", + "regeneratecloudpotion": "lingerpotregeneration", + "regencloudpotion": "lingerpotregeneration", + "cloudpotregeneration": "lingerpotregeneration", + "cloudpotregenerate": "lingerpotregeneration", + "cloudpotregen": "lingerpotregeneration", + "regenerationcloudpot": "lingerpotregeneration", + "regeneratecloudpot": "lingerpotregeneration", + "regencloudpot": "lingerpotregeneration", + "arrowregeneration": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": false + } + }, + "arrowregenerate": "arrowregeneration", + "arrowregen": "arrowregeneration", + "regenerationarrow": "arrowregeneration", + "regeneratearrow": "arrowregeneration", + "regenarrow": "arrowregeneration", + "regenerationiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_regeneration", + "bukkitType": "regeneration", + "isStrong": true, + "isLong": false + } + }, + "regenerationstrongpotion": "regenerationiipotion", + "regenerationleveliipotion": "regenerationiipotion", + "regenerateiipotion": "regenerationiipotion", + "regeneratestrongpotion": "regenerationiipotion", + "regenerateleveliipotion": "regenerationiipotion", + "regeniipotion": "regenerationiipotion", + "regenstrongpotion": "regenerationiipotion", + "regenleveliipotion": "regenerationiipotion", + "regenerationiipot": "regenerationiipotion", + "regenerationstrongpot": "regenerationiipotion", + "regenerationleveliipot": "regenerationiipotion", + "regenerateiipot": "regenerationiipotion", + "regeneratestrongpot": "regenerationiipotion", + "regenerateleveliipot": "regenerationiipotion", + "regeniipot": "regenerationiipotion", + "regenstrongpot": "regenerationiipotion", + "regenleveliipot": "regenerationiipotion", + "potionofregenerationii": "regenerationiipotion", + "potionofregenerationstrong": "regenerationiipotion", + "potionofregenerationlevelii": "regenerationiipotion", + "potionofregenerateii": "regenerationiipotion", + "potionofregeneratestrong": "regenerationiipotion", + "potionofregeneratelevelii": "regenerationiipotion", + "potionofregenii": "regenerationiipotion", + "potionofregenstrong": "regenerationiipotion", + "potionofregenlevelii": "regenerationiipotion", + "potofregenerationii": "regenerationiipotion", + "potofregenerationstrong": "regenerationiipotion", + "potofregenerationlevelii": "regenerationiipotion", + "potofregenerateii": "regenerationiipotion", + "potofregeneratestrong": "regenerationiipotion", + "potofregeneratelevelii": "regenerationiipotion", + "potofregenii": "regenerationiipotion", + "potofregenstrong": "regenerationiipotion", + "potofregenlevelii": "regenerationiipotion", + "splashregenerationiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_regeneration", + "bukkitType": "regeneration", + "isStrong": true, + "isLong": false + } + }, + "splashregenerationstrongpotion": "splashregenerationiipotion", + "splashregenerationleveliipotion": "splashregenerationiipotion", + "splashregenerateiipotion": "splashregenerationiipotion", + "splashregeneratestrongpotion": "splashregenerationiipotion", + "splashregenerateleveliipotion": "splashregenerationiipotion", + "splashregeniipotion": "splashregenerationiipotion", + "splashregenstrongpotion": "splashregenerationiipotion", + "splashregenleveliipotion": "splashregenerationiipotion", + "splregenerationiipotion": "splashregenerationiipotion", + "splregenerationstrongpotion": "splashregenerationiipotion", + "splregenerationleveliipotion": "splashregenerationiipotion", + "splregenerateiipotion": "splashregenerationiipotion", + "splregeneratestrongpotion": "splashregenerationiipotion", + "splregenerateleveliipotion": "splashregenerationiipotion", + "splregeniipotion": "splashregenerationiipotion", + "splregenstrongpotion": "splashregenerationiipotion", + "splregenleveliipotion": "splashregenerationiipotion", + "regenerationiisplashpotion": "splashregenerationiipotion", + "regenerationstrongsplashpotion": "splashregenerationiipotion", + "regenerationleveliisplashpotion": "splashregenerationiipotion", + "regenerateiisplashpotion": "splashregenerationiipotion", + "regeneratestrongsplashpotion": "splashregenerationiipotion", + "regenerateleveliisplashpotion": "splashregenerationiipotion", + "regeniisplashpotion": "splashregenerationiipotion", + "regenstrongsplashpotion": "splashregenerationiipotion", + "regenleveliisplashpotion": "splashregenerationiipotion", + "splashregenerationiipot": "splashregenerationiipotion", + "splashregenerationstrongpot": "splashregenerationiipotion", + "splashregenerationleveliipot": "splashregenerationiipotion", + "splashregenerateiipot": "splashregenerationiipotion", + "splashregeneratestrongpot": "splashregenerationiipotion", + "splashregenerateleveliipot": "splashregenerationiipotion", + "splashregeniipot": "splashregenerationiipotion", + "splashregenstrongpot": "splashregenerationiipotion", + "splashregenleveliipot": "splashregenerationiipotion", + "splregenerationiipot": "splashregenerationiipotion", + "splregenerationstrongpot": "splashregenerationiipotion", + "splregenerationleveliipot": "splashregenerationiipotion", + "splregenerateiipot": "splashregenerationiipotion", + "splregeneratestrongpot": "splashregenerationiipotion", + "splregenerateleveliipot": "splashregenerationiipotion", + "splregeniipot": "splashregenerationiipotion", + "splregenstrongpot": "splashregenerationiipotion", + "splregenleveliipot": "splashregenerationiipotion", + "regenerationiisplashpot": "splashregenerationiipotion", + "regenerationstrongsplashpot": "splashregenerationiipotion", + "regenerationleveliisplashpot": "splashregenerationiipotion", + "regenerateiisplashpot": "splashregenerationiipotion", + "regeneratestrongsplashpot": "splashregenerationiipotion", + "regenerateleveliisplashpot": "splashregenerationiipotion", + "regeniisplashpot": "splashregenerationiipotion", + "regenstrongsplashpot": "splashregenerationiipotion", + "regenleveliisplashpot": "splashregenerationiipotion", + "lingerpotregenerationii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_regeneration", + "bukkitType": "regeneration", + "isStrong": true, + "isLong": false + } + }, + "lingerpotregenerationstrong": "lingerpotregenerationii", + "lingerpotregenerationlevelii": "lingerpotregenerationii", + "lingerpotregenerateii": "lingerpotregenerationii", + "lingerpotregeneratestrong": "lingerpotregenerationii", + "lingerpotregeneratelevelii": "lingerpotregenerationii", + "lingerpotregenii": "lingerpotregenerationii", + "lingerpotregenstrong": "lingerpotregenerationii", + "lingerpotregenlevelii": "lingerpotregenerationii", + "regenerationlingerpotii": "lingerpotregenerationii", + "regenerationlingerpotstrong": "lingerpotregenerationii", + "regenerationlingerpotlevelii": "lingerpotregenerationii", + "regeneratelingerpotii": "lingerpotregenerationii", + "regeneratelingerpotstrong": "lingerpotregenerationii", + "regeneratelingerpotlevelii": "lingerpotregenerationii", + "regenlingerpotii": "lingerpotregenerationii", + "regenlingerpotstrong": "lingerpotregenerationii", + "regenlingerpotlevelii": "lingerpotregenerationii", + "aoepotionregenerationii": "lingerpotregenerationii", + "aoepotionregenerationstrong": "lingerpotregenerationii", + "aoepotionregenerationlevelii": "lingerpotregenerationii", + "aoepotionregenerateii": "lingerpotregenerationii", + "aoepotionregeneratestrong": "lingerpotregenerationii", + "aoepotionregeneratelevelii": "lingerpotregenerationii", + "aoepotionregenii": "lingerpotregenerationii", + "aoepotionregenstrong": "lingerpotregenerationii", + "aoepotionregenlevelii": "lingerpotregenerationii", + "regenerationaoepoiontii": "lingerpotregenerationii", + "regenerationaoepoiontstrong": "lingerpotregenerationii", + "regenerationaoepoiontlevelii": "lingerpotregenerationii", + "regenerateaoepoiontii": "lingerpotregenerationii", + "regenerateaoepoiontstrong": "lingerpotregenerationii", + "regenerateaoepoiontlevelii": "lingerpotregenerationii", + "regenaoepoiontii": "lingerpotregenerationii", + "regenaoepoiontstrong": "lingerpotregenerationii", + "regenaoepoiontlevelii": "lingerpotregenerationii", + "aoepotregenerationii": "lingerpotregenerationii", + "aoepotregenerationstrong": "lingerpotregenerationii", + "aoepotregenerationlevelii": "lingerpotregenerationii", + "aoepotregenerateii": "lingerpotregenerationii", + "aoepotregeneratestrong": "lingerpotregenerationii", + "aoepotregeneratelevelii": "lingerpotregenerationii", + "aoepotregenii": "lingerpotregenerationii", + "aoepotregenstrong": "lingerpotregenerationii", + "aoepotregenlevelii": "lingerpotregenerationii", + "regenerationaoepotii": "lingerpotregenerationii", + "regenerationaoepotstrong": "lingerpotregenerationii", + "regenerationaoepotlevelii": "lingerpotregenerationii", + "regenerateaoepotii": "lingerpotregenerationii", + "regenerateaoepotstrong": "lingerpotregenerationii", + "regenerateaoepotlevelii": "lingerpotregenerationii", + "regenaoepotii": "lingerpotregenerationii", + "regenaoepotstrong": "lingerpotregenerationii", + "regenaoepotlevelii": "lingerpotregenerationii", + "areapotionregenerationii": "lingerpotregenerationii", + "areapotionregenerationstrong": "lingerpotregenerationii", + "areapotionregenerationlevelii": "lingerpotregenerationii", + "areapotionregenerateii": "lingerpotregenerationii", + "areapotionregeneratestrong": "lingerpotregenerationii", + "areapotionregeneratelevelii": "lingerpotregenerationii", + "areapotionregenii": "lingerpotregenerationii", + "areapotionregenstrong": "lingerpotregenerationii", + "areapotionregenlevelii": "lingerpotregenerationii", + "regenerationareapotionii": "lingerpotregenerationii", + "regenerationareapotionstrong": "lingerpotregenerationii", + "regenerationareapotionlevelii": "lingerpotregenerationii", + "regenerateareapotionii": "lingerpotregenerationii", + "regenerateareapotionstrong": "lingerpotregenerationii", + "regenerateareapotionlevelii": "lingerpotregenerationii", + "regenareapotionii": "lingerpotregenerationii", + "regenareapotionstrong": "lingerpotregenerationii", + "regenareapotionlevelii": "lingerpotregenerationii", + "areapotregenerationii": "lingerpotregenerationii", + "areapotregenerationstrong": "lingerpotregenerationii", + "areapotregenerationlevelii": "lingerpotregenerationii", + "areapotregenerateii": "lingerpotregenerationii", + "areapotregeneratestrong": "lingerpotregenerationii", + "areapotregeneratelevelii": "lingerpotregenerationii", + "areapotregenii": "lingerpotregenerationii", + "areapotregenstrong": "lingerpotregenerationii", + "areapotregenlevelii": "lingerpotregenerationii", + "regenerationareapotii": "lingerpotregenerationii", + "regenerationareapotstrong": "lingerpotregenerationii", + "regenerationareapotlevelii": "lingerpotregenerationii", + "regenerateareapotii": "lingerpotregenerationii", + "regenerateareapotstrong": "lingerpotregenerationii", + "regenerateareapotlevelii": "lingerpotregenerationii", + "regenareapotii": "lingerpotregenerationii", + "regenareapotstrong": "lingerpotregenerationii", + "regenareapotlevelii": "lingerpotregenerationii", + "cloudpotionregenerationii": "lingerpotregenerationii", + "cloudpotionregenerationstrong": "lingerpotregenerationii", + "cloudpotionregenerationlevelii": "lingerpotregenerationii", + "cloudpotionregenerateii": "lingerpotregenerationii", + "cloudpotionregeneratestrong": "lingerpotregenerationii", + "cloudpotionregeneratelevelii": "lingerpotregenerationii", + "cloudpotionregenii": "lingerpotregenerationii", + "cloudpotionregenstrong": "lingerpotregenerationii", + "cloudpotionregenlevelii": "lingerpotregenerationii", + "regenerationcloudpotionii": "lingerpotregenerationii", + "regenerationcloudpotionstrong": "lingerpotregenerationii", + "regenerationcloudpotionlevelii": "lingerpotregenerationii", + "regeneratecloudpotionii": "lingerpotregenerationii", + "regeneratecloudpotionstrong": "lingerpotregenerationii", + "regeneratecloudpotionlevelii": "lingerpotregenerationii", + "regencloudpotionii": "lingerpotregenerationii", + "regencloudpotionstrong": "lingerpotregenerationii", + "regencloudpotionlevelii": "lingerpotregenerationii", + "cloudpotregenerationii": "lingerpotregenerationii", + "cloudpotregenerationstrong": "lingerpotregenerationii", + "cloudpotregenerationlevelii": "lingerpotregenerationii", + "cloudpotregenerateii": "lingerpotregenerationii", + "cloudpotregeneratestrong": "lingerpotregenerationii", + "cloudpotregeneratelevelii": "lingerpotregenerationii", + "cloudpotregenii": "lingerpotregenerationii", + "cloudpotregenstrong": "lingerpotregenerationii", + "cloudpotregenlevelii": "lingerpotregenerationii", + "regenerationcloudpotii": "lingerpotregenerationii", + "regenerationcloudpotstrong": "lingerpotregenerationii", + "regenerationcloudpotlevelii": "lingerpotregenerationii", + "regeneratecloudpotii": "lingerpotregenerationii", + "regeneratecloudpotstrong": "lingerpotregenerationii", + "regeneratecloudpotlevelii": "lingerpotregenerationii", + "regencloudpotii": "lingerpotregenerationii", + "regencloudpotstrong": "lingerpotregenerationii", + "regencloudpotlevelii": "lingerpotregenerationii", + "arrowregenerationii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_regeneration", + "bukkitType": "regeneration", + "isStrong": true, + "isLong": false + } + }, + "arrowregenerationstrong": "arrowregenerationii", + "arrowregenerationlevelii": "arrowregenerationii", + "arrowregenerateii": "arrowregenerationii", + "arrowregeneratestrong": "arrowregenerationii", + "arrowregeneratelevelii": "arrowregenerationii", + "arrowregenii": "arrowregenerationii", + "arrowregenstrong": "arrowregenerationii", + "arrowregenlevelii": "arrowregenerationii", + "regenerationarrowii": "arrowregenerationii", + "regenerationarrowstrong": "arrowregenerationii", + "regenerationarrowlevelii": "arrowregenerationii", + "regeneratearrowii": "arrowregenerationii", + "regeneratearrowstrong": "arrowregenerationii", + "regeneratearrowlevelii": "arrowregenerationii", + "regenarrowii": "arrowregenerationii", + "regenarrowstrong": "arrowregenerationii", + "regenarrowlevelii": "arrowregenerationii", + "regeneration2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": true + } + }, + "regenerationlongpotion": "regeneration2potion", + "regenerationextendedpotion": "regeneration2potion", + "regenerationexpotion": "regeneration2potion", + "regenerationlevel2potion": "regeneration2potion", + "regenerate2potion": "regeneration2potion", + "regeneratelongpotion": "regeneration2potion", + "regenerateextendedpotion": "regeneration2potion", + "regenerateexpotion": "regeneration2potion", + "regeneratelevel2potion": "regeneration2potion", + "regen2potion": "regeneration2potion", + "regenlongpotion": "regeneration2potion", + "regenextendedpotion": "regeneration2potion", + "regenexpotion": "regeneration2potion", + "regenlevel2potion": "regeneration2potion", + "regeneration2pot": "regeneration2potion", + "regenerationlongpot": "regeneration2potion", + "regenerationextendedpot": "regeneration2potion", + "regenerationexpot": "regeneration2potion", + "regenerationlevel2pot": "regeneration2potion", + "regenerate2pot": "regeneration2potion", + "regeneratelongpot": "regeneration2potion", + "regenerateextendedpot": "regeneration2potion", + "regenerateexpot": "regeneration2potion", + "regeneratelevel2pot": "regeneration2potion", + "regen2pot": "regeneration2potion", + "regenlongpot": "regeneration2potion", + "regenextendedpot": "regeneration2potion", + "regenexpot": "regeneration2potion", + "regenlevel2pot": "regeneration2potion", + "potionofregeneration2": "regeneration2potion", + "potionofregenerationlong": "regeneration2potion", + "potionofregenerationextended": "regeneration2potion", + "potionofregenerationex": "regeneration2potion", + "potionofregenerationlevel2": "regeneration2potion", + "potionofregenerate2": "regeneration2potion", + "potionofregeneratelong": "regeneration2potion", + "potionofregenerateextended": "regeneration2potion", + "potionofregenerateex": "regeneration2potion", + "potionofregeneratelevel2": "regeneration2potion", + "potionofregen2": "regeneration2potion", + "potionofregenlong": "regeneration2potion", + "potionofregenextended": "regeneration2potion", + "potionofregenex": "regeneration2potion", + "potionofregenlevel2": "regeneration2potion", + "potofregeneration2": "regeneration2potion", + "potofregenerationlong": "regeneration2potion", + "potofregenerationextended": "regeneration2potion", + "potofregenerationex": "regeneration2potion", + "potofregenerationlevel2": "regeneration2potion", + "potofregenerate2": "regeneration2potion", + "potofregeneratelong": "regeneration2potion", + "potofregenerateextended": "regeneration2potion", + "potofregenerateex": "regeneration2potion", + "potofregeneratelevel2": "regeneration2potion", + "potofregen2": "regeneration2potion", + "potofregenlong": "regeneration2potion", + "potofregenextended": "regeneration2potion", + "potofregenex": "regeneration2potion", + "potofregenlevel2": "regeneration2potion", + "splashregeneration2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": true + } + }, + "splashregenerationlongpotion": "splashregeneration2potion", + "splashregenerationextendedpotion": "splashregeneration2potion", + "splashregenerationexpotion": "splashregeneration2potion", + "splashregenerationlevel2potion": "splashregeneration2potion", + "splashregenerate2potion": "splashregeneration2potion", + "splashregeneratelongpotion": "splashregeneration2potion", + "splashregenerateextendedpotion": "splashregeneration2potion", + "splashregenerateexpotion": "splashregeneration2potion", + "splashregeneratelevel2potion": "splashregeneration2potion", + "splashregen2potion": "splashregeneration2potion", + "splashregenlongpotion": "splashregeneration2potion", + "splashregenextendedpotion": "splashregeneration2potion", + "splashregenexpotion": "splashregeneration2potion", + "splashregenlevel2potion": "splashregeneration2potion", + "splregeneration2potion": "splashregeneration2potion", + "splregenerationlongpotion": "splashregeneration2potion", + "splregenerationextendedpotion": "splashregeneration2potion", + "splregenerationexpotion": "splashregeneration2potion", + "splregenerationlevel2potion": "splashregeneration2potion", + "splregenerate2potion": "splashregeneration2potion", + "splregeneratelongpotion": "splashregeneration2potion", + "splregenerateextendedpotion": "splashregeneration2potion", + "splregenerateexpotion": "splashregeneration2potion", + "splregeneratelevel2potion": "splashregeneration2potion", + "splregen2potion": "splashregeneration2potion", + "splregenlongpotion": "splashregeneration2potion", + "splregenextendedpotion": "splashregeneration2potion", + "splregenexpotion": "splashregeneration2potion", + "splregenlevel2potion": "splashregeneration2potion", + "regeneration2splashpotion": "splashregeneration2potion", + "regenerationlongsplashpotion": "splashregeneration2potion", + "regenerationextendedsplashpotion": "splashregeneration2potion", + "regenerationexsplashpotion": "splashregeneration2potion", + "regenerationlevel2splashpotion": "splashregeneration2potion", + "regenerate2splashpotion": "splashregeneration2potion", + "regeneratelongsplashpotion": "splashregeneration2potion", + "regenerateextendedsplashpotion": "splashregeneration2potion", + "regenerateexsplashpotion": "splashregeneration2potion", + "regeneratelevel2splashpotion": "splashregeneration2potion", + "regen2splashpotion": "splashregeneration2potion", + "regenlongsplashpotion": "splashregeneration2potion", + "regenextendedsplashpotion": "splashregeneration2potion", + "regenexsplashpotion": "splashregeneration2potion", + "regenlevel2splashpotion": "splashregeneration2potion", + "splashregeneration2pot": "splashregeneration2potion", + "splashregenerationlongpot": "splashregeneration2potion", + "splashregenerationextendedpot": "splashregeneration2potion", + "splashregenerationexpot": "splashregeneration2potion", + "splashregenerationlevel2pot": "splashregeneration2potion", + "splashregenerate2pot": "splashregeneration2potion", + "splashregeneratelongpot": "splashregeneration2potion", + "splashregenerateextendedpot": "splashregeneration2potion", + "splashregenerateexpot": "splashregeneration2potion", + "splashregeneratelevel2pot": "splashregeneration2potion", + "splashregen2pot": "splashregeneration2potion", + "splashregenlongpot": "splashregeneration2potion", + "splashregenextendedpot": "splashregeneration2potion", + "splashregenexpot": "splashregeneration2potion", + "splashregenlevel2pot": "splashregeneration2potion", + "splregeneration2pot": "splashregeneration2potion", + "splregenerationlongpot": "splashregeneration2potion", + "splregenerationextendedpot": "splashregeneration2potion", + "splregenerationexpot": "splashregeneration2potion", + "splregenerationlevel2pot": "splashregeneration2potion", + "splregenerate2pot": "splashregeneration2potion", + "splregeneratelongpot": "splashregeneration2potion", + "splregenerateextendedpot": "splashregeneration2potion", + "splregenerateexpot": "splashregeneration2potion", + "splregeneratelevel2pot": "splashregeneration2potion", + "splregen2pot": "splashregeneration2potion", + "splregenlongpot": "splashregeneration2potion", + "splregenextendedpot": "splashregeneration2potion", + "splregenexpot": "splashregeneration2potion", + "splregenlevel2pot": "splashregeneration2potion", + "regeneration2splashpot": "splashregeneration2potion", + "regenerationlongsplashpot": "splashregeneration2potion", + "regenerationextendedsplashpot": "splashregeneration2potion", + "regenerationexsplashpot": "splashregeneration2potion", + "regenerationlevel2splashpot": "splashregeneration2potion", + "regenerate2splashpot": "splashregeneration2potion", + "regeneratelongsplashpot": "splashregeneration2potion", + "regenerateextendedsplashpot": "splashregeneration2potion", + "regenerateexsplashpot": "splashregeneration2potion", + "regeneratelevel2splashpot": "splashregeneration2potion", + "regen2splashpot": "splashregeneration2potion", + "regenlongsplashpot": "splashregeneration2potion", + "regenextendedsplashpot": "splashregeneration2potion", + "regenexsplashpot": "splashregeneration2potion", + "regenlevel2splashpot": "splashregeneration2potion", + "lingerpotregeneration2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": true + } + }, + "lingerpotregenerationlong": "lingerpotregeneration2", + "lingerpotregenerationextended": "lingerpotregeneration2", + "lingerpotregenerationex": "lingerpotregeneration2", + "lingerpotregenerationlevel2": "lingerpotregeneration2", + "lingerpotregenerate2": "lingerpotregeneration2", + "lingerpotregeneratelong": "lingerpotregeneration2", + "lingerpotregenerateextended": "lingerpotregeneration2", + "lingerpotregenerateex": "lingerpotregeneration2", + "lingerpotregeneratelevel2": "lingerpotregeneration2", + "lingerpotregen2": "lingerpotregeneration2", + "lingerpotregenlong": "lingerpotregeneration2", + "lingerpotregenextended": "lingerpotregeneration2", + "lingerpotregenex": "lingerpotregeneration2", + "lingerpotregenlevel2": "lingerpotregeneration2", + "regenerationlingerpot2": "lingerpotregeneration2", + "regenerationlingerpotlong": "lingerpotregeneration2", + "regenerationlingerpotextended": "lingerpotregeneration2", + "regenerationlingerpotex": "lingerpotregeneration2", + "regenerationlingerpotlevel2": "lingerpotregeneration2", + "regeneratelingerpot2": "lingerpotregeneration2", + "regeneratelingerpotlong": "lingerpotregeneration2", + "regeneratelingerpotextended": "lingerpotregeneration2", + "regeneratelingerpotex": "lingerpotregeneration2", + "regeneratelingerpotlevel2": "lingerpotregeneration2", + "regenlingerpot2": "lingerpotregeneration2", + "regenlingerpotlong": "lingerpotregeneration2", + "regenlingerpotextended": "lingerpotregeneration2", + "regenlingerpotex": "lingerpotregeneration2", + "regenlingerpotlevel2": "lingerpotregeneration2", + "aoepotionregeneration2": "lingerpotregeneration2", + "aoepotionregenerationlong": "lingerpotregeneration2", + "aoepotionregenerationextended": "lingerpotregeneration2", + "aoepotionregenerationex": "lingerpotregeneration2", + "aoepotionregenerationlevel2": "lingerpotregeneration2", + "aoepotionregenerate2": "lingerpotregeneration2", + "aoepotionregeneratelong": "lingerpotregeneration2", + "aoepotionregenerateextended": "lingerpotregeneration2", + "aoepotionregenerateex": "lingerpotregeneration2", + "aoepotionregeneratelevel2": "lingerpotregeneration2", + "aoepotionregen2": "lingerpotregeneration2", + "aoepotionregenlong": "lingerpotregeneration2", + "aoepotionregenextended": "lingerpotregeneration2", + "aoepotionregenex": "lingerpotregeneration2", + "aoepotionregenlevel2": "lingerpotregeneration2", + "regenerationaoepoiont2": "lingerpotregeneration2", + "regenerationaoepoiontlong": "lingerpotregeneration2", + "regenerationaoepoiontextended": "lingerpotregeneration2", + "regenerationaoepoiontex": "lingerpotregeneration2", + "regenerationaoepoiontlevel2": "lingerpotregeneration2", + "regenerateaoepoiont2": "lingerpotregeneration2", + "regenerateaoepoiontlong": "lingerpotregeneration2", + "regenerateaoepoiontextended": "lingerpotregeneration2", + "regenerateaoepoiontex": "lingerpotregeneration2", + "regenerateaoepoiontlevel2": "lingerpotregeneration2", + "regenaoepoiont2": "lingerpotregeneration2", + "regenaoepoiontlong": "lingerpotregeneration2", + "regenaoepoiontextended": "lingerpotregeneration2", + "regenaoepoiontex": "lingerpotregeneration2", + "regenaoepoiontlevel2": "lingerpotregeneration2", + "aoepotregeneration2": "lingerpotregeneration2", + "aoepotregenerationlong": "lingerpotregeneration2", + "aoepotregenerationextended": "lingerpotregeneration2", + "aoepotregenerationex": "lingerpotregeneration2", + "aoepotregenerationlevel2": "lingerpotregeneration2", + "aoepotregenerate2": "lingerpotregeneration2", + "aoepotregeneratelong": "lingerpotregeneration2", + "aoepotregenerateextended": "lingerpotregeneration2", + "aoepotregenerateex": "lingerpotregeneration2", + "aoepotregeneratelevel2": "lingerpotregeneration2", + "aoepotregen2": "lingerpotregeneration2", + "aoepotregenlong": "lingerpotregeneration2", + "aoepotregenextended": "lingerpotregeneration2", + "aoepotregenex": "lingerpotregeneration2", + "aoepotregenlevel2": "lingerpotregeneration2", + "regenerationaoepot2": "lingerpotregeneration2", + "regenerationaoepotlong": "lingerpotregeneration2", + "regenerationaoepotextended": "lingerpotregeneration2", + "regenerationaoepotex": "lingerpotregeneration2", + "regenerationaoepotlevel2": "lingerpotregeneration2", + "regenerateaoepot2": "lingerpotregeneration2", + "regenerateaoepotlong": "lingerpotregeneration2", + "regenerateaoepotextended": "lingerpotregeneration2", + "regenerateaoepotex": "lingerpotregeneration2", + "regenerateaoepotlevel2": "lingerpotregeneration2", + "regenaoepot2": "lingerpotregeneration2", + "regenaoepotlong": "lingerpotregeneration2", + "regenaoepotextended": "lingerpotregeneration2", + "regenaoepotex": "lingerpotregeneration2", + "regenaoepotlevel2": "lingerpotregeneration2", + "areapotionregeneration2": "lingerpotregeneration2", + "areapotionregenerationlong": "lingerpotregeneration2", + "areapotionregenerationextended": "lingerpotregeneration2", + "areapotionregenerationex": "lingerpotregeneration2", + "areapotionregenerationlevel2": "lingerpotregeneration2", + "areapotionregenerate2": "lingerpotregeneration2", + "areapotionregeneratelong": "lingerpotregeneration2", + "areapotionregenerateextended": "lingerpotregeneration2", + "areapotionregenerateex": "lingerpotregeneration2", + "areapotionregeneratelevel2": "lingerpotregeneration2", + "areapotionregen2": "lingerpotregeneration2", + "areapotionregenlong": "lingerpotregeneration2", + "areapotionregenextended": "lingerpotregeneration2", + "areapotionregenex": "lingerpotregeneration2", + "areapotionregenlevel2": "lingerpotregeneration2", + "regenerationareapotion2": "lingerpotregeneration2", + "regenerationareapotionlong": "lingerpotregeneration2", + "regenerationareapotionextended": "lingerpotregeneration2", + "regenerationareapotionex": "lingerpotregeneration2", + "regenerationareapotionlevel2": "lingerpotregeneration2", + "regenerateareapotion2": "lingerpotregeneration2", + "regenerateareapotionlong": "lingerpotregeneration2", + "regenerateareapotionextended": "lingerpotregeneration2", + "regenerateareapotionex": "lingerpotregeneration2", + "regenerateareapotionlevel2": "lingerpotregeneration2", + "regenareapotion2": "lingerpotregeneration2", + "regenareapotionlong": "lingerpotregeneration2", + "regenareapotionextended": "lingerpotregeneration2", + "regenareapotionex": "lingerpotregeneration2", + "regenareapotionlevel2": "lingerpotregeneration2", + "areapotregeneration2": "lingerpotregeneration2", + "areapotregenerationlong": "lingerpotregeneration2", + "areapotregenerationextended": "lingerpotregeneration2", + "areapotregenerationex": "lingerpotregeneration2", + "areapotregenerationlevel2": "lingerpotregeneration2", + "areapotregenerate2": "lingerpotregeneration2", + "areapotregeneratelong": "lingerpotregeneration2", + "areapotregenerateextended": "lingerpotregeneration2", + "areapotregenerateex": "lingerpotregeneration2", + "areapotregeneratelevel2": "lingerpotregeneration2", + "areapotregen2": "lingerpotregeneration2", + "areapotregenlong": "lingerpotregeneration2", + "areapotregenextended": "lingerpotregeneration2", + "areapotregenex": "lingerpotregeneration2", + "areapotregenlevel2": "lingerpotregeneration2", + "regenerationareapot2": "lingerpotregeneration2", + "regenerationareapotlong": "lingerpotregeneration2", + "regenerationareapotextended": "lingerpotregeneration2", + "regenerationareapotex": "lingerpotregeneration2", + "regenerationareapotlevel2": "lingerpotregeneration2", + "regenerateareapot2": "lingerpotregeneration2", + "regenerateareapotlong": "lingerpotregeneration2", + "regenerateareapotextended": "lingerpotregeneration2", + "regenerateareapotex": "lingerpotregeneration2", + "regenerateareapotlevel2": "lingerpotregeneration2", + "regenareapot2": "lingerpotregeneration2", + "regenareapotlong": "lingerpotregeneration2", + "regenareapotextended": "lingerpotregeneration2", + "regenareapotex": "lingerpotregeneration2", + "regenareapotlevel2": "lingerpotregeneration2", + "cloudpotionregeneration2": "lingerpotregeneration2", + "cloudpotionregenerationlong": "lingerpotregeneration2", + "cloudpotionregenerationextended": "lingerpotregeneration2", + "cloudpotionregenerationex": "lingerpotregeneration2", + "cloudpotionregenerationlevel2": "lingerpotregeneration2", + "cloudpotionregenerate2": "lingerpotregeneration2", + "cloudpotionregeneratelong": "lingerpotregeneration2", + "cloudpotionregenerateextended": "lingerpotregeneration2", + "cloudpotionregenerateex": "lingerpotregeneration2", + "cloudpotionregeneratelevel2": "lingerpotregeneration2", + "cloudpotionregen2": "lingerpotregeneration2", + "cloudpotionregenlong": "lingerpotregeneration2", + "cloudpotionregenextended": "lingerpotregeneration2", + "cloudpotionregenex": "lingerpotregeneration2", + "cloudpotionregenlevel2": "lingerpotregeneration2", + "regenerationcloudpotion2": "lingerpotregeneration2", + "regenerationcloudpotionlong": "lingerpotregeneration2", + "regenerationcloudpotionextended": "lingerpotregeneration2", + "regenerationcloudpotionex": "lingerpotregeneration2", + "regenerationcloudpotionlevel2": "lingerpotregeneration2", + "regeneratecloudpotion2": "lingerpotregeneration2", + "regeneratecloudpotionlong": "lingerpotregeneration2", + "regeneratecloudpotionextended": "lingerpotregeneration2", + "regeneratecloudpotionex": "lingerpotregeneration2", + "regeneratecloudpotionlevel2": "lingerpotregeneration2", + "regencloudpotion2": "lingerpotregeneration2", + "regencloudpotionlong": "lingerpotregeneration2", + "regencloudpotionextended": "lingerpotregeneration2", + "regencloudpotionex": "lingerpotregeneration2", + "regencloudpotionlevel2": "lingerpotregeneration2", + "cloudpotregeneration2": "lingerpotregeneration2", + "cloudpotregenerationlong": "lingerpotregeneration2", + "cloudpotregenerationextended": "lingerpotregeneration2", + "cloudpotregenerationex": "lingerpotregeneration2", + "cloudpotregenerationlevel2": "lingerpotregeneration2", + "cloudpotregenerate2": "lingerpotregeneration2", + "cloudpotregeneratelong": "lingerpotregeneration2", + "cloudpotregenerateextended": "lingerpotregeneration2", + "cloudpotregenerateex": "lingerpotregeneration2", + "cloudpotregeneratelevel2": "lingerpotregeneration2", + "cloudpotregen2": "lingerpotregeneration2", + "cloudpotregenlong": "lingerpotregeneration2", + "cloudpotregenextended": "lingerpotregeneration2", + "cloudpotregenex": "lingerpotregeneration2", + "cloudpotregenlevel2": "lingerpotregeneration2", + "regenerationcloudpot2": "lingerpotregeneration2", + "regenerationcloudpotlong": "lingerpotregeneration2", + "regenerationcloudpotextended": "lingerpotregeneration2", + "regenerationcloudpotex": "lingerpotregeneration2", + "regenerationcloudpotlevel2": "lingerpotregeneration2", + "regeneratecloudpot2": "lingerpotregeneration2", + "regeneratecloudpotlong": "lingerpotregeneration2", + "regeneratecloudpotextended": "lingerpotregeneration2", + "regeneratecloudpotex": "lingerpotregeneration2", + "regeneratecloudpotlevel2": "lingerpotregeneration2", + "regencloudpot2": "lingerpotregeneration2", + "regencloudpotlong": "lingerpotregeneration2", + "regencloudpotextended": "lingerpotregeneration2", + "regencloudpotex": "lingerpotregeneration2", + "regencloudpotlevel2": "lingerpotregeneration2", + "arrowregeneration2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_regeneration", + "bukkitType": "regeneration", + "isStrong": false, + "isLong": true + } + }, + "arrowregenerationlong": "arrowregeneration2", + "arrowregenerationextended": "arrowregeneration2", + "arrowregenerationex": "arrowregeneration2", + "arrowregenerationlevel2": "arrowregeneration2", + "arrowregenerate2": "arrowregeneration2", + "arrowregeneratelong": "arrowregeneration2", + "arrowregenerateextended": "arrowregeneration2", + "arrowregenerateex": "arrowregeneration2", + "arrowregeneratelevel2": "arrowregeneration2", + "arrowregen2": "arrowregeneration2", + "arrowregenlong": "arrowregeneration2", + "arrowregenextended": "arrowregeneration2", + "arrowregenex": "arrowregeneration2", + "arrowregenlevel2": "arrowregeneration2", + "regenerationarrow2": "arrowregeneration2", + "regenerationarrowlong": "arrowregeneration2", + "regenerationarrowextended": "arrowregeneration2", + "regenerationarrowex": "arrowregeneration2", + "regenerationarrowlevel2": "arrowregeneration2", + "regeneratearrow2": "arrowregeneration2", + "regeneratearrowlong": "arrowregeneration2", + "regeneratearrowextended": "arrowregeneration2", + "regeneratearrowex": "arrowregeneration2", + "regeneratearrowlevel2": "arrowregeneration2", + "regenarrow2": "arrowregeneration2", + "regenarrowlong": "arrowregeneration2", + "regenarrowextended": "arrowregeneration2", + "regenarrowex": "arrowregeneration2", + "regenarrowlevel2": "arrowregeneration2", + "strengthpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": false + } + }, + "strongpotion": "strengthpotion", + "strpotion": "strengthpotion", + "strengthpot": "strengthpotion", + "strongpot": "strengthpotion", + "strpot": "strengthpotion", + "potionofstrength": "strengthpotion", + "potionofstrong": "strengthpotion", + "potionofstr": "strengthpotion", + "potofstrength": "strengthpotion", + "potofstrong": "strengthpotion", + "potofstr": "strengthpotion", + "splashstrengthpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": false + } + }, + "splashstrongpotion": "splashstrengthpotion", + "splashstrpotion": "splashstrengthpotion", + "splstrengthpotion": "splashstrengthpotion", + "splstrongpotion": "splashstrengthpotion", + "splstrpotion": "splashstrengthpotion", + "strengthsplashpotion": "splashstrengthpotion", + "strongsplashpotion": "splashstrengthpotion", + "strsplashpotion": "splashstrengthpotion", + "splashstrengthpot": "splashstrengthpotion", + "splashstrongpot": "splashstrengthpotion", + "splashstrpot": "splashstrengthpotion", + "splstrengthpot": "splashstrengthpotion", + "splstrongpot": "splashstrengthpotion", + "splstrpot": "splashstrengthpotion", + "strengthsplashpot": "splashstrengthpotion", + "strongsplashpot": "splashstrengthpotion", + "strsplashpot": "splashstrengthpotion", + "lingerpotstrength": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": false + } + }, + "lingerpotstrong": "lingerpotstrength", + "lingerpotstr": "lingerpotstrength", + "strengthlingerpot": "lingerpotstrength", + "stronglingerpot": "lingerpotstrength", + "strlingerpot": "lingerpotstrength", + "aoepotionstrength": "lingerpotstrength", + "aoepotionstrong": "lingerpotstrength", + "aoepotionstr": "lingerpotstrength", + "strengthaoepoiont": "lingerpotstrength", + "strongaoepoiont": "lingerpotstrength", + "straoepoiont": "lingerpotstrength", + "aoepotstrength": "lingerpotstrength", + "aoepotstrong": "lingerpotstrength", + "aoepotstr": "lingerpotstrength", + "strengthaoepot": "lingerpotstrength", + "strongaoepot": "lingerpotstrength", + "straoepot": "lingerpotstrength", + "areapotionstrength": "lingerpotstrength", + "areapotionstrong": "lingerpotstrength", + "areapotionstr": "lingerpotstrength", + "strengthareapotion": "lingerpotstrength", + "strongareapotion": "lingerpotstrength", + "strareapotion": "lingerpotstrength", + "areapotstrength": "lingerpotstrength", + "areapotstrong": "lingerpotstrength", + "areapotstr": "lingerpotstrength", + "strengthareapot": "lingerpotstrength", + "strongareapot": "lingerpotstrength", + "strareapot": "lingerpotstrength", + "cloudpotionstrength": "lingerpotstrength", + "cloudpotionstrong": "lingerpotstrength", + "cloudpotionstr": "lingerpotstrength", + "strengthcloudpotion": "lingerpotstrength", + "strongcloudpotion": "lingerpotstrength", + "strcloudpotion": "lingerpotstrength", + "cloudpotstrength": "lingerpotstrength", + "cloudpotstrong": "lingerpotstrength", + "cloudpotstr": "lingerpotstrength", + "strengthcloudpot": "lingerpotstrength", + "strongcloudpot": "lingerpotstrength", + "strcloudpot": "lingerpotstrength", + "arrowstrength": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": false + } + }, + "arrowstrong": "arrowstrength", + "arrowstr": "arrowstrength", + "strengtharrow": "arrowstrength", + "strongarrow": "arrowstrength", + "strarrow": "arrowstrength", + "strengthiipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_strength", + "bukkitType": "strength", + "isStrong": true, + "isLong": false + } + }, + "strengthstrongpotion": "strengthiipotion", + "strengthleveliipotion": "strengthiipotion", + "strongiipotion": "strengthiipotion", + "strongstrongpotion": "strengthiipotion", + "strongleveliipotion": "strengthiipotion", + "striipotion": "strengthiipotion", + "strstrongpotion": "strengthiipotion", + "strleveliipotion": "strengthiipotion", + "strengthiipot": "strengthiipotion", + "strengthstrongpot": "strengthiipotion", + "strengthleveliipot": "strengthiipotion", + "strongiipot": "strengthiipotion", + "strongstrongpot": "strengthiipotion", + "strongleveliipot": "strengthiipotion", + "striipot": "strengthiipotion", + "strstrongpot": "strengthiipotion", + "strleveliipot": "strengthiipotion", + "potionofstrengthii": "strengthiipotion", + "potionofstrengthstrong": "strengthiipotion", + "potionofstrengthlevelii": "strengthiipotion", + "potionofstrongii": "strengthiipotion", + "potionofstrongstrong": "strengthiipotion", + "potionofstronglevelii": "strengthiipotion", + "potionofstrii": "strengthiipotion", + "potionofstrstrong": "strengthiipotion", + "potionofstrlevelii": "strengthiipotion", + "potofstrengthii": "strengthiipotion", + "potofstrengthstrong": "strengthiipotion", + "potofstrengthlevelii": "strengthiipotion", + "potofstrongii": "strengthiipotion", + "potofstrongstrong": "strengthiipotion", + "potofstronglevelii": "strengthiipotion", + "potofstrii": "strengthiipotion", + "potofstrstrong": "strengthiipotion", + "potofstrlevelii": "strengthiipotion", + "splashstrengthiipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_strength", + "bukkitType": "strength", + "isStrong": true, + "isLong": false + } + }, + "splashstrengthstrongpotion": "splashstrengthiipotion", + "splashstrengthleveliipotion": "splashstrengthiipotion", + "splashstrongiipotion": "splashstrengthiipotion", + "splashstrongstrongpotion": "splashstrengthiipotion", + "splashstrongleveliipotion": "splashstrengthiipotion", + "splashstriipotion": "splashstrengthiipotion", + "splashstrstrongpotion": "splashstrengthiipotion", + "splashstrleveliipotion": "splashstrengthiipotion", + "splstrengthiipotion": "splashstrengthiipotion", + "splstrengthstrongpotion": "splashstrengthiipotion", + "splstrengthleveliipotion": "splashstrengthiipotion", + "splstrongiipotion": "splashstrengthiipotion", + "splstrongstrongpotion": "splashstrengthiipotion", + "splstrongleveliipotion": "splashstrengthiipotion", + "splstriipotion": "splashstrengthiipotion", + "splstrstrongpotion": "splashstrengthiipotion", + "splstrleveliipotion": "splashstrengthiipotion", + "strengthiisplashpotion": "splashstrengthiipotion", + "strengthstrongsplashpotion": "splashstrengthiipotion", + "strengthleveliisplashpotion": "splashstrengthiipotion", + "strongiisplashpotion": "splashstrengthiipotion", + "strongstrongsplashpotion": "splashstrengthiipotion", + "strongleveliisplashpotion": "splashstrengthiipotion", + "striisplashpotion": "splashstrengthiipotion", + "strstrongsplashpotion": "splashstrengthiipotion", + "strleveliisplashpotion": "splashstrengthiipotion", + "splashstrengthiipot": "splashstrengthiipotion", + "splashstrengthstrongpot": "splashstrengthiipotion", + "splashstrengthleveliipot": "splashstrengthiipotion", + "splashstrongiipot": "splashstrengthiipotion", + "splashstrongstrongpot": "splashstrengthiipotion", + "splashstrongleveliipot": "splashstrengthiipotion", + "splashstriipot": "splashstrengthiipotion", + "splashstrstrongpot": "splashstrengthiipotion", + "splashstrleveliipot": "splashstrengthiipotion", + "splstrengthiipot": "splashstrengthiipotion", + "splstrengthstrongpot": "splashstrengthiipotion", + "splstrengthleveliipot": "splashstrengthiipotion", + "splstrongiipot": "splashstrengthiipotion", + "splstrongstrongpot": "splashstrengthiipotion", + "splstrongleveliipot": "splashstrengthiipotion", + "splstriipot": "splashstrengthiipotion", + "splstrstrongpot": "splashstrengthiipotion", + "splstrleveliipot": "splashstrengthiipotion", + "strengthiisplashpot": "splashstrengthiipotion", + "strengthstrongsplashpot": "splashstrengthiipotion", + "strengthleveliisplashpot": "splashstrengthiipotion", + "strongiisplashpot": "splashstrengthiipotion", + "strongstrongsplashpot": "splashstrengthiipotion", + "strongleveliisplashpot": "splashstrengthiipotion", + "striisplashpot": "splashstrengthiipotion", + "strstrongsplashpot": "splashstrengthiipotion", + "strleveliisplashpot": "splashstrengthiipotion", + "lingerpotstrengthii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_strength", + "bukkitType": "strength", + "isStrong": true, + "isLong": false + } + }, + "lingerpotstrengthstrong": "lingerpotstrengthii", + "lingerpotstrengthlevelii": "lingerpotstrengthii", + "lingerpotstrongii": "lingerpotstrengthii", + "lingerpotstrongstrong": "lingerpotstrengthii", + "lingerpotstronglevelii": "lingerpotstrengthii", + "lingerpotstrii": "lingerpotstrengthii", + "lingerpotstrstrong": "lingerpotstrengthii", + "lingerpotstrlevelii": "lingerpotstrengthii", + "strengthlingerpotii": "lingerpotstrengthii", + "strengthlingerpotstrong": "lingerpotstrengthii", + "strengthlingerpotlevelii": "lingerpotstrengthii", + "stronglingerpotii": "lingerpotstrengthii", + "stronglingerpotstrong": "lingerpotstrengthii", + "stronglingerpotlevelii": "lingerpotstrengthii", + "strlingerpotii": "lingerpotstrengthii", + "strlingerpotstrong": "lingerpotstrengthii", + "strlingerpotlevelii": "lingerpotstrengthii", + "aoepotionstrengthii": "lingerpotstrengthii", + "aoepotionstrengthstrong": "lingerpotstrengthii", + "aoepotionstrengthlevelii": "lingerpotstrengthii", + "aoepotionstrongii": "lingerpotstrengthii", + "aoepotionstrongstrong": "lingerpotstrengthii", + "aoepotionstronglevelii": "lingerpotstrengthii", + "aoepotionstrii": "lingerpotstrengthii", + "aoepotionstrstrong": "lingerpotstrengthii", + "aoepotionstrlevelii": "lingerpotstrengthii", + "strengthaoepoiontii": "lingerpotstrengthii", + "strengthaoepoiontstrong": "lingerpotstrengthii", + "strengthaoepoiontlevelii": "lingerpotstrengthii", + "strongaoepoiontii": "lingerpotstrengthii", + "strongaoepoiontstrong": "lingerpotstrengthii", + "strongaoepoiontlevelii": "lingerpotstrengthii", + "straoepoiontii": "lingerpotstrengthii", + "straoepoiontstrong": "lingerpotstrengthii", + "straoepoiontlevelii": "lingerpotstrengthii", + "aoepotstrengthii": "lingerpotstrengthii", + "aoepotstrengthstrong": "lingerpotstrengthii", + "aoepotstrengthlevelii": "lingerpotstrengthii", + "aoepotstrongii": "lingerpotstrengthii", + "aoepotstrongstrong": "lingerpotstrengthii", + "aoepotstronglevelii": "lingerpotstrengthii", + "aoepotstrii": "lingerpotstrengthii", + "aoepotstrstrong": "lingerpotstrengthii", + "aoepotstrlevelii": "lingerpotstrengthii", + "strengthaoepotii": "lingerpotstrengthii", + "strengthaoepotstrong": "lingerpotstrengthii", + "strengthaoepotlevelii": "lingerpotstrengthii", + "strongaoepotii": "lingerpotstrengthii", + "strongaoepotstrong": "lingerpotstrengthii", + "strongaoepotlevelii": "lingerpotstrengthii", + "straoepotii": "lingerpotstrengthii", + "straoepotstrong": "lingerpotstrengthii", + "straoepotlevelii": "lingerpotstrengthii", + "areapotionstrengthii": "lingerpotstrengthii", + "areapotionstrengthstrong": "lingerpotstrengthii", + "areapotionstrengthlevelii": "lingerpotstrengthii", + "areapotionstrongii": "lingerpotstrengthii", + "areapotionstrongstrong": "lingerpotstrengthii", + "areapotionstronglevelii": "lingerpotstrengthii", + "areapotionstrii": "lingerpotstrengthii", + "areapotionstrstrong": "lingerpotstrengthii", + "areapotionstrlevelii": "lingerpotstrengthii", + "strengthareapotionii": "lingerpotstrengthii", + "strengthareapotionstrong": "lingerpotstrengthii", + "strengthareapotionlevelii": "lingerpotstrengthii", + "strongareapotionii": "lingerpotstrengthii", + "strongareapotionstrong": "lingerpotstrengthii", + "strongareapotionlevelii": "lingerpotstrengthii", + "strareapotionii": "lingerpotstrengthii", + "strareapotionstrong": "lingerpotstrengthii", + "strareapotionlevelii": "lingerpotstrengthii", + "areapotstrengthii": "lingerpotstrengthii", + "areapotstrengthstrong": "lingerpotstrengthii", + "areapotstrengthlevelii": "lingerpotstrengthii", + "areapotstrongii": "lingerpotstrengthii", + "areapotstrongstrong": "lingerpotstrengthii", + "areapotstronglevelii": "lingerpotstrengthii", + "areapotstrii": "lingerpotstrengthii", + "areapotstrstrong": "lingerpotstrengthii", + "areapotstrlevelii": "lingerpotstrengthii", + "strengthareapotii": "lingerpotstrengthii", + "strengthareapotstrong": "lingerpotstrengthii", + "strengthareapotlevelii": "lingerpotstrengthii", + "strongareapotii": "lingerpotstrengthii", + "strongareapotstrong": "lingerpotstrengthii", + "strongareapotlevelii": "lingerpotstrengthii", + "strareapotii": "lingerpotstrengthii", + "strareapotstrong": "lingerpotstrengthii", + "strareapotlevelii": "lingerpotstrengthii", + "cloudpotionstrengthii": "lingerpotstrengthii", + "cloudpotionstrengthstrong": "lingerpotstrengthii", + "cloudpotionstrengthlevelii": "lingerpotstrengthii", + "cloudpotionstrongii": "lingerpotstrengthii", + "cloudpotionstrongstrong": "lingerpotstrengthii", + "cloudpotionstronglevelii": "lingerpotstrengthii", + "cloudpotionstrii": "lingerpotstrengthii", + "cloudpotionstrstrong": "lingerpotstrengthii", + "cloudpotionstrlevelii": "lingerpotstrengthii", + "strengthcloudpotionii": "lingerpotstrengthii", + "strengthcloudpotionstrong": "lingerpotstrengthii", + "strengthcloudpotionlevelii": "lingerpotstrengthii", + "strongcloudpotionii": "lingerpotstrengthii", + "strongcloudpotionstrong": "lingerpotstrengthii", + "strongcloudpotionlevelii": "lingerpotstrengthii", + "strcloudpotionii": "lingerpotstrengthii", + "strcloudpotionstrong": "lingerpotstrengthii", + "strcloudpotionlevelii": "lingerpotstrengthii", + "cloudpotstrengthii": "lingerpotstrengthii", + "cloudpotstrengthstrong": "lingerpotstrengthii", + "cloudpotstrengthlevelii": "lingerpotstrengthii", + "cloudpotstrongii": "lingerpotstrengthii", + "cloudpotstrongstrong": "lingerpotstrengthii", + "cloudpotstronglevelii": "lingerpotstrengthii", + "cloudpotstrii": "lingerpotstrengthii", + "cloudpotstrstrong": "lingerpotstrengthii", + "cloudpotstrlevelii": "lingerpotstrengthii", + "strengthcloudpotii": "lingerpotstrengthii", + "strengthcloudpotstrong": "lingerpotstrengthii", + "strengthcloudpotlevelii": "lingerpotstrengthii", + "strongcloudpotii": "lingerpotstrengthii", + "strongcloudpotstrong": "lingerpotstrengthii", + "strongcloudpotlevelii": "lingerpotstrengthii", + "strcloudpotii": "lingerpotstrengthii", + "strcloudpotstrong": "lingerpotstrengthii", + "strcloudpotlevelii": "lingerpotstrengthii", + "arrowstrengthii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_strength", + "bukkitType": "strength", + "isStrong": true, + "isLong": false + } + }, + "arrowstrengthstrong": "arrowstrengthii", + "arrowstrengthlevelii": "arrowstrengthii", + "arrowstrongii": "arrowstrengthii", + "arrowstrongstrong": "arrowstrengthii", + "arrowstronglevelii": "arrowstrengthii", + "arrowstrii": "arrowstrengthii", + "arrowstrstrong": "arrowstrengthii", + "arrowstrlevelii": "arrowstrengthii", + "strengtharrowii": "arrowstrengthii", + "strengtharrowstrong": "arrowstrengthii", + "strengtharrowlevelii": "arrowstrengthii", + "strongarrowii": "arrowstrengthii", + "strongarrowstrong": "arrowstrengthii", + "strongarrowlevelii": "arrowstrengthii", + "strarrowii": "arrowstrengthii", + "strarrowstrong": "arrowstrengthii", + "strarrowlevelii": "arrowstrengthii", + "strength2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": true + } + }, + "strengthlongpotion": "strength2potion", + "strengthextendedpotion": "strength2potion", + "strengthexpotion": "strength2potion", + "strengthlevel2potion": "strength2potion", + "strong2potion": "strength2potion", + "stronglongpotion": "strength2potion", + "strongextendedpotion": "strength2potion", + "strongexpotion": "strength2potion", + "stronglevel2potion": "strength2potion", + "str2potion": "strength2potion", + "strlongpotion": "strength2potion", + "strextendedpotion": "strength2potion", + "strexpotion": "strength2potion", + "strlevel2potion": "strength2potion", + "strength2pot": "strength2potion", + "strengthlongpot": "strength2potion", + "strengthextendedpot": "strength2potion", + "strengthexpot": "strength2potion", + "strengthlevel2pot": "strength2potion", + "strong2pot": "strength2potion", + "stronglongpot": "strength2potion", + "strongextendedpot": "strength2potion", + "strongexpot": "strength2potion", + "stronglevel2pot": "strength2potion", + "str2pot": "strength2potion", + "strlongpot": "strength2potion", + "strextendedpot": "strength2potion", + "strexpot": "strength2potion", + "strlevel2pot": "strength2potion", + "potionofstrength2": "strength2potion", + "potionofstrengthlong": "strength2potion", + "potionofstrengthextended": "strength2potion", + "potionofstrengthex": "strength2potion", + "potionofstrengthlevel2": "strength2potion", + "potionofstrong2": "strength2potion", + "potionofstronglong": "strength2potion", + "potionofstrongextended": "strength2potion", + "potionofstrongex": "strength2potion", + "potionofstronglevel2": "strength2potion", + "potionofstr2": "strength2potion", + "potionofstrlong": "strength2potion", + "potionofstrextended": "strength2potion", + "potionofstrex": "strength2potion", + "potionofstrlevel2": "strength2potion", + "potofstrength2": "strength2potion", + "potofstrengthlong": "strength2potion", + "potofstrengthextended": "strength2potion", + "potofstrengthex": "strength2potion", + "potofstrengthlevel2": "strength2potion", + "potofstrong2": "strength2potion", + "potofstronglong": "strength2potion", + "potofstrongextended": "strength2potion", + "potofstrongex": "strength2potion", + "potofstronglevel2": "strength2potion", + "potofstr2": "strength2potion", + "potofstrlong": "strength2potion", + "potofstrextended": "strength2potion", + "potofstrex": "strength2potion", + "potofstrlevel2": "strength2potion", + "splashstrength2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": true + } + }, + "splashstrengthlongpotion": "splashstrength2potion", + "splashstrengthextendedpotion": "splashstrength2potion", + "splashstrengthexpotion": "splashstrength2potion", + "splashstrengthlevel2potion": "splashstrength2potion", + "splashstrong2potion": "splashstrength2potion", + "splashstronglongpotion": "splashstrength2potion", + "splashstrongextendedpotion": "splashstrength2potion", + "splashstrongexpotion": "splashstrength2potion", + "splashstronglevel2potion": "splashstrength2potion", + "splashstr2potion": "splashstrength2potion", + "splashstrlongpotion": "splashstrength2potion", + "splashstrextendedpotion": "splashstrength2potion", + "splashstrexpotion": "splashstrength2potion", + "splashstrlevel2potion": "splashstrength2potion", + "splstrength2potion": "splashstrength2potion", + "splstrengthlongpotion": "splashstrength2potion", + "splstrengthextendedpotion": "splashstrength2potion", + "splstrengthexpotion": "splashstrength2potion", + "splstrengthlevel2potion": "splashstrength2potion", + "splstrong2potion": "splashstrength2potion", + "splstronglongpotion": "splashstrength2potion", + "splstrongextendedpotion": "splashstrength2potion", + "splstrongexpotion": "splashstrength2potion", + "splstronglevel2potion": "splashstrength2potion", + "splstr2potion": "splashstrength2potion", + "splstrlongpotion": "splashstrength2potion", + "splstrextendedpotion": "splashstrength2potion", + "splstrexpotion": "splashstrength2potion", + "splstrlevel2potion": "splashstrength2potion", + "strength2splashpotion": "splashstrength2potion", + "strengthlongsplashpotion": "splashstrength2potion", + "strengthextendedsplashpotion": "splashstrength2potion", + "strengthexsplashpotion": "splashstrength2potion", + "strengthlevel2splashpotion": "splashstrength2potion", + "strong2splashpotion": "splashstrength2potion", + "stronglongsplashpotion": "splashstrength2potion", + "strongextendedsplashpotion": "splashstrength2potion", + "strongexsplashpotion": "splashstrength2potion", + "stronglevel2splashpotion": "splashstrength2potion", + "str2splashpotion": "splashstrength2potion", + "strlongsplashpotion": "splashstrength2potion", + "strextendedsplashpotion": "splashstrength2potion", + "strexsplashpotion": "splashstrength2potion", + "strlevel2splashpotion": "splashstrength2potion", + "splashstrength2pot": "splashstrength2potion", + "splashstrengthlongpot": "splashstrength2potion", + "splashstrengthextendedpot": "splashstrength2potion", + "splashstrengthexpot": "splashstrength2potion", + "splashstrengthlevel2pot": "splashstrength2potion", + "splashstrong2pot": "splashstrength2potion", + "splashstronglongpot": "splashstrength2potion", + "splashstrongextendedpot": "splashstrength2potion", + "splashstrongexpot": "splashstrength2potion", + "splashstronglevel2pot": "splashstrength2potion", + "splashstr2pot": "splashstrength2potion", + "splashstrlongpot": "splashstrength2potion", + "splashstrextendedpot": "splashstrength2potion", + "splashstrexpot": "splashstrength2potion", + "splashstrlevel2pot": "splashstrength2potion", + "splstrength2pot": "splashstrength2potion", + "splstrengthlongpot": "splashstrength2potion", + "splstrengthextendedpot": "splashstrength2potion", + "splstrengthexpot": "splashstrength2potion", + "splstrengthlevel2pot": "splashstrength2potion", + "splstrong2pot": "splashstrength2potion", + "splstronglongpot": "splashstrength2potion", + "splstrongextendedpot": "splashstrength2potion", + "splstrongexpot": "splashstrength2potion", + "splstronglevel2pot": "splashstrength2potion", + "splstr2pot": "splashstrength2potion", + "splstrlongpot": "splashstrength2potion", + "splstrextendedpot": "splashstrength2potion", + "splstrexpot": "splashstrength2potion", + "splstrlevel2pot": "splashstrength2potion", + "strength2splashpot": "splashstrength2potion", + "strengthlongsplashpot": "splashstrength2potion", + "strengthextendedsplashpot": "splashstrength2potion", + "strengthexsplashpot": "splashstrength2potion", + "strengthlevel2splashpot": "splashstrength2potion", + "strong2splashpot": "splashstrength2potion", + "stronglongsplashpot": "splashstrength2potion", + "strongextendedsplashpot": "splashstrength2potion", + "strongexsplashpot": "splashstrength2potion", + "stronglevel2splashpot": "splashstrength2potion", + "str2splashpot": "splashstrength2potion", + "strlongsplashpot": "splashstrength2potion", + "strextendedsplashpot": "splashstrength2potion", + "strexsplashpot": "splashstrength2potion", + "strlevel2splashpot": "splashstrength2potion", + "lingerpotstrength2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": true + } + }, + "lingerpotstrengthlong": "lingerpotstrength2", + "lingerpotstrengthextended": "lingerpotstrength2", + "lingerpotstrengthex": "lingerpotstrength2", + "lingerpotstrengthlevel2": "lingerpotstrength2", + "lingerpotstrong2": "lingerpotstrength2", + "lingerpotstronglong": "lingerpotstrength2", + "lingerpotstrongextended": "lingerpotstrength2", + "lingerpotstrongex": "lingerpotstrength2", + "lingerpotstronglevel2": "lingerpotstrength2", + "lingerpotstr2": "lingerpotstrength2", + "lingerpotstrlong": "lingerpotstrength2", + "lingerpotstrextended": "lingerpotstrength2", + "lingerpotstrex": "lingerpotstrength2", + "lingerpotstrlevel2": "lingerpotstrength2", + "strengthlingerpot2": "lingerpotstrength2", + "strengthlingerpotlong": "lingerpotstrength2", + "strengthlingerpotextended": "lingerpotstrength2", + "strengthlingerpotex": "lingerpotstrength2", + "strengthlingerpotlevel2": "lingerpotstrength2", + "stronglingerpot2": "lingerpotstrength2", + "stronglingerpotlong": "lingerpotstrength2", + "stronglingerpotextended": "lingerpotstrength2", + "stronglingerpotex": "lingerpotstrength2", + "stronglingerpotlevel2": "lingerpotstrength2", + "strlingerpot2": "lingerpotstrength2", + "strlingerpotlong": "lingerpotstrength2", + "strlingerpotextended": "lingerpotstrength2", + "strlingerpotex": "lingerpotstrength2", + "strlingerpotlevel2": "lingerpotstrength2", + "aoepotionstrength2": "lingerpotstrength2", + "aoepotionstrengthlong": "lingerpotstrength2", + "aoepotionstrengthextended": "lingerpotstrength2", + "aoepotionstrengthex": "lingerpotstrength2", + "aoepotionstrengthlevel2": "lingerpotstrength2", + "aoepotionstrong2": "lingerpotstrength2", + "aoepotionstronglong": "lingerpotstrength2", + "aoepotionstrongextended": "lingerpotstrength2", + "aoepotionstrongex": "lingerpotstrength2", + "aoepotionstronglevel2": "lingerpotstrength2", + "aoepotionstr2": "lingerpotstrength2", + "aoepotionstrlong": "lingerpotstrength2", + "aoepotionstrextended": "lingerpotstrength2", + "aoepotionstrex": "lingerpotstrength2", + "aoepotionstrlevel2": "lingerpotstrength2", + "strengthaoepoiont2": "lingerpotstrength2", + "strengthaoepoiontlong": "lingerpotstrength2", + "strengthaoepoiontextended": "lingerpotstrength2", + "strengthaoepoiontex": "lingerpotstrength2", + "strengthaoepoiontlevel2": "lingerpotstrength2", + "strongaoepoiont2": "lingerpotstrength2", + "strongaoepoiontlong": "lingerpotstrength2", + "strongaoepoiontextended": "lingerpotstrength2", + "strongaoepoiontex": "lingerpotstrength2", + "strongaoepoiontlevel2": "lingerpotstrength2", + "straoepoiont2": "lingerpotstrength2", + "straoepoiontlong": "lingerpotstrength2", + "straoepoiontextended": "lingerpotstrength2", + "straoepoiontex": "lingerpotstrength2", + "straoepoiontlevel2": "lingerpotstrength2", + "aoepotstrength2": "lingerpotstrength2", + "aoepotstrengthlong": "lingerpotstrength2", + "aoepotstrengthextended": "lingerpotstrength2", + "aoepotstrengthex": "lingerpotstrength2", + "aoepotstrengthlevel2": "lingerpotstrength2", + "aoepotstrong2": "lingerpotstrength2", + "aoepotstronglong": "lingerpotstrength2", + "aoepotstrongextended": "lingerpotstrength2", + "aoepotstrongex": "lingerpotstrength2", + "aoepotstronglevel2": "lingerpotstrength2", + "aoepotstr2": "lingerpotstrength2", + "aoepotstrlong": "lingerpotstrength2", + "aoepotstrextended": "lingerpotstrength2", + "aoepotstrex": "lingerpotstrength2", + "aoepotstrlevel2": "lingerpotstrength2", + "strengthaoepot2": "lingerpotstrength2", + "strengthaoepotlong": "lingerpotstrength2", + "strengthaoepotextended": "lingerpotstrength2", + "strengthaoepotex": "lingerpotstrength2", + "strengthaoepotlevel2": "lingerpotstrength2", + "strongaoepot2": "lingerpotstrength2", + "strongaoepotlong": "lingerpotstrength2", + "strongaoepotextended": "lingerpotstrength2", + "strongaoepotex": "lingerpotstrength2", + "strongaoepotlevel2": "lingerpotstrength2", + "straoepot2": "lingerpotstrength2", + "straoepotlong": "lingerpotstrength2", + "straoepotextended": "lingerpotstrength2", + "straoepotex": "lingerpotstrength2", + "straoepotlevel2": "lingerpotstrength2", + "areapotionstrength2": "lingerpotstrength2", + "areapotionstrengthlong": "lingerpotstrength2", + "areapotionstrengthextended": "lingerpotstrength2", + "areapotionstrengthex": "lingerpotstrength2", + "areapotionstrengthlevel2": "lingerpotstrength2", + "areapotionstrong2": "lingerpotstrength2", + "areapotionstronglong": "lingerpotstrength2", + "areapotionstrongextended": "lingerpotstrength2", + "areapotionstrongex": "lingerpotstrength2", + "areapotionstronglevel2": "lingerpotstrength2", + "areapotionstr2": "lingerpotstrength2", + "areapotionstrlong": "lingerpotstrength2", + "areapotionstrextended": "lingerpotstrength2", + "areapotionstrex": "lingerpotstrength2", + "areapotionstrlevel2": "lingerpotstrength2", + "strengthareapotion2": "lingerpotstrength2", + "strengthareapotionlong": "lingerpotstrength2", + "strengthareapotionextended": "lingerpotstrength2", + "strengthareapotionex": "lingerpotstrength2", + "strengthareapotionlevel2": "lingerpotstrength2", + "strongareapotion2": "lingerpotstrength2", + "strongareapotionlong": "lingerpotstrength2", + "strongareapotionextended": "lingerpotstrength2", + "strongareapotionex": "lingerpotstrength2", + "strongareapotionlevel2": "lingerpotstrength2", + "strareapotion2": "lingerpotstrength2", + "strareapotionlong": "lingerpotstrength2", + "strareapotionextended": "lingerpotstrength2", + "strareapotionex": "lingerpotstrength2", + "strareapotionlevel2": "lingerpotstrength2", + "areapotstrength2": "lingerpotstrength2", + "areapotstrengthlong": "lingerpotstrength2", + "areapotstrengthextended": "lingerpotstrength2", + "areapotstrengthex": "lingerpotstrength2", + "areapotstrengthlevel2": "lingerpotstrength2", + "areapotstrong2": "lingerpotstrength2", + "areapotstronglong": "lingerpotstrength2", + "areapotstrongextended": "lingerpotstrength2", + "areapotstrongex": "lingerpotstrength2", + "areapotstronglevel2": "lingerpotstrength2", + "areapotstr2": "lingerpotstrength2", + "areapotstrlong": "lingerpotstrength2", + "areapotstrextended": "lingerpotstrength2", + "areapotstrex": "lingerpotstrength2", + "areapotstrlevel2": "lingerpotstrength2", + "strengthareapot2": "lingerpotstrength2", + "strengthareapotlong": "lingerpotstrength2", + "strengthareapotextended": "lingerpotstrength2", + "strengthareapotex": "lingerpotstrength2", + "strengthareapotlevel2": "lingerpotstrength2", + "strongareapot2": "lingerpotstrength2", + "strongareapotlong": "lingerpotstrength2", + "strongareapotextended": "lingerpotstrength2", + "strongareapotex": "lingerpotstrength2", + "strongareapotlevel2": "lingerpotstrength2", + "strareapot2": "lingerpotstrength2", + "strareapotlong": "lingerpotstrength2", + "strareapotextended": "lingerpotstrength2", + "strareapotex": "lingerpotstrength2", + "strareapotlevel2": "lingerpotstrength2", + "cloudpotionstrength2": "lingerpotstrength2", + "cloudpotionstrengthlong": "lingerpotstrength2", + "cloudpotionstrengthextended": "lingerpotstrength2", + "cloudpotionstrengthex": "lingerpotstrength2", + "cloudpotionstrengthlevel2": "lingerpotstrength2", + "cloudpotionstrong2": "lingerpotstrength2", + "cloudpotionstronglong": "lingerpotstrength2", + "cloudpotionstrongextended": "lingerpotstrength2", + "cloudpotionstrongex": "lingerpotstrength2", + "cloudpotionstronglevel2": "lingerpotstrength2", + "cloudpotionstr2": "lingerpotstrength2", + "cloudpotionstrlong": "lingerpotstrength2", + "cloudpotionstrextended": "lingerpotstrength2", + "cloudpotionstrex": "lingerpotstrength2", + "cloudpotionstrlevel2": "lingerpotstrength2", + "strengthcloudpotion2": "lingerpotstrength2", + "strengthcloudpotionlong": "lingerpotstrength2", + "strengthcloudpotionextended": "lingerpotstrength2", + "strengthcloudpotionex": "lingerpotstrength2", + "strengthcloudpotionlevel2": "lingerpotstrength2", + "strongcloudpotion2": "lingerpotstrength2", + "strongcloudpotionlong": "lingerpotstrength2", + "strongcloudpotionextended": "lingerpotstrength2", + "strongcloudpotionex": "lingerpotstrength2", + "strongcloudpotionlevel2": "lingerpotstrength2", + "strcloudpotion2": "lingerpotstrength2", + "strcloudpotionlong": "lingerpotstrength2", + "strcloudpotionextended": "lingerpotstrength2", + "strcloudpotionex": "lingerpotstrength2", + "strcloudpotionlevel2": "lingerpotstrength2", + "cloudpotstrength2": "lingerpotstrength2", + "cloudpotstrengthlong": "lingerpotstrength2", + "cloudpotstrengthextended": "lingerpotstrength2", + "cloudpotstrengthex": "lingerpotstrength2", + "cloudpotstrengthlevel2": "lingerpotstrength2", + "cloudpotstrong2": "lingerpotstrength2", + "cloudpotstronglong": "lingerpotstrength2", + "cloudpotstrongextended": "lingerpotstrength2", + "cloudpotstrongex": "lingerpotstrength2", + "cloudpotstronglevel2": "lingerpotstrength2", + "cloudpotstr2": "lingerpotstrength2", + "cloudpotstrlong": "lingerpotstrength2", + "cloudpotstrextended": "lingerpotstrength2", + "cloudpotstrex": "lingerpotstrength2", + "cloudpotstrlevel2": "lingerpotstrength2", + "strengthcloudpot2": "lingerpotstrength2", + "strengthcloudpotlong": "lingerpotstrength2", + "strengthcloudpotextended": "lingerpotstrength2", + "strengthcloudpotex": "lingerpotstrength2", + "strengthcloudpotlevel2": "lingerpotstrength2", + "strongcloudpot2": "lingerpotstrength2", + "strongcloudpotlong": "lingerpotstrength2", + "strongcloudpotextended": "lingerpotstrength2", + "strongcloudpotex": "lingerpotstrength2", + "strongcloudpotlevel2": "lingerpotstrength2", + "strcloudpot2": "lingerpotstrength2", + "strcloudpotlong": "lingerpotstrength2", + "strcloudpotextended": "lingerpotstrength2", + "strcloudpotex": "lingerpotstrength2", + "strcloudpotlevel2": "lingerpotstrength2", + "arrowstrength2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_strength", + "bukkitType": "strength", + "isStrong": false, + "isLong": true + } + }, + "arrowstrengthlong": "arrowstrength2", + "arrowstrengthextended": "arrowstrength2", + "arrowstrengthex": "arrowstrength2", + "arrowstrengthlevel2": "arrowstrength2", + "arrowstrong2": "arrowstrength2", + "arrowstronglong": "arrowstrength2", + "arrowstrongextended": "arrowstrength2", + "arrowstrongex": "arrowstrength2", + "arrowstronglevel2": "arrowstrength2", + "arrowstr2": "arrowstrength2", + "arrowstrlong": "arrowstrength2", + "arrowstrextended": "arrowstrength2", + "arrowstrex": "arrowstrength2", + "arrowstrlevel2": "arrowstrength2", + "strengtharrow2": "arrowstrength2", + "strengtharrowlong": "arrowstrength2", + "strengtharrowextended": "arrowstrength2", + "strengtharrowex": "arrowstrength2", + "strengtharrowlevel2": "arrowstrength2", + "strongarrow2": "arrowstrength2", + "strongarrowlong": "arrowstrength2", + "strongarrowextended": "arrowstrength2", + "strongarrowex": "arrowstrength2", + "strongarrowlevel2": "arrowstrength2", + "strarrow2": "arrowstrength2", + "strarrowlong": "arrowstrength2", + "strarrowextended": "arrowstrength2", + "strarrowex": "arrowstrength2", + "strarrowlevel2": "arrowstrength2", + "weaknesspotion": { + "material": "POTION", + "potionData": { + "vanillaType": "weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": false + } + }, + "weakpotion": "weaknesspotion", + "wepotion": "weaknesspotion", + "weaknesspot": "weaknesspotion", + "weakpot": "weaknesspotion", + "wepot": "weaknesspotion", + "potionofweakness": "weaknesspotion", + "potionofweak": "weaknesspotion", + "potionofwe": "weaknesspotion", + "potofweakness": "weaknesspotion", + "potofweak": "weaknesspotion", + "potofwe": "weaknesspotion", + "splashweaknesspotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": false + } + }, + "splashweakpotion": "splashweaknesspotion", + "splashwepotion": "splashweaknesspotion", + "splweaknesspotion": "splashweaknesspotion", + "splweakpotion": "splashweaknesspotion", + "splwepotion": "splashweaknesspotion", + "weaknesssplashpotion": "splashweaknesspotion", + "weaksplashpotion": "splashweaknesspotion", + "wesplashpotion": "splashweaknesspotion", + "splashweaknesspot": "splashweaknesspotion", + "splashweakpot": "splashweaknesspotion", + "splashwepot": "splashweaknesspotion", + "splweaknesspot": "splashweaknesspotion", + "splweakpot": "splashweaknesspotion", + "splwepot": "splashweaknesspotion", + "weaknesssplashpot": "splashweaknesspotion", + "weaksplashpot": "splashweaknesspotion", + "wesplashpot": "splashweaknesspotion", + "lingerpotweakness": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": false + } + }, + "lingerpotweak": "lingerpotweakness", + "lingerpotwe": "lingerpotweakness", + "weaknesslingerpot": "lingerpotweakness", + "weaklingerpot": "lingerpotweakness", + "welingerpot": "lingerpotweakness", + "aoepotionweakness": "lingerpotweakness", + "aoepotionweak": "lingerpotweakness", + "aoepotionwe": "lingerpotweakness", + "weaknessaoepoiont": "lingerpotweakness", + "weakaoepoiont": "lingerpotweakness", + "weaoepoiont": "lingerpotweakness", + "aoepotweakness": "lingerpotweakness", + "aoepotweak": "lingerpotweakness", + "aoepotwe": "lingerpotweakness", + "weaknessaoepot": "lingerpotweakness", + "weakaoepot": "lingerpotweakness", + "weaoepot": "lingerpotweakness", + "areapotionweakness": "lingerpotweakness", + "areapotionweak": "lingerpotweakness", + "areapotionwe": "lingerpotweakness", + "weaknessareapotion": "lingerpotweakness", + "weakareapotion": "lingerpotweakness", + "weareapotion": "lingerpotweakness", + "areapotweakness": "lingerpotweakness", + "areapotweak": "lingerpotweakness", + "areapotwe": "lingerpotweakness", + "weaknessareapot": "lingerpotweakness", + "weakareapot": "lingerpotweakness", + "weareapot": "lingerpotweakness", + "cloudpotionweakness": "lingerpotweakness", + "cloudpotionweak": "lingerpotweakness", + "cloudpotionwe": "lingerpotweakness", + "weaknesscloudpotion": "lingerpotweakness", + "weakcloudpotion": "lingerpotweakness", + "wecloudpotion": "lingerpotweakness", + "cloudpotweakness": "lingerpotweakness", + "cloudpotweak": "lingerpotweakness", + "cloudpotwe": "lingerpotweakness", + "weaknesscloudpot": "lingerpotweakness", + "weakcloudpot": "lingerpotweakness", + "wecloudpot": "lingerpotweakness", + "arrowweakness": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": false + } + }, + "arrowweak": "arrowweakness", + "arrowwe": "arrowweakness", + "weaknessarrow": "arrowweakness", + "weakarrow": "arrowweakness", + "wearrow": "arrowweakness", + "weakness2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": true + } + }, + "weaknesslongpotion": "weakness2potion", + "weaknessextendedpotion": "weakness2potion", + "weaknessexpotion": "weakness2potion", + "weaknesslevel2potion": "weakness2potion", + "weak2potion": "weakness2potion", + "weaklongpotion": "weakness2potion", + "weakextendedpotion": "weakness2potion", + "weakexpotion": "weakness2potion", + "weaklevel2potion": "weakness2potion", + "we2potion": "weakness2potion", + "welongpotion": "weakness2potion", + "weextendedpotion": "weakness2potion", + "weexpotion": "weakness2potion", + "welevel2potion": "weakness2potion", + "weakness2pot": "weakness2potion", + "weaknesslongpot": "weakness2potion", + "weaknessextendedpot": "weakness2potion", + "weaknessexpot": "weakness2potion", + "weaknesslevel2pot": "weakness2potion", + "weak2pot": "weakness2potion", + "weaklongpot": "weakness2potion", + "weakextendedpot": "weakness2potion", + "weakexpot": "weakness2potion", + "weaklevel2pot": "weakness2potion", + "we2pot": "weakness2potion", + "welongpot": "weakness2potion", + "weextendedpot": "weakness2potion", + "weexpot": "weakness2potion", + "welevel2pot": "weakness2potion", + "potionofweakness2": "weakness2potion", + "potionofweaknesslong": "weakness2potion", + "potionofweaknessextended": "weakness2potion", + "potionofweaknessex": "weakness2potion", + "potionofweaknesslevel2": "weakness2potion", + "potionofweak2": "weakness2potion", + "potionofweaklong": "weakness2potion", + "potionofweakextended": "weakness2potion", + "potionofweakex": "weakness2potion", + "potionofweaklevel2": "weakness2potion", + "potionofwe2": "weakness2potion", + "potionofwelong": "weakness2potion", + "potionofweextended": "weakness2potion", + "potionofweex": "weakness2potion", + "potionofwelevel2": "weakness2potion", + "potofweakness2": "weakness2potion", + "potofweaknesslong": "weakness2potion", + "potofweaknessextended": "weakness2potion", + "potofweaknessex": "weakness2potion", + "potofweaknesslevel2": "weakness2potion", + "potofweak2": "weakness2potion", + "potofweaklong": "weakness2potion", + "potofweakextended": "weakness2potion", + "potofweakex": "weakness2potion", + "potofweaklevel2": "weakness2potion", + "potofwe2": "weakness2potion", + "potofwelong": "weakness2potion", + "potofweextended": "weakness2potion", + "potofweex": "weakness2potion", + "potofwelevel2": "weakness2potion", + "splashweakness2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": true + } + }, + "splashweaknesslongpotion": "splashweakness2potion", + "splashweaknessextendedpotion": "splashweakness2potion", + "splashweaknessexpotion": "splashweakness2potion", + "splashweaknesslevel2potion": "splashweakness2potion", + "splashweak2potion": "splashweakness2potion", + "splashweaklongpotion": "splashweakness2potion", + "splashweakextendedpotion": "splashweakness2potion", + "splashweakexpotion": "splashweakness2potion", + "splashweaklevel2potion": "splashweakness2potion", + "splashwe2potion": "splashweakness2potion", + "splashwelongpotion": "splashweakness2potion", + "splashweextendedpotion": "splashweakness2potion", + "splashweexpotion": "splashweakness2potion", + "splashwelevel2potion": "splashweakness2potion", + "splweakness2potion": "splashweakness2potion", + "splweaknesslongpotion": "splashweakness2potion", + "splweaknessextendedpotion": "splashweakness2potion", + "splweaknessexpotion": "splashweakness2potion", + "splweaknesslevel2potion": "splashweakness2potion", + "splweak2potion": "splashweakness2potion", + "splweaklongpotion": "splashweakness2potion", + "splweakextendedpotion": "splashweakness2potion", + "splweakexpotion": "splashweakness2potion", + "splweaklevel2potion": "splashweakness2potion", + "splwe2potion": "splashweakness2potion", + "splwelongpotion": "splashweakness2potion", + "splweextendedpotion": "splashweakness2potion", + "splweexpotion": "splashweakness2potion", + "splwelevel2potion": "splashweakness2potion", + "weakness2splashpotion": "splashweakness2potion", + "weaknesslongsplashpotion": "splashweakness2potion", + "weaknessextendedsplashpotion": "splashweakness2potion", + "weaknessexsplashpotion": "splashweakness2potion", + "weaknesslevel2splashpotion": "splashweakness2potion", + "weak2splashpotion": "splashweakness2potion", + "weaklongsplashpotion": "splashweakness2potion", + "weakextendedsplashpotion": "splashweakness2potion", + "weakexsplashpotion": "splashweakness2potion", + "weaklevel2splashpotion": "splashweakness2potion", + "we2splashpotion": "splashweakness2potion", + "welongsplashpotion": "splashweakness2potion", + "weextendedsplashpotion": "splashweakness2potion", + "weexsplashpotion": "splashweakness2potion", + "welevel2splashpotion": "splashweakness2potion", + "splashweakness2pot": "splashweakness2potion", + "splashweaknesslongpot": "splashweakness2potion", + "splashweaknessextendedpot": "splashweakness2potion", + "splashweaknessexpot": "splashweakness2potion", + "splashweaknesslevel2pot": "splashweakness2potion", + "splashweak2pot": "splashweakness2potion", + "splashweaklongpot": "splashweakness2potion", + "splashweakextendedpot": "splashweakness2potion", + "splashweakexpot": "splashweakness2potion", + "splashweaklevel2pot": "splashweakness2potion", + "splashwe2pot": "splashweakness2potion", + "splashwelongpot": "splashweakness2potion", + "splashweextendedpot": "splashweakness2potion", + "splashweexpot": "splashweakness2potion", + "splashwelevel2pot": "splashweakness2potion", + "splweakness2pot": "splashweakness2potion", + "splweaknesslongpot": "splashweakness2potion", + "splweaknessextendedpot": "splashweakness2potion", + "splweaknessexpot": "splashweakness2potion", + "splweaknesslevel2pot": "splashweakness2potion", + "splweak2pot": "splashweakness2potion", + "splweaklongpot": "splashweakness2potion", + "splweakextendedpot": "splashweakness2potion", + "splweakexpot": "splashweakness2potion", + "splweaklevel2pot": "splashweakness2potion", + "splwe2pot": "splashweakness2potion", + "splwelongpot": "splashweakness2potion", + "splweextendedpot": "splashweakness2potion", + "splweexpot": "splashweakness2potion", + "splwelevel2pot": "splashweakness2potion", + "weakness2splashpot": "splashweakness2potion", + "weaknesslongsplashpot": "splashweakness2potion", + "weaknessextendedsplashpot": "splashweakness2potion", + "weaknessexsplashpot": "splashweakness2potion", + "weaknesslevel2splashpot": "splashweakness2potion", + "weak2splashpot": "splashweakness2potion", + "weaklongsplashpot": "splashweakness2potion", + "weakextendedsplashpot": "splashweakness2potion", + "weakexsplashpot": "splashweakness2potion", + "weaklevel2splashpot": "splashweakness2potion", + "we2splashpot": "splashweakness2potion", + "welongsplashpot": "splashweakness2potion", + "weextendedsplashpot": "splashweakness2potion", + "weexsplashpot": "splashweakness2potion", + "welevel2splashpot": "splashweakness2potion", + "lingerpotweakness2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": true + } + }, + "lingerpotweaknesslong": "lingerpotweakness2", + "lingerpotweaknessextended": "lingerpotweakness2", + "lingerpotweaknessex": "lingerpotweakness2", + "lingerpotweaknesslevel2": "lingerpotweakness2", + "lingerpotweak2": "lingerpotweakness2", + "lingerpotweaklong": "lingerpotweakness2", + "lingerpotweakextended": "lingerpotweakness2", + "lingerpotweakex": "lingerpotweakness2", + "lingerpotweaklevel2": "lingerpotweakness2", + "lingerpotwe2": "lingerpotweakness2", + "lingerpotwelong": "lingerpotweakness2", + "lingerpotweextended": "lingerpotweakness2", + "lingerpotweex": "lingerpotweakness2", + "lingerpotwelevel2": "lingerpotweakness2", + "weaknesslingerpot2": "lingerpotweakness2", + "weaknesslingerpotlong": "lingerpotweakness2", + "weaknesslingerpotextended": "lingerpotweakness2", + "weaknesslingerpotex": "lingerpotweakness2", + "weaknesslingerpotlevel2": "lingerpotweakness2", + "weaklingerpot2": "lingerpotweakness2", + "weaklingerpotlong": "lingerpotweakness2", + "weaklingerpotextended": "lingerpotweakness2", + "weaklingerpotex": "lingerpotweakness2", + "weaklingerpotlevel2": "lingerpotweakness2", + "welingerpot2": "lingerpotweakness2", + "welingerpotlong": "lingerpotweakness2", + "welingerpotextended": "lingerpotweakness2", + "welingerpotex": "lingerpotweakness2", + "welingerpotlevel2": "lingerpotweakness2", + "aoepotionweakness2": "lingerpotweakness2", + "aoepotionweaknesslong": "lingerpotweakness2", + "aoepotionweaknessextended": "lingerpotweakness2", + "aoepotionweaknessex": "lingerpotweakness2", + "aoepotionweaknesslevel2": "lingerpotweakness2", + "aoepotionweak2": "lingerpotweakness2", + "aoepotionweaklong": "lingerpotweakness2", + "aoepotionweakextended": "lingerpotweakness2", + "aoepotionweakex": "lingerpotweakness2", + "aoepotionweaklevel2": "lingerpotweakness2", + "aoepotionwe2": "lingerpotweakness2", + "aoepotionwelong": "lingerpotweakness2", + "aoepotionweextended": "lingerpotweakness2", + "aoepotionweex": "lingerpotweakness2", + "aoepotionwelevel2": "lingerpotweakness2", + "weaknessaoepoiont2": "lingerpotweakness2", + "weaknessaoepoiontlong": "lingerpotweakness2", + "weaknessaoepoiontextended": "lingerpotweakness2", + "weaknessaoepoiontex": "lingerpotweakness2", + "weaknessaoepoiontlevel2": "lingerpotweakness2", + "weakaoepoiont2": "lingerpotweakness2", + "weakaoepoiontlong": "lingerpotweakness2", + "weakaoepoiontextended": "lingerpotweakness2", + "weakaoepoiontex": "lingerpotweakness2", + "weakaoepoiontlevel2": "lingerpotweakness2", + "weaoepoiont2": "lingerpotweakness2", + "weaoepoiontlong": "lingerpotweakness2", + "weaoepoiontextended": "lingerpotweakness2", + "weaoepoiontex": "lingerpotweakness2", + "weaoepoiontlevel2": "lingerpotweakness2", + "aoepotweakness2": "lingerpotweakness2", + "aoepotweaknesslong": "lingerpotweakness2", + "aoepotweaknessextended": "lingerpotweakness2", + "aoepotweaknessex": "lingerpotweakness2", + "aoepotweaknesslevel2": "lingerpotweakness2", + "aoepotweak2": "lingerpotweakness2", + "aoepotweaklong": "lingerpotweakness2", + "aoepotweakextended": "lingerpotweakness2", + "aoepotweakex": "lingerpotweakness2", + "aoepotweaklevel2": "lingerpotweakness2", + "aoepotwe2": "lingerpotweakness2", + "aoepotwelong": "lingerpotweakness2", + "aoepotweextended": "lingerpotweakness2", + "aoepotweex": "lingerpotweakness2", + "aoepotwelevel2": "lingerpotweakness2", + "weaknessaoepot2": "lingerpotweakness2", + "weaknessaoepotlong": "lingerpotweakness2", + "weaknessaoepotextended": "lingerpotweakness2", + "weaknessaoepotex": "lingerpotweakness2", + "weaknessaoepotlevel2": "lingerpotweakness2", + "weakaoepot2": "lingerpotweakness2", + "weakaoepotlong": "lingerpotweakness2", + "weakaoepotextended": "lingerpotweakness2", + "weakaoepotex": "lingerpotweakness2", + "weakaoepotlevel2": "lingerpotweakness2", + "weaoepot2": "lingerpotweakness2", + "weaoepotlong": "lingerpotweakness2", + "weaoepotextended": "lingerpotweakness2", + "weaoepotex": "lingerpotweakness2", + "weaoepotlevel2": "lingerpotweakness2", + "areapotionweakness2": "lingerpotweakness2", + "areapotionweaknesslong": "lingerpotweakness2", + "areapotionweaknessextended": "lingerpotweakness2", + "areapotionweaknessex": "lingerpotweakness2", + "areapotionweaknesslevel2": "lingerpotweakness2", + "areapotionweak2": "lingerpotweakness2", + "areapotionweaklong": "lingerpotweakness2", + "areapotionweakextended": "lingerpotweakness2", + "areapotionweakex": "lingerpotweakness2", + "areapotionweaklevel2": "lingerpotweakness2", + "areapotionwe2": "lingerpotweakness2", + "areapotionwelong": "lingerpotweakness2", + "areapotionweextended": "lingerpotweakness2", + "areapotionweex": "lingerpotweakness2", + "areapotionwelevel2": "lingerpotweakness2", + "weaknessareapotion2": "lingerpotweakness2", + "weaknessareapotionlong": "lingerpotweakness2", + "weaknessareapotionextended": "lingerpotweakness2", + "weaknessareapotionex": "lingerpotweakness2", + "weaknessareapotionlevel2": "lingerpotweakness2", + "weakareapotion2": "lingerpotweakness2", + "weakareapotionlong": "lingerpotweakness2", + "weakareapotionextended": "lingerpotweakness2", + "weakareapotionex": "lingerpotweakness2", + "weakareapotionlevel2": "lingerpotweakness2", + "weareapotion2": "lingerpotweakness2", + "weareapotionlong": "lingerpotweakness2", + "weareapotionextended": "lingerpotweakness2", + "weareapotionex": "lingerpotweakness2", + "weareapotionlevel2": "lingerpotweakness2", + "areapotweakness2": "lingerpotweakness2", + "areapotweaknesslong": "lingerpotweakness2", + "areapotweaknessextended": "lingerpotweakness2", + "areapotweaknessex": "lingerpotweakness2", + "areapotweaknesslevel2": "lingerpotweakness2", + "areapotweak2": "lingerpotweakness2", + "areapotweaklong": "lingerpotweakness2", + "areapotweakextended": "lingerpotweakness2", + "areapotweakex": "lingerpotweakness2", + "areapotweaklevel2": "lingerpotweakness2", + "areapotwe2": "lingerpotweakness2", + "areapotwelong": "lingerpotweakness2", + "areapotweextended": "lingerpotweakness2", + "areapotweex": "lingerpotweakness2", + "areapotwelevel2": "lingerpotweakness2", + "weaknessareapot2": "lingerpotweakness2", + "weaknessareapotlong": "lingerpotweakness2", + "weaknessareapotextended": "lingerpotweakness2", + "weaknessareapotex": "lingerpotweakness2", + "weaknessareapotlevel2": "lingerpotweakness2", + "weakareapot2": "lingerpotweakness2", + "weakareapotlong": "lingerpotweakness2", + "weakareapotextended": "lingerpotweakness2", + "weakareapotex": "lingerpotweakness2", + "weakareapotlevel2": "lingerpotweakness2", + "weareapot2": "lingerpotweakness2", + "weareapotlong": "lingerpotweakness2", + "weareapotextended": "lingerpotweakness2", + "weareapotex": "lingerpotweakness2", + "weareapotlevel2": "lingerpotweakness2", + "cloudpotionweakness2": "lingerpotweakness2", + "cloudpotionweaknesslong": "lingerpotweakness2", + "cloudpotionweaknessextended": "lingerpotweakness2", + "cloudpotionweaknessex": "lingerpotweakness2", + "cloudpotionweaknesslevel2": "lingerpotweakness2", + "cloudpotionweak2": "lingerpotweakness2", + "cloudpotionweaklong": "lingerpotweakness2", + "cloudpotionweakextended": "lingerpotweakness2", + "cloudpotionweakex": "lingerpotweakness2", + "cloudpotionweaklevel2": "lingerpotweakness2", + "cloudpotionwe2": "lingerpotweakness2", + "cloudpotionwelong": "lingerpotweakness2", + "cloudpotionweextended": "lingerpotweakness2", + "cloudpotionweex": "lingerpotweakness2", + "cloudpotionwelevel2": "lingerpotweakness2", + "weaknesscloudpotion2": "lingerpotweakness2", + "weaknesscloudpotionlong": "lingerpotweakness2", + "weaknesscloudpotionextended": "lingerpotweakness2", + "weaknesscloudpotionex": "lingerpotweakness2", + "weaknesscloudpotionlevel2": "lingerpotweakness2", + "weakcloudpotion2": "lingerpotweakness2", + "weakcloudpotionlong": "lingerpotweakness2", + "weakcloudpotionextended": "lingerpotweakness2", + "weakcloudpotionex": "lingerpotweakness2", + "weakcloudpotionlevel2": "lingerpotweakness2", + "wecloudpotion2": "lingerpotweakness2", + "wecloudpotionlong": "lingerpotweakness2", + "wecloudpotionextended": "lingerpotweakness2", + "wecloudpotionex": "lingerpotweakness2", + "wecloudpotionlevel2": "lingerpotweakness2", + "cloudpotweakness2": "lingerpotweakness2", + "cloudpotweaknesslong": "lingerpotweakness2", + "cloudpotweaknessextended": "lingerpotweakness2", + "cloudpotweaknessex": "lingerpotweakness2", + "cloudpotweaknesslevel2": "lingerpotweakness2", + "cloudpotweak2": "lingerpotweakness2", + "cloudpotweaklong": "lingerpotweakness2", + "cloudpotweakextended": "lingerpotweakness2", + "cloudpotweakex": "lingerpotweakness2", + "cloudpotweaklevel2": "lingerpotweakness2", + "cloudpotwe2": "lingerpotweakness2", + "cloudpotwelong": "lingerpotweakness2", + "cloudpotweextended": "lingerpotweakness2", + "cloudpotweex": "lingerpotweakness2", + "cloudpotwelevel2": "lingerpotweakness2", + "weaknesscloudpot2": "lingerpotweakness2", + "weaknesscloudpotlong": "lingerpotweakness2", + "weaknesscloudpotextended": "lingerpotweakness2", + "weaknesscloudpotex": "lingerpotweakness2", + "weaknesscloudpotlevel2": "lingerpotweakness2", + "weakcloudpot2": "lingerpotweakness2", + "weakcloudpotlong": "lingerpotweakness2", + "weakcloudpotextended": "lingerpotweakness2", + "weakcloudpotex": "lingerpotweakness2", + "weakcloudpotlevel2": "lingerpotweakness2", + "wecloudpot2": "lingerpotweakness2", + "wecloudpotlong": "lingerpotweakness2", + "wecloudpotextended": "lingerpotweakness2", + "wecloudpotex": "lingerpotweakness2", + "wecloudpotlevel2": "lingerpotweakness2", + "arrowweakness2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_weakness", + "bukkitType": "weakness", + "isStrong": false, + "isLong": true + } + }, + "arrowweaknesslong": "arrowweakness2", + "arrowweaknessextended": "arrowweakness2", + "arrowweaknessex": "arrowweakness2", + "arrowweaknesslevel2": "arrowweakness2", + "arrowweak2": "arrowweakness2", + "arrowweaklong": "arrowweakness2", + "arrowweakextended": "arrowweakness2", + "arrowweakex": "arrowweakness2", + "arrowweaklevel2": "arrowweakness2", + "arrowwe2": "arrowweakness2", + "arrowwelong": "arrowweakness2", + "arrowweextended": "arrowweakness2", + "arrowweex": "arrowweakness2", + "arrowwelevel2": "arrowweakness2", + "weaknessarrow2": "arrowweakness2", + "weaknessarrowlong": "arrowweakness2", + "weaknessarrowextended": "arrowweakness2", + "weaknessarrowex": "arrowweakness2", + "weaknessarrowlevel2": "arrowweakness2", + "weakarrow2": "arrowweakness2", + "weakarrowlong": "arrowweakness2", + "weakarrowextended": "arrowweakness2", + "weakarrowex": "arrowweakness2", + "weakarrowlevel2": "arrowweakness2", + "wearrow2": "arrowweakness2", + "wearrowlong": "arrowweakness2", + "wearrowextended": "arrowweakness2", + "wearrowex": "arrowweakness2", + "wearrowlevel2": "arrowweakness2", + "luckpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "luck", + "bukkitType": "luck", + "isStrong": false, + "isLong": false + } + }, + "luckypotion": "luckpotion", + "luckpot": "luckpotion", + "luckypot": "luckpotion", + "potionofluck": "luckpotion", + "potionoflucky": "luckpotion", + "potofluck": "luckpotion", + "potoflucky": "luckpotion", + "splashluckpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "luck", + "bukkitType": "luck", + "isStrong": false, + "isLong": false + } + }, + "splashluckypotion": "splashluckpotion", + "splluckpotion": "splashluckpotion", + "splluckypotion": "splashluckpotion", + "lucksplashpotion": "splashluckpotion", + "luckysplashpotion": "splashluckpotion", + "splashluckpot": "splashluckpotion", + "splashluckypot": "splashluckpotion", + "splluckpot": "splashluckpotion", + "splluckypot": "splashluckpotion", + "lucksplashpot": "splashluckpotion", + "luckysplashpot": "splashluckpotion", + "lingerpotluck": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "luck", + "bukkitType": "luck", + "isStrong": false, + "isLong": false + } + }, + "lingerpotlucky": "lingerpotluck", + "lucklingerpot": "lingerpotluck", + "luckylingerpot": "lingerpotluck", + "aoepotionluck": "lingerpotluck", + "aoepotionlucky": "lingerpotluck", + "luckaoepoiont": "lingerpotluck", + "luckyaoepoiont": "lingerpotluck", + "aoepotluck": "lingerpotluck", + "aoepotlucky": "lingerpotluck", + "luckaoepot": "lingerpotluck", + "luckyaoepot": "lingerpotluck", + "areapotionluck": "lingerpotluck", + "areapotionlucky": "lingerpotluck", + "luckareapotion": "lingerpotluck", + "luckyareapotion": "lingerpotluck", + "areapotluck": "lingerpotluck", + "areapotlucky": "lingerpotluck", + "luckareapot": "lingerpotluck", + "luckyareapot": "lingerpotluck", + "cloudpotionluck": "lingerpotluck", + "cloudpotionlucky": "lingerpotluck", + "luckcloudpotion": "lingerpotluck", + "luckycloudpotion": "lingerpotluck", + "cloudpotluck": "lingerpotluck", + "cloudpotlucky": "lingerpotluck", + "luckcloudpot": "lingerpotluck", + "luckycloudpot": "lingerpotluck", + "arrowluck": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "luck", + "bukkitType": "luck", + "isStrong": false, + "isLong": false + } + }, + "arrowlucky": "arrowluck", + "luckarrow": "arrowluck", + "luckyarrow": "arrowluck", + "turtlemasterpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": false + } + }, + "turtlepotion": "turtlemasterpotion", + "tmpotion": "turtlemasterpotion", + "turtlemasterpot": "turtlemasterpotion", + "turtlepot": "turtlemasterpotion", + "tmpot": "turtlemasterpotion", + "potionofturtlemaster": "turtlemasterpotion", + "potionofturtle": "turtlemasterpotion", + "potionoftm": "turtlemasterpotion", + "potofturtlemaster": "turtlemasterpotion", + "potofturtle": "turtlemasterpotion", + "potoftm": "turtlemasterpotion", + "splashturtlemasterpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": false + } + }, + "splashturtlepotion": "splashturtlemasterpotion", + "splashtmpotion": "splashturtlemasterpotion", + "splturtlemasterpotion": "splashturtlemasterpotion", + "splturtlepotion": "splashturtlemasterpotion", + "spltmpotion": "splashturtlemasterpotion", + "turtlemastersplashpotion": "splashturtlemasterpotion", + "turtlesplashpotion": "splashturtlemasterpotion", + "tmsplashpotion": "splashturtlemasterpotion", + "splashturtlemasterpot": "splashturtlemasterpotion", + "splashturtlepot": "splashturtlemasterpotion", + "splashtmpot": "splashturtlemasterpotion", + "splturtlemasterpot": "splashturtlemasterpotion", + "splturtlepot": "splashturtlemasterpotion", + "spltmpot": "splashturtlemasterpotion", + "turtlemastersplashpot": "splashturtlemasterpotion", + "turtlesplashpot": "splashturtlemasterpotion", + "tmsplashpot": "splashturtlemasterpotion", + "lingerpotturtlemaster": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": false + } + }, + "lingerpotturtle": "lingerpotturtlemaster", + "lingerpottm": "lingerpotturtlemaster", + "turtlemasterlingerpot": "lingerpotturtlemaster", + "turtlelingerpot": "lingerpotturtlemaster", + "tmlingerpot": "lingerpotturtlemaster", + "aoepotionturtlemaster": "lingerpotturtlemaster", + "aoepotionturtle": "lingerpotturtlemaster", + "aoepotiontm": "lingerpotturtlemaster", + "turtlemasteraoepoiont": "lingerpotturtlemaster", + "turtleaoepoiont": "lingerpotturtlemaster", + "tmaoepoiont": "lingerpotturtlemaster", + "aoepotturtlemaster": "lingerpotturtlemaster", + "aoepotturtle": "lingerpotturtlemaster", + "aoepottm": "lingerpotturtlemaster", + "turtlemasteraoepot": "lingerpotturtlemaster", + "turtleaoepot": "lingerpotturtlemaster", + "tmaoepot": "lingerpotturtlemaster", + "areapotionturtlemaster": "lingerpotturtlemaster", + "areapotionturtle": "lingerpotturtlemaster", + "areapotiontm": "lingerpotturtlemaster", + "turtlemasterareapotion": "lingerpotturtlemaster", + "turtleareapotion": "lingerpotturtlemaster", + "tmareapotion": "lingerpotturtlemaster", + "areapotturtlemaster": "lingerpotturtlemaster", + "areapotturtle": "lingerpotturtlemaster", + "areapottm": "lingerpotturtlemaster", + "turtlemasterareapot": "lingerpotturtlemaster", + "turtleareapot": "lingerpotturtlemaster", + "tmareapot": "lingerpotturtlemaster", + "cloudpotionturtlemaster": "lingerpotturtlemaster", + "cloudpotionturtle": "lingerpotturtlemaster", + "cloudpotiontm": "lingerpotturtlemaster", + "turtlemastercloudpotion": "lingerpotturtlemaster", + "turtlecloudpotion": "lingerpotturtlemaster", + "tmcloudpotion": "lingerpotturtlemaster", + "cloudpotturtlemaster": "lingerpotturtlemaster", + "cloudpotturtle": "lingerpotturtlemaster", + "cloudpottm": "lingerpotturtlemaster", + "turtlemastercloudpot": "lingerpotturtlemaster", + "turtlecloudpot": "lingerpotturtlemaster", + "tmcloudpot": "lingerpotturtlemaster", + "arrowturtlemaster": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": false + } + }, + "arrowturtle": "arrowturtlemaster", + "arrowtm": "arrowturtlemaster", + "turtlemasterarrow": "arrowturtlemaster", + "turtlearrow": "arrowturtlemaster", + "tmarrow": "arrowturtlemaster", + "turtlemasteriipotion": { + "material": "POTION", + "potionData": { + "vanillaType": "strong_turtle_master", + "bukkitType": "turtle_master", + "isStrong": true, + "isLong": false + } + }, + "turtlemasterstrongpotion": "turtlemasteriipotion", + "turtlemasterleveliipotion": "turtlemasteriipotion", + "turtleiipotion": "turtlemasteriipotion", + "turtlestrongpotion": "turtlemasteriipotion", + "turtleleveliipotion": "turtlemasteriipotion", + "tmiipotion": "turtlemasteriipotion", + "tmstrongpotion": "turtlemasteriipotion", + "tmleveliipotion": "turtlemasteriipotion", + "turtlemasteriipot": "turtlemasteriipotion", + "turtlemasterstrongpot": "turtlemasteriipotion", + "turtlemasterleveliipot": "turtlemasteriipotion", + "turtleiipot": "turtlemasteriipotion", + "turtlestrongpot": "turtlemasteriipotion", + "turtleleveliipot": "turtlemasteriipotion", + "tmiipot": "turtlemasteriipotion", + "tmstrongpot": "turtlemasteriipotion", + "tmleveliipot": "turtlemasteriipotion", + "potionofturtlemasterii": "turtlemasteriipotion", + "potionofturtlemasterstrong": "turtlemasteriipotion", + "potionofturtlemasterlevelii": "turtlemasteriipotion", + "potionofturtleii": "turtlemasteriipotion", + "potionofturtlestrong": "turtlemasteriipotion", + "potionofturtlelevelii": "turtlemasteriipotion", + "potionoftmii": "turtlemasteriipotion", + "potionoftmstrong": "turtlemasteriipotion", + "potionoftmlevelii": "turtlemasteriipotion", + "potofturtlemasterii": "turtlemasteriipotion", + "potofturtlemasterstrong": "turtlemasteriipotion", + "potofturtlemasterlevelii": "turtlemasteriipotion", + "potofturtleii": "turtlemasteriipotion", + "potofturtlestrong": "turtlemasteriipotion", + "potofturtlelevelii": "turtlemasteriipotion", + "potoftmii": "turtlemasteriipotion", + "potoftmstrong": "turtlemasteriipotion", + "potoftmlevelii": "turtlemasteriipotion", + "splashturtlemasteriipotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "strong_turtle_master", + "bukkitType": "turtle_master", + "isStrong": true, + "isLong": false + } + }, + "splashturtlemasterstrongpotion": "splashturtlemasteriipotion", + "splashturtlemasterleveliipotion": "splashturtlemasteriipotion", + "splashturtleiipotion": "splashturtlemasteriipotion", + "splashturtlestrongpotion": "splashturtlemasteriipotion", + "splashturtleleveliipotion": "splashturtlemasteriipotion", + "splashtmiipotion": "splashturtlemasteriipotion", + "splashtmstrongpotion": "splashturtlemasteriipotion", + "splashtmleveliipotion": "splashturtlemasteriipotion", + "splturtlemasteriipotion": "splashturtlemasteriipotion", + "splturtlemasterstrongpotion": "splashturtlemasteriipotion", + "splturtlemasterleveliipotion": "splashturtlemasteriipotion", + "splturtleiipotion": "splashturtlemasteriipotion", + "splturtlestrongpotion": "splashturtlemasteriipotion", + "splturtleleveliipotion": "splashturtlemasteriipotion", + "spltmiipotion": "splashturtlemasteriipotion", + "spltmstrongpotion": "splashturtlemasteriipotion", + "spltmleveliipotion": "splashturtlemasteriipotion", + "turtlemasteriisplashpotion": "splashturtlemasteriipotion", + "turtlemasterstrongsplashpotion": "splashturtlemasteriipotion", + "turtlemasterleveliisplashpotion": "splashturtlemasteriipotion", + "turtleiisplashpotion": "splashturtlemasteriipotion", + "turtlestrongsplashpotion": "splashturtlemasteriipotion", + "turtleleveliisplashpotion": "splashturtlemasteriipotion", + "tmiisplashpotion": "splashturtlemasteriipotion", + "tmstrongsplashpotion": "splashturtlemasteriipotion", + "tmleveliisplashpotion": "splashturtlemasteriipotion", + "splashturtlemasteriipot": "splashturtlemasteriipotion", + "splashturtlemasterstrongpot": "splashturtlemasteriipotion", + "splashturtlemasterleveliipot": "splashturtlemasteriipotion", + "splashturtleiipot": "splashturtlemasteriipotion", + "splashturtlestrongpot": "splashturtlemasteriipotion", + "splashturtleleveliipot": "splashturtlemasteriipotion", + "splashtmiipot": "splashturtlemasteriipotion", + "splashtmstrongpot": "splashturtlemasteriipotion", + "splashtmleveliipot": "splashturtlemasteriipotion", + "splturtlemasteriipot": "splashturtlemasteriipotion", + "splturtlemasterstrongpot": "splashturtlemasteriipotion", + "splturtlemasterleveliipot": "splashturtlemasteriipotion", + "splturtleiipot": "splashturtlemasteriipotion", + "splturtlestrongpot": "splashturtlemasteriipotion", + "splturtleleveliipot": "splashturtlemasteriipotion", + "spltmiipot": "splashturtlemasteriipotion", + "spltmstrongpot": "splashturtlemasteriipotion", + "spltmleveliipot": "splashturtlemasteriipotion", + "turtlemasteriisplashpot": "splashturtlemasteriipotion", + "turtlemasterstrongsplashpot": "splashturtlemasteriipotion", + "turtlemasterleveliisplashpot": "splashturtlemasteriipotion", + "turtleiisplashpot": "splashturtlemasteriipotion", + "turtlestrongsplashpot": "splashturtlemasteriipotion", + "turtleleveliisplashpot": "splashturtlemasteriipotion", + "tmiisplashpot": "splashturtlemasteriipotion", + "tmstrongsplashpot": "splashturtlemasteriipotion", + "tmleveliisplashpot": "splashturtlemasteriipotion", + "lingerpotturtlemasterii": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "strong_turtle_master", + "bukkitType": "turtle_master", + "isStrong": true, + "isLong": false + } + }, + "lingerpotturtlemasterstrong": "lingerpotturtlemasterii", + "lingerpotturtlemasterlevelii": "lingerpotturtlemasterii", + "lingerpotturtleii": "lingerpotturtlemasterii", + "lingerpotturtlestrong": "lingerpotturtlemasterii", + "lingerpotturtlelevelii": "lingerpotturtlemasterii", + "lingerpottmii": "lingerpotturtlemasterii", + "lingerpottmstrong": "lingerpotturtlemasterii", + "lingerpottmlevelii": "lingerpotturtlemasterii", + "turtlemasterlingerpotii": "lingerpotturtlemasterii", + "turtlemasterlingerpotstrong": "lingerpotturtlemasterii", + "turtlemasterlingerpotlevelii": "lingerpotturtlemasterii", + "turtlelingerpotii": "lingerpotturtlemasterii", + "turtlelingerpotstrong": "lingerpotturtlemasterii", + "turtlelingerpotlevelii": "lingerpotturtlemasterii", + "tmlingerpotii": "lingerpotturtlemasterii", + "tmlingerpotstrong": "lingerpotturtlemasterii", + "tmlingerpotlevelii": "lingerpotturtlemasterii", + "aoepotionturtlemasterii": "lingerpotturtlemasterii", + "aoepotionturtlemasterstrong": "lingerpotturtlemasterii", + "aoepotionturtlemasterlevelii": "lingerpotturtlemasterii", + "aoepotionturtleii": "lingerpotturtlemasterii", + "aoepotionturtlestrong": "lingerpotturtlemasterii", + "aoepotionturtlelevelii": "lingerpotturtlemasterii", + "aoepotiontmii": "lingerpotturtlemasterii", + "aoepotiontmstrong": "lingerpotturtlemasterii", + "aoepotiontmlevelii": "lingerpotturtlemasterii", + "turtlemasteraoepoiontii": "lingerpotturtlemasterii", + "turtlemasteraoepoiontstrong": "lingerpotturtlemasterii", + "turtlemasteraoepoiontlevelii": "lingerpotturtlemasterii", + "turtleaoepoiontii": "lingerpotturtlemasterii", + "turtleaoepoiontstrong": "lingerpotturtlemasterii", + "turtleaoepoiontlevelii": "lingerpotturtlemasterii", + "tmaoepoiontii": "lingerpotturtlemasterii", + "tmaoepoiontstrong": "lingerpotturtlemasterii", + "tmaoepoiontlevelii": "lingerpotturtlemasterii", + "aoepotturtlemasterii": "lingerpotturtlemasterii", + "aoepotturtlemasterstrong": "lingerpotturtlemasterii", + "aoepotturtlemasterlevelii": "lingerpotturtlemasterii", + "aoepotturtleii": "lingerpotturtlemasterii", + "aoepotturtlestrong": "lingerpotturtlemasterii", + "aoepotturtlelevelii": "lingerpotturtlemasterii", + "aoepottmii": "lingerpotturtlemasterii", + "aoepottmstrong": "lingerpotturtlemasterii", + "aoepottmlevelii": "lingerpotturtlemasterii", + "turtlemasteraoepotii": "lingerpotturtlemasterii", + "turtlemasteraoepotstrong": "lingerpotturtlemasterii", + "turtlemasteraoepotlevelii": "lingerpotturtlemasterii", + "turtleaoepotii": "lingerpotturtlemasterii", + "turtleaoepotstrong": "lingerpotturtlemasterii", + "turtleaoepotlevelii": "lingerpotturtlemasterii", + "tmaoepotii": "lingerpotturtlemasterii", + "tmaoepotstrong": "lingerpotturtlemasterii", + "tmaoepotlevelii": "lingerpotturtlemasterii", + "areapotionturtlemasterii": "lingerpotturtlemasterii", + "areapotionturtlemasterstrong": "lingerpotturtlemasterii", + "areapotionturtlemasterlevelii": "lingerpotturtlemasterii", + "areapotionturtleii": "lingerpotturtlemasterii", + "areapotionturtlestrong": "lingerpotturtlemasterii", + "areapotionturtlelevelii": "lingerpotturtlemasterii", + "areapotiontmii": "lingerpotturtlemasterii", + "areapotiontmstrong": "lingerpotturtlemasterii", + "areapotiontmlevelii": "lingerpotturtlemasterii", + "turtlemasterareapotionii": "lingerpotturtlemasterii", + "turtlemasterareapotionstrong": "lingerpotturtlemasterii", + "turtlemasterareapotionlevelii": "lingerpotturtlemasterii", + "turtleareapotionii": "lingerpotturtlemasterii", + "turtleareapotionstrong": "lingerpotturtlemasterii", + "turtleareapotionlevelii": "lingerpotturtlemasterii", + "tmareapotionii": "lingerpotturtlemasterii", + "tmareapotionstrong": "lingerpotturtlemasterii", + "tmareapotionlevelii": "lingerpotturtlemasterii", + "areapotturtlemasterii": "lingerpotturtlemasterii", + "areapotturtlemasterstrong": "lingerpotturtlemasterii", + "areapotturtlemasterlevelii": "lingerpotturtlemasterii", + "areapotturtleii": "lingerpotturtlemasterii", + "areapotturtlestrong": "lingerpotturtlemasterii", + "areapotturtlelevelii": "lingerpotturtlemasterii", + "areapottmii": "lingerpotturtlemasterii", + "areapottmstrong": "lingerpotturtlemasterii", + "areapottmlevelii": "lingerpotturtlemasterii", + "turtlemasterareapotii": "lingerpotturtlemasterii", + "turtlemasterareapotstrong": "lingerpotturtlemasterii", + "turtlemasterareapotlevelii": "lingerpotturtlemasterii", + "turtleareapotii": "lingerpotturtlemasterii", + "turtleareapotstrong": "lingerpotturtlemasterii", + "turtleareapotlevelii": "lingerpotturtlemasterii", + "tmareapotii": "lingerpotturtlemasterii", + "tmareapotstrong": "lingerpotturtlemasterii", + "tmareapotlevelii": "lingerpotturtlemasterii", + "cloudpotionturtlemasterii": "lingerpotturtlemasterii", + "cloudpotionturtlemasterstrong": "lingerpotturtlemasterii", + "cloudpotionturtlemasterlevelii": "lingerpotturtlemasterii", + "cloudpotionturtleii": "lingerpotturtlemasterii", + "cloudpotionturtlestrong": "lingerpotturtlemasterii", + "cloudpotionturtlelevelii": "lingerpotturtlemasterii", + "cloudpotiontmii": "lingerpotturtlemasterii", + "cloudpotiontmstrong": "lingerpotturtlemasterii", + "cloudpotiontmlevelii": "lingerpotturtlemasterii", + "turtlemastercloudpotionii": "lingerpotturtlemasterii", + "turtlemastercloudpotionstrong": "lingerpotturtlemasterii", + "turtlemastercloudpotionlevelii": "lingerpotturtlemasterii", + "turtlecloudpotionii": "lingerpotturtlemasterii", + "turtlecloudpotionstrong": "lingerpotturtlemasterii", + "turtlecloudpotionlevelii": "lingerpotturtlemasterii", + "tmcloudpotionii": "lingerpotturtlemasterii", + "tmcloudpotionstrong": "lingerpotturtlemasterii", + "tmcloudpotionlevelii": "lingerpotturtlemasterii", + "cloudpotturtlemasterii": "lingerpotturtlemasterii", + "cloudpotturtlemasterstrong": "lingerpotturtlemasterii", + "cloudpotturtlemasterlevelii": "lingerpotturtlemasterii", + "cloudpotturtleii": "lingerpotturtlemasterii", + "cloudpotturtlestrong": "lingerpotturtlemasterii", + "cloudpotturtlelevelii": "lingerpotturtlemasterii", + "cloudpottmii": "lingerpotturtlemasterii", + "cloudpottmstrong": "lingerpotturtlemasterii", + "cloudpottmlevelii": "lingerpotturtlemasterii", + "turtlemastercloudpotii": "lingerpotturtlemasterii", + "turtlemastercloudpotstrong": "lingerpotturtlemasterii", + "turtlemastercloudpotlevelii": "lingerpotturtlemasterii", + "turtlecloudpotii": "lingerpotturtlemasterii", + "turtlecloudpotstrong": "lingerpotturtlemasterii", + "turtlecloudpotlevelii": "lingerpotturtlemasterii", + "tmcloudpotii": "lingerpotturtlemasterii", + "tmcloudpotstrong": "lingerpotturtlemasterii", + "tmcloudpotlevelii": "lingerpotturtlemasterii", + "arrowturtlemasterii": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "strong_turtle_master", + "bukkitType": "turtle_master", + "isStrong": true, + "isLong": false + } + }, + "arrowturtlemasterstrong": "arrowturtlemasterii", + "arrowturtlemasterlevelii": "arrowturtlemasterii", + "arrowturtleii": "arrowturtlemasterii", + "arrowturtlestrong": "arrowturtlemasterii", + "arrowturtlelevelii": "arrowturtlemasterii", + "arrowtmii": "arrowturtlemasterii", + "arrowtmstrong": "arrowturtlemasterii", + "arrowtmlevelii": "arrowturtlemasterii", + "turtlemasterarrowii": "arrowturtlemasterii", + "turtlemasterarrowstrong": "arrowturtlemasterii", + "turtlemasterarrowlevelii": "arrowturtlemasterii", + "turtlearrowii": "arrowturtlemasterii", + "turtlearrowstrong": "arrowturtlemasterii", + "turtlearrowlevelii": "arrowturtlemasterii", + "tmarrowii": "arrowturtlemasterii", + "tmarrowstrong": "arrowturtlemasterii", + "tmarrowlevelii": "arrowturtlemasterii", + "turtlemaster2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": true + } + }, + "turtlemasterlongpotion": "turtlemaster2potion", + "turtlemasterextendedpotion": "turtlemaster2potion", + "turtlemasterexpotion": "turtlemaster2potion", + "turtlemasterlevel2potion": "turtlemaster2potion", + "turtle2potion": "turtlemaster2potion", + "turtlelongpotion": "turtlemaster2potion", + "turtleextendedpotion": "turtlemaster2potion", + "turtleexpotion": "turtlemaster2potion", + "turtlelevel2potion": "turtlemaster2potion", + "tm2potion": "turtlemaster2potion", + "tmlongpotion": "turtlemaster2potion", + "tmextendedpotion": "turtlemaster2potion", + "tmexpotion": "turtlemaster2potion", + "tmlevel2potion": "turtlemaster2potion", + "turtlemaster2pot": "turtlemaster2potion", + "turtlemasterlongpot": "turtlemaster2potion", + "turtlemasterextendedpot": "turtlemaster2potion", + "turtlemasterexpot": "turtlemaster2potion", + "turtlemasterlevel2pot": "turtlemaster2potion", + "turtle2pot": "turtlemaster2potion", + "turtlelongpot": "turtlemaster2potion", + "turtleextendedpot": "turtlemaster2potion", + "turtleexpot": "turtlemaster2potion", + "turtlelevel2pot": "turtlemaster2potion", + "tm2pot": "turtlemaster2potion", + "tmlongpot": "turtlemaster2potion", + "tmextendedpot": "turtlemaster2potion", + "tmexpot": "turtlemaster2potion", + "tmlevel2pot": "turtlemaster2potion", + "potionofturtlemaster2": "turtlemaster2potion", + "potionofturtlemasterlong": "turtlemaster2potion", + "potionofturtlemasterextended": "turtlemaster2potion", + "potionofturtlemasterex": "turtlemaster2potion", + "potionofturtlemasterlevel2": "turtlemaster2potion", + "potionofturtle2": "turtlemaster2potion", + "potionofturtlelong": "turtlemaster2potion", + "potionofturtleextended": "turtlemaster2potion", + "potionofturtleex": "turtlemaster2potion", + "potionofturtlelevel2": "turtlemaster2potion", + "potionoftm2": "turtlemaster2potion", + "potionoftmlong": "turtlemaster2potion", + "potionoftmextended": "turtlemaster2potion", + "potionoftmex": "turtlemaster2potion", + "potionoftmlevel2": "turtlemaster2potion", + "potofturtlemaster2": "turtlemaster2potion", + "potofturtlemasterlong": "turtlemaster2potion", + "potofturtlemasterextended": "turtlemaster2potion", + "potofturtlemasterex": "turtlemaster2potion", + "potofturtlemasterlevel2": "turtlemaster2potion", + "potofturtle2": "turtlemaster2potion", + "potofturtlelong": "turtlemaster2potion", + "potofturtleextended": "turtlemaster2potion", + "potofturtleex": "turtlemaster2potion", + "potofturtlelevel2": "turtlemaster2potion", + "potoftm2": "turtlemaster2potion", + "potoftmlong": "turtlemaster2potion", + "potoftmextended": "turtlemaster2potion", + "potoftmex": "turtlemaster2potion", + "potoftmlevel2": "turtlemaster2potion", + "splashturtlemaster2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": true + } + }, + "splashturtlemasterlongpotion": "splashturtlemaster2potion", + "splashturtlemasterextendedpotion": "splashturtlemaster2potion", + "splashturtlemasterexpotion": "splashturtlemaster2potion", + "splashturtlemasterlevel2potion": "splashturtlemaster2potion", + "splashturtle2potion": "splashturtlemaster2potion", + "splashturtlelongpotion": "splashturtlemaster2potion", + "splashturtleextendedpotion": "splashturtlemaster2potion", + "splashturtleexpotion": "splashturtlemaster2potion", + "splashturtlelevel2potion": "splashturtlemaster2potion", + "splashtm2potion": "splashturtlemaster2potion", + "splashtmlongpotion": "splashturtlemaster2potion", + "splashtmextendedpotion": "splashturtlemaster2potion", + "splashtmexpotion": "splashturtlemaster2potion", + "splashtmlevel2potion": "splashturtlemaster2potion", + "splturtlemaster2potion": "splashturtlemaster2potion", + "splturtlemasterlongpotion": "splashturtlemaster2potion", + "splturtlemasterextendedpotion": "splashturtlemaster2potion", + "splturtlemasterexpotion": "splashturtlemaster2potion", + "splturtlemasterlevel2potion": "splashturtlemaster2potion", + "splturtle2potion": "splashturtlemaster2potion", + "splturtlelongpotion": "splashturtlemaster2potion", + "splturtleextendedpotion": "splashturtlemaster2potion", + "splturtleexpotion": "splashturtlemaster2potion", + "splturtlelevel2potion": "splashturtlemaster2potion", + "spltm2potion": "splashturtlemaster2potion", + "spltmlongpotion": "splashturtlemaster2potion", + "spltmextendedpotion": "splashturtlemaster2potion", + "spltmexpotion": "splashturtlemaster2potion", + "spltmlevel2potion": "splashturtlemaster2potion", + "turtlemaster2splashpotion": "splashturtlemaster2potion", + "turtlemasterlongsplashpotion": "splashturtlemaster2potion", + "turtlemasterextendedsplashpotion": "splashturtlemaster2potion", + "turtlemasterexsplashpotion": "splashturtlemaster2potion", + "turtlemasterlevel2splashpotion": "splashturtlemaster2potion", + "turtle2splashpotion": "splashturtlemaster2potion", + "turtlelongsplashpotion": "splashturtlemaster2potion", + "turtleextendedsplashpotion": "splashturtlemaster2potion", + "turtleexsplashpotion": "splashturtlemaster2potion", + "turtlelevel2splashpotion": "splashturtlemaster2potion", + "tm2splashpotion": "splashturtlemaster2potion", + "tmlongsplashpotion": "splashturtlemaster2potion", + "tmextendedsplashpotion": "splashturtlemaster2potion", + "tmexsplashpotion": "splashturtlemaster2potion", + "tmlevel2splashpotion": "splashturtlemaster2potion", + "splashturtlemaster2pot": "splashturtlemaster2potion", + "splashturtlemasterlongpot": "splashturtlemaster2potion", + "splashturtlemasterextendedpot": "splashturtlemaster2potion", + "splashturtlemasterexpot": "splashturtlemaster2potion", + "splashturtlemasterlevel2pot": "splashturtlemaster2potion", + "splashturtle2pot": "splashturtlemaster2potion", + "splashturtlelongpot": "splashturtlemaster2potion", + "splashturtleextendedpot": "splashturtlemaster2potion", + "splashturtleexpot": "splashturtlemaster2potion", + "splashturtlelevel2pot": "splashturtlemaster2potion", + "splashtm2pot": "splashturtlemaster2potion", + "splashtmlongpot": "splashturtlemaster2potion", + "splashtmextendedpot": "splashturtlemaster2potion", + "splashtmexpot": "splashturtlemaster2potion", + "splashtmlevel2pot": "splashturtlemaster2potion", + "splturtlemaster2pot": "splashturtlemaster2potion", + "splturtlemasterlongpot": "splashturtlemaster2potion", + "splturtlemasterextendedpot": "splashturtlemaster2potion", + "splturtlemasterexpot": "splashturtlemaster2potion", + "splturtlemasterlevel2pot": "splashturtlemaster2potion", + "splturtle2pot": "splashturtlemaster2potion", + "splturtlelongpot": "splashturtlemaster2potion", + "splturtleextendedpot": "splashturtlemaster2potion", + "splturtleexpot": "splashturtlemaster2potion", + "splturtlelevel2pot": "splashturtlemaster2potion", + "spltm2pot": "splashturtlemaster2potion", + "spltmlongpot": "splashturtlemaster2potion", + "spltmextendedpot": "splashturtlemaster2potion", + "spltmexpot": "splashturtlemaster2potion", + "spltmlevel2pot": "splashturtlemaster2potion", + "turtlemaster2splashpot": "splashturtlemaster2potion", + "turtlemasterlongsplashpot": "splashturtlemaster2potion", + "turtlemasterextendedsplashpot": "splashturtlemaster2potion", + "turtlemasterexsplashpot": "splashturtlemaster2potion", + "turtlemasterlevel2splashpot": "splashturtlemaster2potion", + "turtle2splashpot": "splashturtlemaster2potion", + "turtlelongsplashpot": "splashturtlemaster2potion", + "turtleextendedsplashpot": "splashturtlemaster2potion", + "turtleexsplashpot": "splashturtlemaster2potion", + "turtlelevel2splashpot": "splashturtlemaster2potion", + "tm2splashpot": "splashturtlemaster2potion", + "tmlongsplashpot": "splashturtlemaster2potion", + "tmextendedsplashpot": "splashturtlemaster2potion", + "tmexsplashpot": "splashturtlemaster2potion", + "tmlevel2splashpot": "splashturtlemaster2potion", + "lingerpotturtlemaster2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": true + } + }, + "lingerpotturtlemasterlong": "lingerpotturtlemaster2", + "lingerpotturtlemasterextended": "lingerpotturtlemaster2", + "lingerpotturtlemasterex": "lingerpotturtlemaster2", + "lingerpotturtlemasterlevel2": "lingerpotturtlemaster2", + "lingerpotturtle2": "lingerpotturtlemaster2", + "lingerpotturtlelong": "lingerpotturtlemaster2", + "lingerpotturtleextended": "lingerpotturtlemaster2", + "lingerpotturtleex": "lingerpotturtlemaster2", + "lingerpotturtlelevel2": "lingerpotturtlemaster2", + "lingerpottm2": "lingerpotturtlemaster2", + "lingerpottmlong": "lingerpotturtlemaster2", + "lingerpottmextended": "lingerpotturtlemaster2", + "lingerpottmex": "lingerpotturtlemaster2", + "lingerpottmlevel2": "lingerpotturtlemaster2", + "turtlemasterlingerpot2": "lingerpotturtlemaster2", + "turtlemasterlingerpotlong": "lingerpotturtlemaster2", + "turtlemasterlingerpotextended": "lingerpotturtlemaster2", + "turtlemasterlingerpotex": "lingerpotturtlemaster2", + "turtlemasterlingerpotlevel2": "lingerpotturtlemaster2", + "turtlelingerpot2": "lingerpotturtlemaster2", + "turtlelingerpotlong": "lingerpotturtlemaster2", + "turtlelingerpotextended": "lingerpotturtlemaster2", + "turtlelingerpotex": "lingerpotturtlemaster2", + "turtlelingerpotlevel2": "lingerpotturtlemaster2", + "tmlingerpot2": "lingerpotturtlemaster2", + "tmlingerpotlong": "lingerpotturtlemaster2", + "tmlingerpotextended": "lingerpotturtlemaster2", + "tmlingerpotex": "lingerpotturtlemaster2", + "tmlingerpotlevel2": "lingerpotturtlemaster2", + "aoepotionturtlemaster2": "lingerpotturtlemaster2", + "aoepotionturtlemasterlong": "lingerpotturtlemaster2", + "aoepotionturtlemasterextended": "lingerpotturtlemaster2", + "aoepotionturtlemasterex": "lingerpotturtlemaster2", + "aoepotionturtlemasterlevel2": "lingerpotturtlemaster2", + "aoepotionturtle2": "lingerpotturtlemaster2", + "aoepotionturtlelong": "lingerpotturtlemaster2", + "aoepotionturtleextended": "lingerpotturtlemaster2", + "aoepotionturtleex": "lingerpotturtlemaster2", + "aoepotionturtlelevel2": "lingerpotturtlemaster2", + "aoepotiontm2": "lingerpotturtlemaster2", + "aoepotiontmlong": "lingerpotturtlemaster2", + "aoepotiontmextended": "lingerpotturtlemaster2", + "aoepotiontmex": "lingerpotturtlemaster2", + "aoepotiontmlevel2": "lingerpotturtlemaster2", + "turtlemasteraoepoiont2": "lingerpotturtlemaster2", + "turtlemasteraoepoiontlong": "lingerpotturtlemaster2", + "turtlemasteraoepoiontextended": "lingerpotturtlemaster2", + "turtlemasteraoepoiontex": "lingerpotturtlemaster2", + "turtlemasteraoepoiontlevel2": "lingerpotturtlemaster2", + "turtleaoepoiont2": "lingerpotturtlemaster2", + "turtleaoepoiontlong": "lingerpotturtlemaster2", + "turtleaoepoiontextended": "lingerpotturtlemaster2", + "turtleaoepoiontex": "lingerpotturtlemaster2", + "turtleaoepoiontlevel2": "lingerpotturtlemaster2", + "tmaoepoiont2": "lingerpotturtlemaster2", + "tmaoepoiontlong": "lingerpotturtlemaster2", + "tmaoepoiontextended": "lingerpotturtlemaster2", + "tmaoepoiontex": "lingerpotturtlemaster2", + "tmaoepoiontlevel2": "lingerpotturtlemaster2", + "aoepotturtlemaster2": "lingerpotturtlemaster2", + "aoepotturtlemasterlong": "lingerpotturtlemaster2", + "aoepotturtlemasterextended": "lingerpotturtlemaster2", + "aoepotturtlemasterex": "lingerpotturtlemaster2", + "aoepotturtlemasterlevel2": "lingerpotturtlemaster2", + "aoepotturtle2": "lingerpotturtlemaster2", + "aoepotturtlelong": "lingerpotturtlemaster2", + "aoepotturtleextended": "lingerpotturtlemaster2", + "aoepotturtleex": "lingerpotturtlemaster2", + "aoepotturtlelevel2": "lingerpotturtlemaster2", + "aoepottm2": "lingerpotturtlemaster2", + "aoepottmlong": "lingerpotturtlemaster2", + "aoepottmextended": "lingerpotturtlemaster2", + "aoepottmex": "lingerpotturtlemaster2", + "aoepottmlevel2": "lingerpotturtlemaster2", + "turtlemasteraoepot2": "lingerpotturtlemaster2", + "turtlemasteraoepotlong": "lingerpotturtlemaster2", + "turtlemasteraoepotextended": "lingerpotturtlemaster2", + "turtlemasteraoepotex": "lingerpotturtlemaster2", + "turtlemasteraoepotlevel2": "lingerpotturtlemaster2", + "turtleaoepot2": "lingerpotturtlemaster2", + "turtleaoepotlong": "lingerpotturtlemaster2", + "turtleaoepotextended": "lingerpotturtlemaster2", + "turtleaoepotex": "lingerpotturtlemaster2", + "turtleaoepotlevel2": "lingerpotturtlemaster2", + "tmaoepot2": "lingerpotturtlemaster2", + "tmaoepotlong": "lingerpotturtlemaster2", + "tmaoepotextended": "lingerpotturtlemaster2", + "tmaoepotex": "lingerpotturtlemaster2", + "tmaoepotlevel2": "lingerpotturtlemaster2", + "areapotionturtlemaster2": "lingerpotturtlemaster2", + "areapotionturtlemasterlong": "lingerpotturtlemaster2", + "areapotionturtlemasterextended": "lingerpotturtlemaster2", + "areapotionturtlemasterex": "lingerpotturtlemaster2", + "areapotionturtlemasterlevel2": "lingerpotturtlemaster2", + "areapotionturtle2": "lingerpotturtlemaster2", + "areapotionturtlelong": "lingerpotturtlemaster2", + "areapotionturtleextended": "lingerpotturtlemaster2", + "areapotionturtleex": "lingerpotturtlemaster2", + "areapotionturtlelevel2": "lingerpotturtlemaster2", + "areapotiontm2": "lingerpotturtlemaster2", + "areapotiontmlong": "lingerpotturtlemaster2", + "areapotiontmextended": "lingerpotturtlemaster2", + "areapotiontmex": "lingerpotturtlemaster2", + "areapotiontmlevel2": "lingerpotturtlemaster2", + "turtlemasterareapotion2": "lingerpotturtlemaster2", + "turtlemasterareapotionlong": "lingerpotturtlemaster2", + "turtlemasterareapotionextended": "lingerpotturtlemaster2", + "turtlemasterareapotionex": "lingerpotturtlemaster2", + "turtlemasterareapotionlevel2": "lingerpotturtlemaster2", + "turtleareapotion2": "lingerpotturtlemaster2", + "turtleareapotionlong": "lingerpotturtlemaster2", + "turtleareapotionextended": "lingerpotturtlemaster2", + "turtleareapotionex": "lingerpotturtlemaster2", + "turtleareapotionlevel2": "lingerpotturtlemaster2", + "tmareapotion2": "lingerpotturtlemaster2", + "tmareapotionlong": "lingerpotturtlemaster2", + "tmareapotionextended": "lingerpotturtlemaster2", + "tmareapotionex": "lingerpotturtlemaster2", + "tmareapotionlevel2": "lingerpotturtlemaster2", + "areapotturtlemaster2": "lingerpotturtlemaster2", + "areapotturtlemasterlong": "lingerpotturtlemaster2", + "areapotturtlemasterextended": "lingerpotturtlemaster2", + "areapotturtlemasterex": "lingerpotturtlemaster2", + "areapotturtlemasterlevel2": "lingerpotturtlemaster2", + "areapotturtle2": "lingerpotturtlemaster2", + "areapotturtlelong": "lingerpotturtlemaster2", + "areapotturtleextended": "lingerpotturtlemaster2", + "areapotturtleex": "lingerpotturtlemaster2", + "areapotturtlelevel2": "lingerpotturtlemaster2", + "areapottm2": "lingerpotturtlemaster2", + "areapottmlong": "lingerpotturtlemaster2", + "areapottmextended": "lingerpotturtlemaster2", + "areapottmex": "lingerpotturtlemaster2", + "areapottmlevel2": "lingerpotturtlemaster2", + "turtlemasterareapot2": "lingerpotturtlemaster2", + "turtlemasterareapotlong": "lingerpotturtlemaster2", + "turtlemasterareapotextended": "lingerpotturtlemaster2", + "turtlemasterareapotex": "lingerpotturtlemaster2", + "turtlemasterareapotlevel2": "lingerpotturtlemaster2", + "turtleareapot2": "lingerpotturtlemaster2", + "turtleareapotlong": "lingerpotturtlemaster2", + "turtleareapotextended": "lingerpotturtlemaster2", + "turtleareapotex": "lingerpotturtlemaster2", + "turtleareapotlevel2": "lingerpotturtlemaster2", + "tmareapot2": "lingerpotturtlemaster2", + "tmareapotlong": "lingerpotturtlemaster2", + "tmareapotextended": "lingerpotturtlemaster2", + "tmareapotex": "lingerpotturtlemaster2", + "tmareapotlevel2": "lingerpotturtlemaster2", + "cloudpotionturtlemaster2": "lingerpotturtlemaster2", + "cloudpotionturtlemasterlong": "lingerpotturtlemaster2", + "cloudpotionturtlemasterextended": "lingerpotturtlemaster2", + "cloudpotionturtlemasterex": "lingerpotturtlemaster2", + "cloudpotionturtlemasterlevel2": "lingerpotturtlemaster2", + "cloudpotionturtle2": "lingerpotturtlemaster2", + "cloudpotionturtlelong": "lingerpotturtlemaster2", + "cloudpotionturtleextended": "lingerpotturtlemaster2", + "cloudpotionturtleex": "lingerpotturtlemaster2", + "cloudpotionturtlelevel2": "lingerpotturtlemaster2", + "cloudpotiontm2": "lingerpotturtlemaster2", + "cloudpotiontmlong": "lingerpotturtlemaster2", + "cloudpotiontmextended": "lingerpotturtlemaster2", + "cloudpotiontmex": "lingerpotturtlemaster2", + "cloudpotiontmlevel2": "lingerpotturtlemaster2", + "turtlemastercloudpotion2": "lingerpotturtlemaster2", + "turtlemastercloudpotionlong": "lingerpotturtlemaster2", + "turtlemastercloudpotionextended": "lingerpotturtlemaster2", + "turtlemastercloudpotionex": "lingerpotturtlemaster2", + "turtlemastercloudpotionlevel2": "lingerpotturtlemaster2", + "turtlecloudpotion2": "lingerpotturtlemaster2", + "turtlecloudpotionlong": "lingerpotturtlemaster2", + "turtlecloudpotionextended": "lingerpotturtlemaster2", + "turtlecloudpotionex": "lingerpotturtlemaster2", + "turtlecloudpotionlevel2": "lingerpotturtlemaster2", + "tmcloudpotion2": "lingerpotturtlemaster2", + "tmcloudpotionlong": "lingerpotturtlemaster2", + "tmcloudpotionextended": "lingerpotturtlemaster2", + "tmcloudpotionex": "lingerpotturtlemaster2", + "tmcloudpotionlevel2": "lingerpotturtlemaster2", + "cloudpotturtlemaster2": "lingerpotturtlemaster2", + "cloudpotturtlemasterlong": "lingerpotturtlemaster2", + "cloudpotturtlemasterextended": "lingerpotturtlemaster2", + "cloudpotturtlemasterex": "lingerpotturtlemaster2", + "cloudpotturtlemasterlevel2": "lingerpotturtlemaster2", + "cloudpotturtle2": "lingerpotturtlemaster2", + "cloudpotturtlelong": "lingerpotturtlemaster2", + "cloudpotturtleextended": "lingerpotturtlemaster2", + "cloudpotturtleex": "lingerpotturtlemaster2", + "cloudpotturtlelevel2": "lingerpotturtlemaster2", + "cloudpottm2": "lingerpotturtlemaster2", + "cloudpottmlong": "lingerpotturtlemaster2", + "cloudpottmextended": "lingerpotturtlemaster2", + "cloudpottmex": "lingerpotturtlemaster2", + "cloudpottmlevel2": "lingerpotturtlemaster2", + "turtlemastercloudpot2": "lingerpotturtlemaster2", + "turtlemastercloudpotlong": "lingerpotturtlemaster2", + "turtlemastercloudpotextended": "lingerpotturtlemaster2", + "turtlemastercloudpotex": "lingerpotturtlemaster2", + "turtlemastercloudpotlevel2": "lingerpotturtlemaster2", + "turtlecloudpot2": "lingerpotturtlemaster2", + "turtlecloudpotlong": "lingerpotturtlemaster2", + "turtlecloudpotextended": "lingerpotturtlemaster2", + "turtlecloudpotex": "lingerpotturtlemaster2", + "turtlecloudpotlevel2": "lingerpotturtlemaster2", + "tmcloudpot2": "lingerpotturtlemaster2", + "tmcloudpotlong": "lingerpotturtlemaster2", + "tmcloudpotextended": "lingerpotturtlemaster2", + "tmcloudpotex": "lingerpotturtlemaster2", + "tmcloudpotlevel2": "lingerpotturtlemaster2", + "arrowturtlemaster2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_turtle_master", + "bukkitType": "turtle_master", + "isStrong": false, + "isLong": true + } + }, + "arrowturtlemasterlong": "arrowturtlemaster2", + "arrowturtlemasterextended": "arrowturtlemaster2", + "arrowturtlemasterex": "arrowturtlemaster2", + "arrowturtlemasterlevel2": "arrowturtlemaster2", + "arrowturtle2": "arrowturtlemaster2", + "arrowturtlelong": "arrowturtlemaster2", + "arrowturtleextended": "arrowturtlemaster2", + "arrowturtleex": "arrowturtlemaster2", + "arrowturtlelevel2": "arrowturtlemaster2", + "arrowtm2": "arrowturtlemaster2", + "arrowtmlong": "arrowturtlemaster2", + "arrowtmextended": "arrowturtlemaster2", + "arrowtmex": "arrowturtlemaster2", + "arrowtmlevel2": "arrowturtlemaster2", + "turtlemasterarrow2": "arrowturtlemaster2", + "turtlemasterarrowlong": "arrowturtlemaster2", + "turtlemasterarrowextended": "arrowturtlemaster2", + "turtlemasterarrowex": "arrowturtlemaster2", + "turtlemasterarrowlevel2": "arrowturtlemaster2", + "turtlearrow2": "arrowturtlemaster2", + "turtlearrowlong": "arrowturtlemaster2", + "turtlearrowextended": "arrowturtlemaster2", + "turtlearrowex": "arrowturtlemaster2", + "turtlearrowlevel2": "arrowturtlemaster2", + "tmarrow2": "arrowturtlemaster2", + "tmarrowlong": "arrowturtlemaster2", + "tmarrowextended": "arrowturtlemaster2", + "tmarrowex": "arrowturtlemaster2", + "tmarrowlevel2": "arrowturtlemaster2", + "slowfallingpotion": { + "material": "POTION", + "potionData": { + "vanillaType": "slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": false + } + }, + "slowfallpotion": "slowfallingpotion", + "sfpotion": "slowfallingpotion", + "slowfallingpot": "slowfallingpotion", + "slowfallpot": "slowfallingpotion", + "sfpot": "slowfallingpotion", + "potionofslowfalling": "slowfallingpotion", + "potionofslowfall": "slowfallingpotion", + "potionofsf": "slowfallingpotion", + "potofslowfalling": "slowfallingpotion", + "potofslowfall": "slowfallingpotion", + "potofsf": "slowfallingpotion", + "splashslowfallingpotion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": false + } + }, + "splashslowfallpotion": "splashslowfallingpotion", + "splashsfpotion": "splashslowfallingpotion", + "splslowfallingpotion": "splashslowfallingpotion", + "splslowfallpotion": "splashslowfallingpotion", + "splsfpotion": "splashslowfallingpotion", + "slowfallingsplashpotion": "splashslowfallingpotion", + "slowfallsplashpotion": "splashslowfallingpotion", + "sfsplashpotion": "splashslowfallingpotion", + "splashslowfallingpot": "splashslowfallingpotion", + "splashslowfallpot": "splashslowfallingpotion", + "splashsfpot": "splashslowfallingpotion", + "splslowfallingpot": "splashslowfallingpotion", + "splslowfallpot": "splashslowfallingpotion", + "splsfpot": "splashslowfallingpotion", + "slowfallingsplashpot": "splashslowfallingpotion", + "slowfallsplashpot": "splashslowfallingpotion", + "sfsplashpot": "splashslowfallingpotion", + "lingerpotslowfalling": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": false + } + }, + "lingerpotslowfall": "lingerpotslowfalling", + "lingerpotsf": "lingerpotslowfalling", + "slowfallinglingerpot": "lingerpotslowfalling", + "slowfalllingerpot": "lingerpotslowfalling", + "sflingerpot": "lingerpotslowfalling", + "aoepotionslowfalling": "lingerpotslowfalling", + "aoepotionslowfall": "lingerpotslowfalling", + "aoepotionsf": "lingerpotslowfalling", + "slowfallingaoepoiont": "lingerpotslowfalling", + "slowfallaoepoiont": "lingerpotslowfalling", + "sfaoepoiont": "lingerpotslowfalling", + "aoepotslowfalling": "lingerpotslowfalling", + "aoepotslowfall": "lingerpotslowfalling", + "aoepotsf": "lingerpotslowfalling", + "slowfallingaoepot": "lingerpotslowfalling", + "slowfallaoepot": "lingerpotslowfalling", + "sfaoepot": "lingerpotslowfalling", + "areapotionslowfalling": "lingerpotslowfalling", + "areapotionslowfall": "lingerpotslowfalling", + "areapotionsf": "lingerpotslowfalling", + "slowfallingareapotion": "lingerpotslowfalling", + "slowfallareapotion": "lingerpotslowfalling", + "sfareapotion": "lingerpotslowfalling", + "areapotslowfalling": "lingerpotslowfalling", + "areapotslowfall": "lingerpotslowfalling", + "areapotsf": "lingerpotslowfalling", + "slowfallingareapot": "lingerpotslowfalling", + "slowfallareapot": "lingerpotslowfalling", + "sfareapot": "lingerpotslowfalling", + "cloudpotionslowfalling": "lingerpotslowfalling", + "cloudpotionslowfall": "lingerpotslowfalling", + "cloudpotionsf": "lingerpotslowfalling", + "slowfallingcloudpotion": "lingerpotslowfalling", + "slowfallcloudpotion": "lingerpotslowfalling", + "sfcloudpotion": "lingerpotslowfalling", + "cloudpotslowfalling": "lingerpotslowfalling", + "cloudpotslowfall": "lingerpotslowfalling", + "cloudpotsf": "lingerpotslowfalling", + "slowfallingcloudpot": "lingerpotslowfalling", + "slowfallcloudpot": "lingerpotslowfalling", + "sfcloudpot": "lingerpotslowfalling", + "arrowslowfalling": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": false + } + }, + "arrowslowfall": "arrowslowfalling", + "arrowsf": "arrowslowfalling", + "slowfallingarrow": "arrowslowfalling", + "slowfallarrow": "arrowslowfalling", + "sfarrow": "arrowslowfalling", + "slowfalling2potion": { + "material": "POTION", + "potionData": { + "vanillaType": "long_slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": true + } + }, + "slowfallinglongpotion": "slowfalling2potion", + "slowfallingextendedpotion": "slowfalling2potion", + "slowfallingexpotion": "slowfalling2potion", + "slowfallinglevel2potion": "slowfalling2potion", + "slowfall2potion": "slowfalling2potion", + "slowfalllongpotion": "slowfalling2potion", + "slowfallextendedpotion": "slowfalling2potion", + "slowfallexpotion": "slowfalling2potion", + "slowfalllevel2potion": "slowfalling2potion", + "sf2potion": "slowfalling2potion", + "sflongpotion": "slowfalling2potion", + "sfextendedpotion": "slowfalling2potion", + "sfexpotion": "slowfalling2potion", + "sflevel2potion": "slowfalling2potion", + "slowfalling2pot": "slowfalling2potion", + "slowfallinglongpot": "slowfalling2potion", + "slowfallingextendedpot": "slowfalling2potion", + "slowfallingexpot": "slowfalling2potion", + "slowfallinglevel2pot": "slowfalling2potion", + "slowfall2pot": "slowfalling2potion", + "slowfalllongpot": "slowfalling2potion", + "slowfallextendedpot": "slowfalling2potion", + "slowfallexpot": "slowfalling2potion", + "slowfalllevel2pot": "slowfalling2potion", + "sf2pot": "slowfalling2potion", + "sflongpot": "slowfalling2potion", + "sfextendedpot": "slowfalling2potion", + "sfexpot": "slowfalling2potion", + "sflevel2pot": "slowfalling2potion", + "potionofslowfalling2": "slowfalling2potion", + "potionofslowfallinglong": "slowfalling2potion", + "potionofslowfallingextended": "slowfalling2potion", + "potionofslowfallingex": "slowfalling2potion", + "potionofslowfallinglevel2": "slowfalling2potion", + "potionofslowfall2": "slowfalling2potion", + "potionofslowfalllong": "slowfalling2potion", + "potionofslowfallextended": "slowfalling2potion", + "potionofslowfallex": "slowfalling2potion", + "potionofslowfalllevel2": "slowfalling2potion", + "potionofsf2": "slowfalling2potion", + "potionofsflong": "slowfalling2potion", + "potionofsfextended": "slowfalling2potion", + "potionofsfex": "slowfalling2potion", + "potionofsflevel2": "slowfalling2potion", + "potofslowfalling2": "slowfalling2potion", + "potofslowfallinglong": "slowfalling2potion", + "potofslowfallingextended": "slowfalling2potion", + "potofslowfallingex": "slowfalling2potion", + "potofslowfallinglevel2": "slowfalling2potion", + "potofslowfall2": "slowfalling2potion", + "potofslowfalllong": "slowfalling2potion", + "potofslowfallextended": "slowfalling2potion", + "potofslowfallex": "slowfalling2potion", + "potofslowfalllevel2": "slowfalling2potion", + "potofsf2": "slowfalling2potion", + "potofsflong": "slowfalling2potion", + "potofsfextended": "slowfalling2potion", + "potofsfex": "slowfalling2potion", + "potofsflevel2": "slowfalling2potion", + "splashslowfalling2potion": { + "material": "SPLASH_POTION", + "potionData": { + "vanillaType": "long_slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": true + } + }, + "splashslowfallinglongpotion": "splashslowfalling2potion", + "splashslowfallingextendedpotion": "splashslowfalling2potion", + "splashslowfallingexpotion": "splashslowfalling2potion", + "splashslowfallinglevel2potion": "splashslowfalling2potion", + "splashslowfall2potion": "splashslowfalling2potion", + "splashslowfalllongpotion": "splashslowfalling2potion", + "splashslowfallextendedpotion": "splashslowfalling2potion", + "splashslowfallexpotion": "splashslowfalling2potion", + "splashslowfalllevel2potion": "splashslowfalling2potion", + "splashsf2potion": "splashslowfalling2potion", + "splashsflongpotion": "splashslowfalling2potion", + "splashsfextendedpotion": "splashslowfalling2potion", + "splashsfexpotion": "splashslowfalling2potion", + "splashsflevel2potion": "splashslowfalling2potion", + "splslowfalling2potion": "splashslowfalling2potion", + "splslowfallinglongpotion": "splashslowfalling2potion", + "splslowfallingextendedpotion": "splashslowfalling2potion", + "splslowfallingexpotion": "splashslowfalling2potion", + "splslowfallinglevel2potion": "splashslowfalling2potion", + "splslowfall2potion": "splashslowfalling2potion", + "splslowfalllongpotion": "splashslowfalling2potion", + "splslowfallextendedpotion": "splashslowfalling2potion", + "splslowfallexpotion": "splashslowfalling2potion", + "splslowfalllevel2potion": "splashslowfalling2potion", + "splsf2potion": "splashslowfalling2potion", + "splsflongpotion": "splashslowfalling2potion", + "splsfextendedpotion": "splashslowfalling2potion", + "splsfexpotion": "splashslowfalling2potion", + "splsflevel2potion": "splashslowfalling2potion", + "slowfalling2splashpotion": "splashslowfalling2potion", + "slowfallinglongsplashpotion": "splashslowfalling2potion", + "slowfallingextendedsplashpotion": "splashslowfalling2potion", + "slowfallingexsplashpotion": "splashslowfalling2potion", + "slowfallinglevel2splashpotion": "splashslowfalling2potion", + "slowfall2splashpotion": "splashslowfalling2potion", + "slowfalllongsplashpotion": "splashslowfalling2potion", + "slowfallextendedsplashpotion": "splashslowfalling2potion", + "slowfallexsplashpotion": "splashslowfalling2potion", + "slowfalllevel2splashpotion": "splashslowfalling2potion", + "sf2splashpotion": "splashslowfalling2potion", + "sflongsplashpotion": "splashslowfalling2potion", + "sfextendedsplashpotion": "splashslowfalling2potion", + "sfexsplashpotion": "splashslowfalling2potion", + "sflevel2splashpotion": "splashslowfalling2potion", + "splashslowfalling2pot": "splashslowfalling2potion", + "splashslowfallinglongpot": "splashslowfalling2potion", + "splashslowfallingextendedpot": "splashslowfalling2potion", + "splashslowfallingexpot": "splashslowfalling2potion", + "splashslowfallinglevel2pot": "splashslowfalling2potion", + "splashslowfall2pot": "splashslowfalling2potion", + "splashslowfalllongpot": "splashslowfalling2potion", + "splashslowfallextendedpot": "splashslowfalling2potion", + "splashslowfallexpot": "splashslowfalling2potion", + "splashslowfalllevel2pot": "splashslowfalling2potion", + "splashsf2pot": "splashslowfalling2potion", + "splashsflongpot": "splashslowfalling2potion", + "splashsfextendedpot": "splashslowfalling2potion", + "splashsfexpot": "splashslowfalling2potion", + "splashsflevel2pot": "splashslowfalling2potion", + "splslowfalling2pot": "splashslowfalling2potion", + "splslowfallinglongpot": "splashslowfalling2potion", + "splslowfallingextendedpot": "splashslowfalling2potion", + "splslowfallingexpot": "splashslowfalling2potion", + "splslowfallinglevel2pot": "splashslowfalling2potion", + "splslowfall2pot": "splashslowfalling2potion", + "splslowfalllongpot": "splashslowfalling2potion", + "splslowfallextendedpot": "splashslowfalling2potion", + "splslowfallexpot": "splashslowfalling2potion", + "splslowfalllevel2pot": "splashslowfalling2potion", + "splsf2pot": "splashslowfalling2potion", + "splsflongpot": "splashslowfalling2potion", + "splsfextendedpot": "splashslowfalling2potion", + "splsfexpot": "splashslowfalling2potion", + "splsflevel2pot": "splashslowfalling2potion", + "slowfalling2splashpot": "splashslowfalling2potion", + "slowfallinglongsplashpot": "splashslowfalling2potion", + "slowfallingextendedsplashpot": "splashslowfalling2potion", + "slowfallingexsplashpot": "splashslowfalling2potion", + "slowfallinglevel2splashpot": "splashslowfalling2potion", + "slowfall2splashpot": "splashslowfalling2potion", + "slowfalllongsplashpot": "splashslowfalling2potion", + "slowfallextendedsplashpot": "splashslowfalling2potion", + "slowfallexsplashpot": "splashslowfalling2potion", + "slowfalllevel2splashpot": "splashslowfalling2potion", + "sf2splashpot": "splashslowfalling2potion", + "sflongsplashpot": "splashslowfalling2potion", + "sfextendedsplashpot": "splashslowfalling2potion", + "sfexsplashpot": "splashslowfalling2potion", + "sflevel2splashpot": "splashslowfalling2potion", + "lingerpotslowfalling2": { + "material": "LINGERING_POTION", + "potionData": { + "vanillaType": "long_slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": true + } + }, + "lingerpotslowfallinglong": "lingerpotslowfalling2", + "lingerpotslowfallingextended": "lingerpotslowfalling2", + "lingerpotslowfallingex": "lingerpotslowfalling2", + "lingerpotslowfallinglevel2": "lingerpotslowfalling2", + "lingerpotslowfall2": "lingerpotslowfalling2", + "lingerpotslowfalllong": "lingerpotslowfalling2", + "lingerpotslowfallextended": "lingerpotslowfalling2", + "lingerpotslowfallex": "lingerpotslowfalling2", + "lingerpotslowfalllevel2": "lingerpotslowfalling2", + "lingerpotsf2": "lingerpotslowfalling2", + "lingerpotsflong": "lingerpotslowfalling2", + "lingerpotsfextended": "lingerpotslowfalling2", + "lingerpotsfex": "lingerpotslowfalling2", + "lingerpotsflevel2": "lingerpotslowfalling2", + "slowfallinglingerpot2": "lingerpotslowfalling2", + "slowfallinglingerpotlong": "lingerpotslowfalling2", + "slowfallinglingerpotextended": "lingerpotslowfalling2", + "slowfallinglingerpotex": "lingerpotslowfalling2", + "slowfallinglingerpotlevel2": "lingerpotslowfalling2", + "slowfalllingerpot2": "lingerpotslowfalling2", + "slowfalllingerpotlong": "lingerpotslowfalling2", + "slowfalllingerpotextended": "lingerpotslowfalling2", + "slowfalllingerpotex": "lingerpotslowfalling2", + "slowfalllingerpotlevel2": "lingerpotslowfalling2", + "sflingerpot2": "lingerpotslowfalling2", + "sflingerpotlong": "lingerpotslowfalling2", + "sflingerpotextended": "lingerpotslowfalling2", + "sflingerpotex": "lingerpotslowfalling2", + "sflingerpotlevel2": "lingerpotslowfalling2", + "aoepotionslowfalling2": "lingerpotslowfalling2", + "aoepotionslowfallinglong": "lingerpotslowfalling2", + "aoepotionslowfallingextended": "lingerpotslowfalling2", + "aoepotionslowfallingex": "lingerpotslowfalling2", + "aoepotionslowfallinglevel2": "lingerpotslowfalling2", + "aoepotionslowfall2": "lingerpotslowfalling2", + "aoepotionslowfalllong": "lingerpotslowfalling2", + "aoepotionslowfallextended": "lingerpotslowfalling2", + "aoepotionslowfallex": "lingerpotslowfalling2", + "aoepotionslowfalllevel2": "lingerpotslowfalling2", + "aoepotionsf2": "lingerpotslowfalling2", + "aoepotionsflong": "lingerpotslowfalling2", + "aoepotionsfextended": "lingerpotslowfalling2", + "aoepotionsfex": "lingerpotslowfalling2", + "aoepotionsflevel2": "lingerpotslowfalling2", + "slowfallingaoepoiont2": "lingerpotslowfalling2", + "slowfallingaoepoiontlong": "lingerpotslowfalling2", + "slowfallingaoepoiontextended": "lingerpotslowfalling2", + "slowfallingaoepoiontex": "lingerpotslowfalling2", + "slowfallingaoepoiontlevel2": "lingerpotslowfalling2", + "slowfallaoepoiont2": "lingerpotslowfalling2", + "slowfallaoepoiontlong": "lingerpotslowfalling2", + "slowfallaoepoiontextended": "lingerpotslowfalling2", + "slowfallaoepoiontex": "lingerpotslowfalling2", + "slowfallaoepoiontlevel2": "lingerpotslowfalling2", + "sfaoepoiont2": "lingerpotslowfalling2", + "sfaoepoiontlong": "lingerpotslowfalling2", + "sfaoepoiontextended": "lingerpotslowfalling2", + "sfaoepoiontex": "lingerpotslowfalling2", + "sfaoepoiontlevel2": "lingerpotslowfalling2", + "aoepotslowfalling2": "lingerpotslowfalling2", + "aoepotslowfallinglong": "lingerpotslowfalling2", + "aoepotslowfallingextended": "lingerpotslowfalling2", + "aoepotslowfallingex": "lingerpotslowfalling2", + "aoepotslowfallinglevel2": "lingerpotslowfalling2", + "aoepotslowfall2": "lingerpotslowfalling2", + "aoepotslowfalllong": "lingerpotslowfalling2", + "aoepotslowfallextended": "lingerpotslowfalling2", + "aoepotslowfallex": "lingerpotslowfalling2", + "aoepotslowfalllevel2": "lingerpotslowfalling2", + "aoepotsf2": "lingerpotslowfalling2", + "aoepotsflong": "lingerpotslowfalling2", + "aoepotsfextended": "lingerpotslowfalling2", + "aoepotsfex": "lingerpotslowfalling2", + "aoepotsflevel2": "lingerpotslowfalling2", + "slowfallingaoepot2": "lingerpotslowfalling2", + "slowfallingaoepotlong": "lingerpotslowfalling2", + "slowfallingaoepotextended": "lingerpotslowfalling2", + "slowfallingaoepotex": "lingerpotslowfalling2", + "slowfallingaoepotlevel2": "lingerpotslowfalling2", + "slowfallaoepot2": "lingerpotslowfalling2", + "slowfallaoepotlong": "lingerpotslowfalling2", + "slowfallaoepotextended": "lingerpotslowfalling2", + "slowfallaoepotex": "lingerpotslowfalling2", + "slowfallaoepotlevel2": "lingerpotslowfalling2", + "sfaoepot2": "lingerpotslowfalling2", + "sfaoepotlong": "lingerpotslowfalling2", + "sfaoepotextended": "lingerpotslowfalling2", + "sfaoepotex": "lingerpotslowfalling2", + "sfaoepotlevel2": "lingerpotslowfalling2", + "areapotionslowfalling2": "lingerpotslowfalling2", + "areapotionslowfallinglong": "lingerpotslowfalling2", + "areapotionslowfallingextended": "lingerpotslowfalling2", + "areapotionslowfallingex": "lingerpotslowfalling2", + "areapotionslowfallinglevel2": "lingerpotslowfalling2", + "areapotionslowfall2": "lingerpotslowfalling2", + "areapotionslowfalllong": "lingerpotslowfalling2", + "areapotionslowfallextended": "lingerpotslowfalling2", + "areapotionslowfallex": "lingerpotslowfalling2", + "areapotionslowfalllevel2": "lingerpotslowfalling2", + "areapotionsf2": "lingerpotslowfalling2", + "areapotionsflong": "lingerpotslowfalling2", + "areapotionsfextended": "lingerpotslowfalling2", + "areapotionsfex": "lingerpotslowfalling2", + "areapotionsflevel2": "lingerpotslowfalling2", + "slowfallingareapotion2": "lingerpotslowfalling2", + "slowfallingareapotionlong": "lingerpotslowfalling2", + "slowfallingareapotionextended": "lingerpotslowfalling2", + "slowfallingareapotionex": "lingerpotslowfalling2", + "slowfallingareapotionlevel2": "lingerpotslowfalling2", + "slowfallareapotion2": "lingerpotslowfalling2", + "slowfallareapotionlong": "lingerpotslowfalling2", + "slowfallareapotionextended": "lingerpotslowfalling2", + "slowfallareapotionex": "lingerpotslowfalling2", + "slowfallareapotionlevel2": "lingerpotslowfalling2", + "sfareapotion2": "lingerpotslowfalling2", + "sfareapotionlong": "lingerpotslowfalling2", + "sfareapotionextended": "lingerpotslowfalling2", + "sfareapotionex": "lingerpotslowfalling2", + "sfareapotionlevel2": "lingerpotslowfalling2", + "areapotslowfalling2": "lingerpotslowfalling2", + "areapotslowfallinglong": "lingerpotslowfalling2", + "areapotslowfallingextended": "lingerpotslowfalling2", + "areapotslowfallingex": "lingerpotslowfalling2", + "areapotslowfallinglevel2": "lingerpotslowfalling2", + "areapotslowfall2": "lingerpotslowfalling2", + "areapotslowfalllong": "lingerpotslowfalling2", + "areapotslowfallextended": "lingerpotslowfalling2", + "areapotslowfallex": "lingerpotslowfalling2", + "areapotslowfalllevel2": "lingerpotslowfalling2", + "areapotsf2": "lingerpotslowfalling2", + "areapotsflong": "lingerpotslowfalling2", + "areapotsfextended": "lingerpotslowfalling2", + "areapotsfex": "lingerpotslowfalling2", + "areapotsflevel2": "lingerpotslowfalling2", + "slowfallingareapot2": "lingerpotslowfalling2", + "slowfallingareapotlong": "lingerpotslowfalling2", + "slowfallingareapotextended": "lingerpotslowfalling2", + "slowfallingareapotex": "lingerpotslowfalling2", + "slowfallingareapotlevel2": "lingerpotslowfalling2", + "slowfallareapot2": "lingerpotslowfalling2", + "slowfallareapotlong": "lingerpotslowfalling2", + "slowfallareapotextended": "lingerpotslowfalling2", + "slowfallareapotex": "lingerpotslowfalling2", + "slowfallareapotlevel2": "lingerpotslowfalling2", + "sfareapot2": "lingerpotslowfalling2", + "sfareapotlong": "lingerpotslowfalling2", + "sfareapotextended": "lingerpotslowfalling2", + "sfareapotex": "lingerpotslowfalling2", + "sfareapotlevel2": "lingerpotslowfalling2", + "cloudpotionslowfalling2": "lingerpotslowfalling2", + "cloudpotionslowfallinglong": "lingerpotslowfalling2", + "cloudpotionslowfallingextended": "lingerpotslowfalling2", + "cloudpotionslowfallingex": "lingerpotslowfalling2", + "cloudpotionslowfallinglevel2": "lingerpotslowfalling2", + "cloudpotionslowfall2": "lingerpotslowfalling2", + "cloudpotionslowfalllong": "lingerpotslowfalling2", + "cloudpotionslowfallextended": "lingerpotslowfalling2", + "cloudpotionslowfallex": "lingerpotslowfalling2", + "cloudpotionslowfalllevel2": "lingerpotslowfalling2", + "cloudpotionsf2": "lingerpotslowfalling2", + "cloudpotionsflong": "lingerpotslowfalling2", + "cloudpotionsfextended": "lingerpotslowfalling2", + "cloudpotionsfex": "lingerpotslowfalling2", + "cloudpotionsflevel2": "lingerpotslowfalling2", + "slowfallingcloudpotion2": "lingerpotslowfalling2", + "slowfallingcloudpotionlong": "lingerpotslowfalling2", + "slowfallingcloudpotionextended": "lingerpotslowfalling2", + "slowfallingcloudpotionex": "lingerpotslowfalling2", + "slowfallingcloudpotionlevel2": "lingerpotslowfalling2", + "slowfallcloudpotion2": "lingerpotslowfalling2", + "slowfallcloudpotionlong": "lingerpotslowfalling2", + "slowfallcloudpotionextended": "lingerpotslowfalling2", + "slowfallcloudpotionex": "lingerpotslowfalling2", + "slowfallcloudpotionlevel2": "lingerpotslowfalling2", + "sfcloudpotion2": "lingerpotslowfalling2", + "sfcloudpotionlong": "lingerpotslowfalling2", + "sfcloudpotionextended": "lingerpotslowfalling2", + "sfcloudpotionex": "lingerpotslowfalling2", + "sfcloudpotionlevel2": "lingerpotslowfalling2", + "cloudpotslowfalling2": "lingerpotslowfalling2", + "cloudpotslowfallinglong": "lingerpotslowfalling2", + "cloudpotslowfallingextended": "lingerpotslowfalling2", + "cloudpotslowfallingex": "lingerpotslowfalling2", + "cloudpotslowfallinglevel2": "lingerpotslowfalling2", + "cloudpotslowfall2": "lingerpotslowfalling2", + "cloudpotslowfalllong": "lingerpotslowfalling2", + "cloudpotslowfallextended": "lingerpotslowfalling2", + "cloudpotslowfallex": "lingerpotslowfalling2", + "cloudpotslowfalllevel2": "lingerpotslowfalling2", + "cloudpotsf2": "lingerpotslowfalling2", + "cloudpotsflong": "lingerpotslowfalling2", + "cloudpotsfextended": "lingerpotslowfalling2", + "cloudpotsfex": "lingerpotslowfalling2", + "cloudpotsflevel2": "lingerpotslowfalling2", + "slowfallingcloudpot2": "lingerpotslowfalling2", + "slowfallingcloudpotlong": "lingerpotslowfalling2", + "slowfallingcloudpotextended": "lingerpotslowfalling2", + "slowfallingcloudpotex": "lingerpotslowfalling2", + "slowfallingcloudpotlevel2": "lingerpotslowfalling2", + "slowfallcloudpot2": "lingerpotslowfalling2", + "slowfallcloudpotlong": "lingerpotslowfalling2", + "slowfallcloudpotextended": "lingerpotslowfalling2", + "slowfallcloudpotex": "lingerpotslowfalling2", + "slowfallcloudpotlevel2": "lingerpotslowfalling2", + "sfcloudpot2": "lingerpotslowfalling2", + "sfcloudpotlong": "lingerpotslowfalling2", + "sfcloudpotextended": "lingerpotslowfalling2", + "sfcloudpotex": "lingerpotslowfalling2", + "sfcloudpotlevel2": "lingerpotslowfalling2", + "arrowslowfalling2": { + "material": "TIPPED_ARROW", + "potionData": { + "vanillaType": "long_slow_falling", + "bukkitType": "slow_falling", + "isStrong": false, + "isLong": true + } + }, + "arrowslowfallinglong": "arrowslowfalling2", + "arrowslowfallingextended": "arrowslowfalling2", + "arrowslowfallingex": "arrowslowfalling2", + "arrowslowfallinglevel2": "arrowslowfalling2", + "arrowslowfall2": "arrowslowfalling2", + "arrowslowfalllong": "arrowslowfalling2", + "arrowslowfallextended": "arrowslowfalling2", + "arrowslowfallex": "arrowslowfalling2", + "arrowslowfalllevel2": "arrowslowfalling2", + "arrowsf2": "arrowslowfalling2", + "arrowsflong": "arrowslowfalling2", + "arrowsfextended": "arrowslowfalling2", + "arrowsfex": "arrowslowfalling2", + "arrowsflevel2": "arrowslowfalling2", + "slowfallingarrow2": "arrowslowfalling2", + "slowfallingarrowlong": "arrowslowfalling2", + "slowfallingarrowextended": "arrowslowfalling2", + "slowfallingarrowex": "arrowslowfalling2", + "slowfallingarrowlevel2": "arrowslowfalling2", + "slowfallarrow2": "arrowslowfalling2", + "slowfallarrowlong": "arrowslowfalling2", + "slowfallarrowextended": "arrowslowfalling2", + "slowfallarrowex": "arrowslowfalling2", + "slowfallarrowlevel2": "arrowslowfalling2", + "sfarrow2": "arrowslowfalling2", + "sfarrowlong": "arrowslowfalling2", + "sfarrowextended": "arrowslowfalling2", + "sfarrowex": "arrowslowfalling2", + "sfarrowlevel2": "arrowslowfalling2" +} \ No newline at end of file diff --git a/pom.xml b/pom.xml index c4374ac32..f01e906be 100644 --- a/pom.xml +++ b/pom.xml @@ -173,6 +173,7 @@ messages*.properties config.yml items.csv + items.json plugin.yml From 718d9d9d3a64e09b85950b4647163ad7bfeda032 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 21:55:29 +0100 Subject: [PATCH 23/62] Initialise provider and file during first reload --- .../src/com/earth2me/essentials/ItemDb.java | 23 +++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index a0ac3b793..1cad7200f 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -24,23 +24,28 @@ import static com.earth2me.essentials.I18n.tl; public class ItemDb implements IConf, net.ess3.api.IItemDb { protected static final Logger LOGGER = Logger.getLogger("Essentials"); private final transient IEssentials ess; - private final transient ItemDbProvider provider; + private transient ItemDbProvider provider = null; - private final transient ManagedFile file; + private transient ManagedFile file = null; public ItemDb(final IEssentials ess) { this.ess = ess; - this.provider = ess.getItemDbProvider(); - - if (provider instanceof LegacyItemDbProvider) { - file = new ManagedFile("items.csv", ess); - } else { - file = new ManagedFile("items.json", ess); - } } @Override public void reloadConfig() { + if (provider == null) { + this.provider = ess.getItemDbProvider(); + } + + if (file == null) { + if (provider instanceof LegacyItemDbProvider) { + file = new ManagedFile("items.csv", ess); + } else { + file = new ManagedFile("items.json", ess); + } + } + provider.rebuild(file.getLines()); } From d5b43b71624f91a554a6c62ccf0ba1e2240c5a92 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 23:09:02 +0100 Subject: [PATCH 24/62] Include JSON files in jar at build time --- pom.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/pom.xml b/pom.xml index f01e906be..7889d0c17 100644 --- a/pom.xml +++ b/pom.xml @@ -279,6 +279,7 @@ *.yml *.csv *.txt + *.json true From 9487665fae74cbb7f27b70e32dce31d9dfacf59f Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 23:10:23 +0100 Subject: [PATCH 25/62] Use Bukkit PotionData instead of our own --- Essentials/src/items.json | 672 +++++++++--------- .../src/net/ess3/nms/ItemDbProvider.java | 10 +- 2 files changed, 340 insertions(+), 342 deletions(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index 27b16bb16..09ada925d 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -7794,8 +7794,8 @@ "potionData": { "vanillaType": "empty", "bukkitType": "empty", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "emptypot": "emptypotion", @@ -7806,8 +7806,8 @@ "potionData": { "vanillaType": "empty", "bukkitType": "empty", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splemptypotion": "splashemptypotion", @@ -7820,8 +7820,8 @@ "potionData": { "vanillaType": "empty", "bukkitType": "empty", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "emptylingerpot": "lingerpotempty", @@ -7842,8 +7842,8 @@ "potionData": { "vanillaType": "empty", "bukkitType": "empty", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "emptyarrow": "arrowempty", @@ -7852,8 +7852,8 @@ "potionData": { "vanillaType": "water", "bukkitType": "water", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "waterpot": "waterpotion", @@ -7864,8 +7864,8 @@ "potionData": { "vanillaType": "water", "bukkitType": "water", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splwaterpotion": "splashwaterpotion", @@ -7878,8 +7878,8 @@ "potionData": { "vanillaType": "water", "bukkitType": "water", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "waterlingerpot": "lingerpotwater", @@ -7900,8 +7900,8 @@ "potionData": { "vanillaType": "water", "bukkitType": "water", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "waterarrow": "arrowwater", @@ -7910,8 +7910,8 @@ "potionData": { "vanillaType": "mundane", "bukkitType": "mundane", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "mundanepot": "mundanepotion", @@ -7922,8 +7922,8 @@ "potionData": { "vanillaType": "mundane", "bukkitType": "mundane", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splmundanepotion": "splashmundanepotion", @@ -7936,8 +7936,8 @@ "potionData": { "vanillaType": "mundane", "bukkitType": "mundane", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "mundanelingerpot": "lingerpotmundane", @@ -7958,8 +7958,8 @@ "potionData": { "vanillaType": "mundane", "bukkitType": "mundane", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "mundanearrow": "arrowmundane", @@ -7968,8 +7968,8 @@ "potionData": { "vanillaType": "thick", "bukkitType": "thick", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "thickpot": "thickpotion", @@ -7980,8 +7980,8 @@ "potionData": { "vanillaType": "thick", "bukkitType": "thick", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splthickpotion": "splashthickpotion", @@ -7994,8 +7994,8 @@ "potionData": { "vanillaType": "thick", "bukkitType": "thick", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "thicklingerpot": "lingerpotthick", @@ -8016,8 +8016,8 @@ "potionData": { "vanillaType": "thick", "bukkitType": "thick", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "thickarrow": "arrowthick", @@ -8026,8 +8026,8 @@ "potionData": { "vanillaType": "awkward", "bukkitType": "awkward", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "awkwardpot": "awkwardpotion", @@ -8038,8 +8038,8 @@ "potionData": { "vanillaType": "awkward", "bukkitType": "awkward", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splawkwardpotion": "splashawkwardpotion", @@ -8052,8 +8052,8 @@ "potionData": { "vanillaType": "awkward", "bukkitType": "awkward", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "awkwardlingerpot": "lingerpotawkward", @@ -8074,8 +8074,8 @@ "potionData": { "vanillaType": "awkward", "bukkitType": "awkward", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "awkwardarrow": "arrowawkward", @@ -8084,8 +8084,8 @@ "potionData": { "vanillaType": "night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "nvpotion": "nightvisionpotion", @@ -8120,8 +8120,8 @@ "potionData": { "vanillaType": "night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashnvpotion": "splashnightvisionpotion", @@ -8170,8 +8170,8 @@ "potionData": { "vanillaType": "night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotnv": "lingerpotnightvision", @@ -8276,8 +8276,8 @@ "potionData": { "vanillaType": "night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrownv": "arrownightvision", @@ -8298,8 +8298,8 @@ "potionData": { "vanillaType": "long_night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "nightvisionlongpotion": "nightvision2potion", @@ -8446,8 +8446,8 @@ "potionData": { "vanillaType": "long_night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashnightvisionlongpotion": "splashnightvision2potion", @@ -8664,8 +8664,8 @@ "potionData": { "vanillaType": "long_night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotnightvisionlong": "lingerpotnightvision2", @@ -9162,8 +9162,8 @@ "potionData": { "vanillaType": "long_night_vision", "bukkitType": "night_vision", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrownightvisionlong": "arrownightvision2", @@ -9240,8 +9240,8 @@ "potionData": { "vanillaType": "invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "invispotion": "invisibilitypotion", @@ -9264,8 +9264,8 @@ "potionData": { "vanillaType": "invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashinvispotion": "splashinvisibilitypotion", @@ -9296,8 +9296,8 @@ "potionData": { "vanillaType": "invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotinvis": "lingerpotinvisibility", @@ -9360,8 +9360,8 @@ "potionData": { "vanillaType": "invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowinvis": "arrowinvisibility", @@ -9376,8 +9376,8 @@ "potionData": { "vanillaType": "long_invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "invisibilitylongpotion": "invisibility2potion", @@ -9464,8 +9464,8 @@ "potionData": { "vanillaType": "long_invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashinvisibilitylongpotion": "splashinvisibility2potion", @@ -9592,8 +9592,8 @@ "potionData": { "vanillaType": "long_invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotinvisibilitylong": "lingerpotinvisibility2", @@ -9880,8 +9880,8 @@ "potionData": { "vanillaType": "long_invisibility", "bukkitType": "invisibility", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowinvisibilitylong": "arrowinvisibility2", @@ -9928,8 +9928,8 @@ "potionData": { "vanillaType": "leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "leappotion": "leapingpotion", @@ -9944,8 +9944,8 @@ "potionData": { "vanillaType": "leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashleappotion": "splashleapingpotion", @@ -9964,8 +9964,8 @@ "potionData": { "vanillaType": "leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotleap": "lingerpotleaping", @@ -10000,8 +10000,8 @@ "potionData": { "vanillaType": "leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowleap": "arrowleaping", @@ -10012,8 +10012,8 @@ "potionData": { "vanillaType": "strong_leaping", "bukkitType": "leaping", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "leapingstrongpotion": "leapingiipotion", @@ -10044,8 +10044,8 @@ "potionData": { "vanillaType": "strong_leaping", "bukkitType": "leaping", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashleapingstrongpotion": "splashleapingiipotion", @@ -10088,8 +10088,8 @@ "potionData": { "vanillaType": "strong_leaping", "bukkitType": "leaping", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotleapingstrong": "lingerpotleapingii", @@ -10180,8 +10180,8 @@ "potionData": { "vanillaType": "strong_leaping", "bukkitType": "leaping", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowleapingstrong": "arrowleapingii", @@ -10200,8 +10200,8 @@ "potionData": { "vanillaType": "long_leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "leapinglongpotion": "leaping2potion", @@ -10248,8 +10248,8 @@ "potionData": { "vanillaType": "long_leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashleapinglongpotion": "splashleaping2potion", @@ -10316,8 +10316,8 @@ "potionData": { "vanillaType": "long_leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotleapinglong": "lingerpotleaping2", @@ -10464,8 +10464,8 @@ "potionData": { "vanillaType": "long_leaping", "bukkitType": "leaping", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowleapinglong": "arrowleaping2", @@ -10492,8 +10492,8 @@ "potionData": { "vanillaType": "fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "firerespotion": "fireresistpotion", @@ -10512,8 +10512,8 @@ "potionData": { "vanillaType": "fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashfirerespotion": "splashfireresistpotion", @@ -10538,8 +10538,8 @@ "potionData": { "vanillaType": "fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotfireres": "lingerpotfireresist", @@ -10588,8 +10588,8 @@ "potionData": { "vanillaType": "fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowfireres": "arrowfireresist", @@ -10602,8 +10602,8 @@ "potionData": { "vanillaType": "long_fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "fireresistlongpotion": "fireresist2potion", @@ -10670,8 +10670,8 @@ "potionData": { "vanillaType": "long_fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashfireresistlongpotion": "splashfireresist2potion", @@ -10768,8 +10768,8 @@ "potionData": { "vanillaType": "long_fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotfireresistlong": "lingerpotfireresist2", @@ -10986,8 +10986,8 @@ "potionData": { "vanillaType": "long_fire_resistance", "bukkitType": "fire_resistance", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowfireresistlong": "arrowfireresist2", @@ -11024,8 +11024,8 @@ "potionData": { "vanillaType": "swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "swiftpotion": "swiftnesspotion", @@ -11044,8 +11044,8 @@ "potionData": { "vanillaType": "swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashswiftpotion": "splashswiftnesspotion", @@ -11070,8 +11070,8 @@ "potionData": { "vanillaType": "swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotswift": "lingerpotswiftness", @@ -11120,8 +11120,8 @@ "potionData": { "vanillaType": "swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowswift": "arrowswiftness", @@ -11134,8 +11134,8 @@ "potionData": { "vanillaType": "strong_swiftness", "bukkitType": "swiftness", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "swiftnessstrongpotion": "swiftnessiipotion", @@ -11178,8 +11178,8 @@ "potionData": { "vanillaType": "strong_swiftness", "bukkitType": "swiftness", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashswiftnessstrongpotion": "splashswiftnessiipotion", @@ -11240,8 +11240,8 @@ "potionData": { "vanillaType": "strong_swiftness", "bukkitType": "swiftness", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotswiftnessstrong": "lingerpotswiftnessii", @@ -11374,8 +11374,8 @@ "potionData": { "vanillaType": "strong_swiftness", "bukkitType": "swiftness", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowswiftnessstrong": "arrowswiftnessii", @@ -11400,8 +11400,8 @@ "potionData": { "vanillaType": "long_swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "swiftnesslongpotion": "swiftness2potion", @@ -11468,8 +11468,8 @@ "potionData": { "vanillaType": "long_swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashswiftnesslongpotion": "splashswiftness2potion", @@ -11566,8 +11566,8 @@ "potionData": { "vanillaType": "long_swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotswiftnesslong": "lingerpotswiftness2", @@ -11784,8 +11784,8 @@ "potionData": { "vanillaType": "long_swiftness", "bukkitType": "swiftness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowswiftnesslong": "arrowswiftness2", @@ -11822,8 +11822,8 @@ "potionData": { "vanillaType": "slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "slowpotion": "slownesspotion", @@ -11838,8 +11838,8 @@ "potionData": { "vanillaType": "slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashslowpotion": "splashslownesspotion", @@ -11858,8 +11858,8 @@ "potionData": { "vanillaType": "slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotslow": "lingerpotslowness", @@ -11894,8 +11894,8 @@ "potionData": { "vanillaType": "slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowslow": "arrowslowness", @@ -11906,8 +11906,8 @@ "potionData": { "vanillaType": "long_slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "slownesslongpotion": "slowness2potion", @@ -11954,8 +11954,8 @@ "potionData": { "vanillaType": "long_slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashslownesslongpotion": "splashslowness2potion", @@ -12022,8 +12022,8 @@ "potionData": { "vanillaType": "long_slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotslownesslong": "lingerpotslowness2", @@ -12170,8 +12170,8 @@ "potionData": { "vanillaType": "long_slowness", "bukkitType": "slowness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowslownesslong": "arrowslowness2", @@ -12198,8 +12198,8 @@ "potionData": { "vanillaType": "water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "wbpotion": "waterbreathingpotion", @@ -12226,8 +12226,8 @@ "potionData": { "vanillaType": "water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashwbpotion": "splashwaterbreathingpotion", @@ -12264,8 +12264,8 @@ "potionData": { "vanillaType": "water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotwb": "lingerpotwaterbreathing", @@ -12342,8 +12342,8 @@ "potionData": { "vanillaType": "water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowwb": "arrowwaterbreathing", @@ -12360,8 +12360,8 @@ "potionData": { "vanillaType": "long_water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "waterbreathinglongpotion": "waterbreathing2potion", @@ -12468,8 +12468,8 @@ "potionData": { "vanillaType": "long_water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashwaterbreathinglongpotion": "splashwaterbreathing2potion", @@ -12626,8 +12626,8 @@ "potionData": { "vanillaType": "long_water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotwaterbreathinglong": "lingerpotwaterbreathing2", @@ -12984,8 +12984,8 @@ "potionData": { "vanillaType": "long_water_breathing", "bukkitType": "water_breathing", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowwaterbreathinglong": "arrowwaterbreathing2", @@ -13042,8 +13042,8 @@ "potionData": { "vanillaType": "healing", "bukkitType": "healing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "healpotion": "healingpotion", @@ -13066,8 +13066,8 @@ "potionData": { "vanillaType": "healing", "bukkitType": "healing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashhealpotion": "splashhealingpotion", @@ -13098,8 +13098,8 @@ "potionData": { "vanillaType": "healing", "bukkitType": "healing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotheal": "lingerpothealing", @@ -13162,8 +13162,8 @@ "potionData": { "vanillaType": "healing", "bukkitType": "healing", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowheal": "arrowhealing", @@ -13178,8 +13178,8 @@ "potionData": { "vanillaType": "strong_healing", "bukkitType": "healing", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "healingstrongpotion": "healingiipotion", @@ -13234,8 +13234,8 @@ "potionData": { "vanillaType": "strong_healing", "bukkitType": "healing", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashhealingstrongpotion": "splashhealingiipotion", @@ -13314,8 +13314,8 @@ "potionData": { "vanillaType": "strong_healing", "bukkitType": "healing", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpothealingstrong": "lingerpothealingii", @@ -13490,8 +13490,8 @@ "potionData": { "vanillaType": "strong_healing", "bukkitType": "healing", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowhealingstrong": "arrowhealingii", @@ -13522,8 +13522,8 @@ "potionData": { "vanillaType": "harming", "bukkitType": "harming", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "damagepotion": "harmingpotion", @@ -13546,8 +13546,8 @@ "potionData": { "vanillaType": "harming", "bukkitType": "harming", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashdamagepotion": "splashharmingpotion", @@ -13578,8 +13578,8 @@ "potionData": { "vanillaType": "harming", "bukkitType": "harming", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotdamage": "lingerpotharming", @@ -13642,8 +13642,8 @@ "potionData": { "vanillaType": "harming", "bukkitType": "harming", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowdamage": "arrowharming", @@ -13658,8 +13658,8 @@ "potionData": { "vanillaType": "strong_harming", "bukkitType": "harming", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "harmingstrongpotion": "harmingiipotion", @@ -13714,8 +13714,8 @@ "potionData": { "vanillaType": "strong_harming", "bukkitType": "harming", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashharmingstrongpotion": "splashharmingiipotion", @@ -13794,8 +13794,8 @@ "potionData": { "vanillaType": "strong_harming", "bukkitType": "harming", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotharmingstrong": "lingerpotharmingii", @@ -13970,8 +13970,8 @@ "potionData": { "vanillaType": "strong_harming", "bukkitType": "harming", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowharmingstrong": "arrowharmingii", @@ -14002,8 +14002,8 @@ "potionData": { "vanillaType": "poison", "bukkitType": "poison", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "acidpotion": "poisonpotion", @@ -14022,8 +14022,8 @@ "potionData": { "vanillaType": "poison", "bukkitType": "poison", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashacidpotion": "splashpoisonpotion", @@ -14048,8 +14048,8 @@ "potionData": { "vanillaType": "poison", "bukkitType": "poison", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotacid": "lingerpotpoison", @@ -14098,8 +14098,8 @@ "potionData": { "vanillaType": "poison", "bukkitType": "poison", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowacid": "arrowpoison", @@ -14112,8 +14112,8 @@ "potionData": { "vanillaType": "strong_poison", "bukkitType": "poison", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "poisonstrongpotion": "poisoniipotion", @@ -14156,8 +14156,8 @@ "potionData": { "vanillaType": "strong_poison", "bukkitType": "poison", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashpoisonstrongpotion": "splashpoisoniipotion", @@ -14218,8 +14218,8 @@ "potionData": { "vanillaType": "strong_poison", "bukkitType": "poison", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotpoisonstrong": "lingerpotpoisonii", @@ -14352,8 +14352,8 @@ "potionData": { "vanillaType": "strong_poison", "bukkitType": "poison", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowpoisonstrong": "arrowpoisonii", @@ -14378,8 +14378,8 @@ "potionData": { "vanillaType": "long_poison", "bukkitType": "poison", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "poisonlongpotion": "poison2potion", @@ -14446,8 +14446,8 @@ "potionData": { "vanillaType": "long_poison", "bukkitType": "poison", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashpoisonlongpotion": "splashpoison2potion", @@ -14544,8 +14544,8 @@ "potionData": { "vanillaType": "long_poison", "bukkitType": "poison", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotpoisonlong": "lingerpotpoison2", @@ -14762,8 +14762,8 @@ "potionData": { "vanillaType": "long_poison", "bukkitType": "poison", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowpoisonlong": "arrowpoison2", @@ -14800,8 +14800,8 @@ "potionData": { "vanillaType": "regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "regeneratepotion": "regenerationpotion", @@ -14820,8 +14820,8 @@ "potionData": { "vanillaType": "regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashregeneratepotion": "splashregenerationpotion", @@ -14846,8 +14846,8 @@ "potionData": { "vanillaType": "regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotregenerate": "lingerpotregeneration", @@ -14896,8 +14896,8 @@ "potionData": { "vanillaType": "regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowregenerate": "arrowregeneration", @@ -14910,8 +14910,8 @@ "potionData": { "vanillaType": "strong_regeneration", "bukkitType": "regeneration", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "regenerationstrongpotion": "regenerationiipotion", @@ -14954,8 +14954,8 @@ "potionData": { "vanillaType": "strong_regeneration", "bukkitType": "regeneration", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashregenerationstrongpotion": "splashregenerationiipotion", @@ -15016,8 +15016,8 @@ "potionData": { "vanillaType": "strong_regeneration", "bukkitType": "regeneration", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotregenerationstrong": "lingerpotregenerationii", @@ -15150,8 +15150,8 @@ "potionData": { "vanillaType": "strong_regeneration", "bukkitType": "regeneration", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowregenerationstrong": "arrowregenerationii", @@ -15176,8 +15176,8 @@ "potionData": { "vanillaType": "long_regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "regenerationlongpotion": "regeneration2potion", @@ -15244,8 +15244,8 @@ "potionData": { "vanillaType": "long_regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashregenerationlongpotion": "splashregeneration2potion", @@ -15342,8 +15342,8 @@ "potionData": { "vanillaType": "long_regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotregenerationlong": "lingerpotregeneration2", @@ -15560,8 +15560,8 @@ "potionData": { "vanillaType": "long_regeneration", "bukkitType": "regeneration", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowregenerationlong": "arrowregeneration2", @@ -15598,8 +15598,8 @@ "potionData": { "vanillaType": "strength", "bukkitType": "strength", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "strongpotion": "strengthpotion", @@ -15618,8 +15618,8 @@ "potionData": { "vanillaType": "strength", "bukkitType": "strength", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashstrongpotion": "splashstrengthpotion", @@ -15644,8 +15644,8 @@ "potionData": { "vanillaType": "strength", "bukkitType": "strength", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotstrong": "lingerpotstrength", @@ -15694,8 +15694,8 @@ "potionData": { "vanillaType": "strength", "bukkitType": "strength", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowstrong": "arrowstrength", @@ -15708,8 +15708,8 @@ "potionData": { "vanillaType": "strong_strength", "bukkitType": "strength", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "strengthstrongpotion": "strengthiipotion", @@ -15752,8 +15752,8 @@ "potionData": { "vanillaType": "strong_strength", "bukkitType": "strength", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashstrengthstrongpotion": "splashstrengthiipotion", @@ -15814,8 +15814,8 @@ "potionData": { "vanillaType": "strong_strength", "bukkitType": "strength", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotstrengthstrong": "lingerpotstrengthii", @@ -15948,8 +15948,8 @@ "potionData": { "vanillaType": "strong_strength", "bukkitType": "strength", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowstrengthstrong": "arrowstrengthii", @@ -15974,8 +15974,8 @@ "potionData": { "vanillaType": "long_strength", "bukkitType": "strength", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "strengthlongpotion": "strength2potion", @@ -16042,8 +16042,8 @@ "potionData": { "vanillaType": "long_strength", "bukkitType": "strength", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashstrengthlongpotion": "splashstrength2potion", @@ -16140,8 +16140,8 @@ "potionData": { "vanillaType": "long_strength", "bukkitType": "strength", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotstrengthlong": "lingerpotstrength2", @@ -16358,8 +16358,8 @@ "potionData": { "vanillaType": "long_strength", "bukkitType": "strength", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowstrengthlong": "arrowstrength2", @@ -16396,8 +16396,8 @@ "potionData": { "vanillaType": "weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "weakpotion": "weaknesspotion", @@ -16416,8 +16416,8 @@ "potionData": { "vanillaType": "weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashweakpotion": "splashweaknesspotion", @@ -16442,8 +16442,8 @@ "potionData": { "vanillaType": "weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotweak": "lingerpotweakness", @@ -16492,8 +16492,8 @@ "potionData": { "vanillaType": "weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowweak": "arrowweakness", @@ -16506,8 +16506,8 @@ "potionData": { "vanillaType": "long_weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "weaknesslongpotion": "weakness2potion", @@ -16574,8 +16574,8 @@ "potionData": { "vanillaType": "long_weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashweaknesslongpotion": "splashweakness2potion", @@ -16672,8 +16672,8 @@ "potionData": { "vanillaType": "long_weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotweaknesslong": "lingerpotweakness2", @@ -16890,8 +16890,8 @@ "potionData": { "vanillaType": "long_weakness", "bukkitType": "weakness", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowweaknesslong": "arrowweakness2", @@ -16928,8 +16928,8 @@ "potionData": { "vanillaType": "luck", "bukkitType": "luck", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "luckypotion": "luckpotion", @@ -16944,8 +16944,8 @@ "potionData": { "vanillaType": "luck", "bukkitType": "luck", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashluckypotion": "splashluckpotion", @@ -16964,8 +16964,8 @@ "potionData": { "vanillaType": "luck", "bukkitType": "luck", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotlucky": "lingerpotluck", @@ -17000,8 +17000,8 @@ "potionData": { "vanillaType": "luck", "bukkitType": "luck", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowlucky": "arrowluck", @@ -17012,8 +17012,8 @@ "potionData": { "vanillaType": "turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "turtlepotion": "turtlemasterpotion", @@ -17032,8 +17032,8 @@ "potionData": { "vanillaType": "turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashturtlepotion": "splashturtlemasterpotion", @@ -17058,8 +17058,8 @@ "potionData": { "vanillaType": "turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotturtle": "lingerpotturtlemaster", @@ -17108,8 +17108,8 @@ "potionData": { "vanillaType": "turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowturtle": "arrowturtlemaster", @@ -17122,8 +17122,8 @@ "potionData": { "vanillaType": "strong_turtle_master", "bukkitType": "turtle_master", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "turtlemasterstrongpotion": "turtlemasteriipotion", @@ -17166,8 +17166,8 @@ "potionData": { "vanillaType": "strong_turtle_master", "bukkitType": "turtle_master", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "splashturtlemasterstrongpotion": "splashturtlemasteriipotion", @@ -17228,8 +17228,8 @@ "potionData": { "vanillaType": "strong_turtle_master", "bukkitType": "turtle_master", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "lingerpotturtlemasterstrong": "lingerpotturtlemasterii", @@ -17362,8 +17362,8 @@ "potionData": { "vanillaType": "strong_turtle_master", "bukkitType": "turtle_master", - "isStrong": true, - "isLong": false + "upgraded": true, + "extended": false } }, "arrowturtlemasterstrong": "arrowturtlemasterii", @@ -17388,8 +17388,8 @@ "potionData": { "vanillaType": "long_turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "turtlemasterlongpotion": "turtlemaster2potion", @@ -17456,8 +17456,8 @@ "potionData": { "vanillaType": "long_turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashturtlemasterlongpotion": "splashturtlemaster2potion", @@ -17554,8 +17554,8 @@ "potionData": { "vanillaType": "long_turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotturtlemasterlong": "lingerpotturtlemaster2", @@ -17772,8 +17772,8 @@ "potionData": { "vanillaType": "long_turtle_master", "bukkitType": "turtle_master", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowturtlemasterlong": "arrowturtlemaster2", @@ -17810,8 +17810,8 @@ "potionData": { "vanillaType": "slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "slowfallpotion": "slowfallingpotion", @@ -17830,8 +17830,8 @@ "potionData": { "vanillaType": "slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "splashslowfallpotion": "splashslowfallingpotion", @@ -17856,8 +17856,8 @@ "potionData": { "vanillaType": "slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "lingerpotslowfall": "lingerpotslowfalling", @@ -17906,8 +17906,8 @@ "potionData": { "vanillaType": "slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": false + "upgraded": false, + "extended": false } }, "arrowslowfall": "arrowslowfalling", @@ -17920,8 +17920,8 @@ "potionData": { "vanillaType": "long_slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "slowfallinglongpotion": "slowfalling2potion", @@ -17988,8 +17988,8 @@ "potionData": { "vanillaType": "long_slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "splashslowfallinglongpotion": "splashslowfalling2potion", @@ -18086,8 +18086,8 @@ "potionData": { "vanillaType": "long_slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "lingerpotslowfallinglong": "lingerpotslowfalling2", @@ -18304,8 +18304,8 @@ "potionData": { "vanillaType": "long_slow_falling", "bukkitType": "slow_falling", - "isStrong": false, - "isLong": true + "upgraded": false, + "extended": true } }, "arrowslowfallinglong": "arrowslowfalling2", diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index 4e719a2a6..c44f61d18 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -3,6 +3,7 @@ package net.ess3.nms; import net.ess3.providers.Provider; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; +import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionType; import java.io.BufferedReader; @@ -249,13 +250,10 @@ public abstract class ItemDbProvider implements Provider { // TODO: generalise comparison return this.material == pairo.getMaterial() && this.itemData == pairo.getItemData() && this.nbt.equals(pairo.getNbt()); } - } - public static class PotionData { - private PotionType bukkitType; - private String vanillaType; - private boolean isStrong; - private boolean isLong; + public PotionData getPotionData() { + return this.potionData; + } } protected static class LengthCompare implements java.util.Comparator { From 610774b0b978eee7e9b3b7944867bef29b74aa22 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 23:11:30 +0100 Subject: [PATCH 26/62] Remove default getStack implementation --- nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index c44f61d18..733f4d366 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -95,9 +95,7 @@ public abstract class ItemDbProvider implements Provider { * @param name The material name to look up * @return An ItemStack of size 1 of the given item */ - public ItemStack getStack(String name) throws Exception { - return new ItemStack(resolve(name)); - } + public abstract ItemStack getStack(String name) throws Exception; /** * Creates a stack with the given amount of a given item by its name. From fec655a29c7d56e61bfaa4c351b1065e3bba7bd4 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sun, 19 Aug 2018 23:12:27 +0100 Subject: [PATCH 27/62] Implement ItemDbProviders, pt 7 Implement getStack and resolve for FlatItemDbProvider --- .../nms/flattened/FlatItemDbProvider.java | 35 ++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 58e8c9fca..b56cb3ac4 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -4,6 +4,8 @@ import com.google.gson.*; import net.ess3.nms.ItemDbProvider; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.PotionMeta; +import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionType; import java.util.*; @@ -16,7 +18,7 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public Material resolve(String name) { - return null; + return Objects.requireNonNull(getByName(name)).getMaterial(); } @Override @@ -59,11 +61,42 @@ public class FlatItemDbProvider extends ItemDbProvider { return null; } + @Override + public ItemStack getStack(String name) throws Exception { + ItemData data = Objects.requireNonNull(getByName(name)); + PotionData potionData = data.getPotionData(); + Material material = data.getMaterial(); + + ItemStack stack = new ItemStack(material); + + if (potionData != null) { + PotionMeta meta = (PotionMeta) stack.getItemMeta(); + meta.setBasePotionData(potionData); + stack.setItemMeta(meta); + } + + return stack; + } + @Override public Collection listNames() { return Collections.unmodifiableSet(primaryNames.keySet()); } + private ItemData getByName(String name) { + if (primaryNames.containsKey(name.toLowerCase())) { + return primaryNames.get(name); + } else { + for (Map.Entry> entry : names.entrySet()) { + if (entry.getValue().contains(name.toLowerCase())) { + return primaryNames.get(entry.getKey()); + } + } + } + + return null; + } + @Override public void rebuild(List lines) { String json = String.join("\n", lines); From 1be7fbd8a6241447556cd791615063f72f3fd5e2 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 25 Aug 2018 16:54:09 +0100 Subject: [PATCH 28/62] Remove hash comment when rebuilding JSON database --- .../src/net/ess3/nms/flattened/FlatItemDbProvider.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index b56cb3ac4..89581d1f1 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -99,7 +99,10 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public void rebuild(List lines) { - String json = String.join("\n", lines); + String json = lines.stream() + .filter(line -> !line.startsWith("#")) + .collect(Collectors.joining("\n")); + JsonObject map = (new JsonParser()).parse(json).getAsJsonObject(); for (Map.Entry entry : map.entrySet()) { From 65a4ef7ee51182bf58c14a0db6ab38d30b884845 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 25 Aug 2018 16:54:50 +0100 Subject: [PATCH 29/62] Use items that actually exist in tryProvider --- nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index 733f4d366..ca82c8726 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -124,8 +124,8 @@ public abstract class ItemDbProvider implements Provider { getStack("cstone"); getStack("diorite"); getStack("steelbar", 5); - getStack("aoepot"); - getStack("skeletonegg", 12); + getStack("splbreathlevel2pot"); + getStack("skeletonhorsespawnegg", 12); return true; } catch (Exception e) { return false; From 303aa77901107ec768ce3a02f243388696027435 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 25 Aug 2018 16:55:12 +0100 Subject: [PATCH 30/62] Add missing import --- .../src/net/ess3/nms/flattened/FlatItemDbProvider.java | 1 + 1 file changed, 1 insertion(+) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 89581d1f1..14709ba66 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -9,6 +9,7 @@ import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionType; import java.util.*; +import java.util.stream.Collectors; public class FlatItemDbProvider extends ItemDbProvider { private static Gson gson = new Gson(); From 05fcb7b1aad5d3b2232933dcb5dd53e79f0b150e Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 25 Aug 2018 18:38:50 +0100 Subject: [PATCH 31/62] Refactor to allow items to be added after first load --- .../net/ess3/nms/flattened/FlatItemDbProvider.java | 13 ++++++++++++- .../src/net/ess3/nms/ids/LegacyItemDbProvider.java | 12 ++++++++++-- .../src/net/ess3/nms/ItemDbProvider.java | 11 +++++++++-- 3 files changed, 31 insertions(+), 5 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 14709ba66..f6bce8baf 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -98,8 +98,13 @@ public class FlatItemDbProvider extends ItemDbProvider { return null; } + private void resetDb() { + primaryNames.clear(); + names.clear(); + } + @Override - public void rebuild(List lines) { + public void addFrom(List lines) { String json = lines.stream() .filter(line -> !line.startsWith("#")) .collect(Collectors.joining("\n")); @@ -124,6 +129,12 @@ public class FlatItemDbProvider extends ItemDbProvider { } } + @Override + public void rebuild(List lines) { + resetDb(); + addFrom(lines); + } + private void addAlias(String primaryName, String alias) { List aliasList; diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index d0debf44b..1705bca39 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -174,13 +174,15 @@ public class LegacyItemDbProvider extends ItemDbProvider { return nameList; } - @Override - public void rebuild(List lines) { + private void resetDb() { durabilities.clear(); items.clear(); names.clear(); primaryNames.clear(); + } + @Override + public void addFrom(List lines) { lines.stream() .filter(line -> line.length() > 0 && !(line.charAt(0) == '#')) .map(this::parseLine) @@ -192,6 +194,12 @@ public class LegacyItemDbProvider extends ItemDbProvider { } } + @Override + public void rebuild(List lines) { + resetDb(); + addFrom(lines); + } + private ItemData parseLine(String line) { String itemName = null; int numeric = -1; diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index ca82c8726..442e8e561 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -20,9 +20,16 @@ public abstract class ItemDbProvider implements Provider { private PotionMetaProvider potionMetaProvider; /** - * Rebuild the item database, using the given lines of a file. + * Populate the item database using the given lines of data. * - * @param lines The lines of the file from which the database should be built. + * @param lines The lines of data from which the database should be populated + */ + public abstract void addFrom(List lines); + + /** + * Reset the database and rebuild it from the given lines of data. + * + * @param lines The lines of the file from which the database should be built */ public abstract void rebuild(List lines); From 96c6c7b1cab5966fdc2397ebbeaaf23e6423ce26 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 11:23:47 +0100 Subject: [PATCH 32/62] Add per-provider implementations of ItemData --- .../nms/flattened/FlatItemDbProvider.java | 40 +++++++++++++--- .../ess3/nms/ids/LegacyItemDbProvider.java | 46 ++++++++++++++----- .../src/net/ess3/nms/ItemDbProvider.java | 42 +++-------------- 3 files changed, 76 insertions(+), 52 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index f6bce8baf..f99a5cfd2 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -1,12 +1,14 @@ package net.ess3.nms.flattened; -import com.google.gson.*; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; import net.ess3.nms.ItemDbProvider; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.potion.PotionData; -import org.bukkit.potion.PotionType; import java.util.*; import java.util.stream.Collectors; @@ -14,7 +16,7 @@ import java.util.stream.Collectors; public class FlatItemDbProvider extends ItemDbProvider { private static Gson gson = new Gson(); - private final transient Map primaryNames = new HashMap<>(); + private final transient Map primaryNames = new HashMap<>(); private final transient Map> names = new HashMap<>(); @Override @@ -39,9 +41,9 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public String getPrimaryName(ItemStack item) { - ItemData itemData = new ItemData(null, item.getType(), null); + ItemData itemData = new FlatItemData(null, item.getType(), null); - for (Map.Entry entry : primaryNames.entrySet()) { + for (Map.Entry entry : primaryNames.entrySet()) { if (entry.getValue().equals(itemData)) { return entry.getKey(); } @@ -116,7 +118,7 @@ public class FlatItemDbProvider extends ItemDbProvider { JsonElement element = entry.getValue(); if (element.isJsonObject()) { - ItemData data = gson.fromJson(element, ItemData.class); + FlatItemData data = gson.fromJson(element, FlatItemData.class); primaryNames.put(key, data); } else { try { @@ -159,4 +161,30 @@ public class FlatItemDbProvider extends ItemDbProvider { public String getHumanName() { return "Post-1.13 item database provider"; } + + public static class FlatItemData extends ItemData { + private FlatItemData(String itemName, Material material, PotionData potionData) { + this.itemName = itemName; + this.material = material; + this.potionData = potionData; + } + + @Override + public int hashCode() { + return (31 * material.hashCode()) ^ potionData.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (!(o instanceof ItemData)) { + return false; + } + ItemData pairo = (ItemData) o; + return this.material == pairo.getMaterial() && + (this.potionData == null && pairo.getPotionData() == null) || this.potionData.equals(pairo.getPotionData()); + } + } } diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 1705bca39..6e04a93a7 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -1,13 +1,10 @@ package net.ess3.nms.ids; import net.ess3.nms.ItemDbProvider; -import net.ess3.nms.PotionMetaProvider; -import net.ess3.nms.SpawnEggProvider; import net.ess3.nms.refl.ReflUtil; import org.apache.commons.lang.StringUtils; import org.bukkit.Bukkit; import org.bukkit.Material; -import org.bukkit.Server; import org.bukkit.entity.EntityType; import org.bukkit.inventory.ItemStack; @@ -19,7 +16,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { private final transient Map items = new HashMap<>(); private final transient Map> names = new HashMap<>(); private final transient Map primaryNames = new HashMap<>(); - private final transient Map legacyIds = new HashMap<>(); + private final transient Map legacyIds = new HashMap<>(); private final transient Map durabilities = new HashMap<>(); private final transient Map nbtData = new HashMap<>(); @@ -147,10 +144,10 @@ public class LegacyItemDbProvider extends ItemDbProvider { @Override public String getPrimaryName(ItemStack item) { - ItemData itemData = new ItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); + ItemData itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); String name = primaryNames.get(itemData); if (name == null) { - itemData = new ItemData(null, item.getType(), item.getTypeId(), (short) 0, null); + itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), (short) 0, null); name = primaryNames.get(itemData); if (name == null) { return null; @@ -161,10 +158,10 @@ public class LegacyItemDbProvider extends ItemDbProvider { @Override public List getNames(ItemStack item) { - ItemData itemData = new ItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); + ItemData itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); List nameList = names.get(itemData); if (nameList == null) { - itemData = new ItemData(null, item.getType(), item.getTypeId(), (short) 0, null); + itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), (short) 0, null); nameList = names.get(itemData); if (nameList == null) { return null; @@ -200,7 +197,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { addFrom(lines); } - private ItemData parseLine(String line) { + private LegacyItemData parseLine(String line) { String itemName = null; int numeric = -1; short data = 0; @@ -242,10 +239,10 @@ public class LegacyItemDbProvider extends ItemDbProvider { return null; } - return new ItemData(itemName, material, numeric, data, nbt); + return new LegacyItemData(itemName, material, numeric, data, nbt); } - private void addItem(ItemData itemData) { + private void addItem(LegacyItemData itemData) { final String name = itemData.getItemName(); final int numeric = itemData.getItemNo(); final short data = itemData.getItemData(); @@ -291,4 +288,31 @@ public class LegacyItemDbProvider extends ItemDbProvider { return false; } } + + public static class LegacyItemData extends ItemData { + private LegacyItemData(String itemName, Material material, final int legacyId, final short itemData, String nbt) { + this.itemName = itemName; + this.material = material; + this.legacyId = legacyId; + this.itemData = itemData; + this.nbt = nbt; + } + + @Override + public int hashCode() { + return (31 * legacyId) ^ itemData; + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (!(o instanceof ItemData)) { + return false; + } + ItemData pairo = (ItemData) o; + return this.legacyId == pairo.getItemNo() && this.itemData == pairo.getItemData(); + } + } } diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index 442e8e561..c327f1a0f 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -187,35 +187,13 @@ public abstract class ItemDbProvider implements Provider { this.potionMetaProvider = potionMetaProvider; } - public static class ItemData { - final private String itemName; - final private Material material; - private int legacyId; - private short itemData; - final private String nbt; - private PotionData potionData; - - public ItemData(String itemName, Material material, String nbt) { - this.itemName = itemName; - this.material = material; - this.nbt = nbt; - } - - public ItemData(String itemName, Material material, String nbt, PotionData potionData) { - this.itemName = itemName; - this.material = material; - this.nbt = nbt; - this.potionData = potionData; - } - - @Deprecated - public ItemData(String itemName, Material material, final int legacyId, final short itemData, String nbt) { - this.itemName = itemName; - this.material = material; - this.legacyId = legacyId; - this.itemData = itemData; - this.nbt = nbt; - } + public abstract static class ItemData { + protected String itemName; + protected Material material; + protected int legacyId; + protected short itemData; + protected String nbt; + protected PotionData potionData; public String getItemName() { return itemName; @@ -225,7 +203,6 @@ public abstract class ItemDbProvider implements Provider { return material; } - @Deprecated public int getItemNo() { return legacyId; } @@ -238,11 +215,6 @@ public abstract class ItemDbProvider implements Provider { return nbt; } - @Override - public int hashCode() { - return (31 * material.hashCode()) ^ itemData; - } - @Override public boolean equals(Object o) { if (o == null) { From e3c726b8f6704f3e8298aa908854cabf78b323bf Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 13:06:27 +0100 Subject: [PATCH 33/62] Log total loaded items on reload --- Essentials/src/com/earth2me/essentials/ItemDb.java | 1 + 1 file changed, 1 insertion(+) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 1cad7200f..13e1f1a73 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -47,6 +47,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { } provider.rebuild(file.getLines()); + LOGGER.info(String.format("Loaded %s items.", provider.listNames().size())); } @Override From 825f697fd28ae968ed1813b7a2d9152c4c4b3fc0 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 19:30:05 +0100 Subject: [PATCH 34/62] Update items.json --- Essentials/src/items.json | 356 ++++++++++++++++++++------------------ 1 file changed, 188 insertions(+), 168 deletions(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index 09ada925d..116d42c8c 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -1833,6 +1833,10 @@ "material": "DAYLIGHT_DETECTOR" }, "daylightdetector": "daylight_detector", + "dead_brain_coral": { + "material": "DEAD_BRAIN_CORAL" + }, + "deadbraincoral": "dead_brain_coral", "dead_brain_coral_block": { "material": "DEAD_BRAIN_CORAL_BLOCK" }, @@ -1845,6 +1849,10 @@ "material": "DEAD_BRAIN_CORAL_WALL_FAN" }, "deadbraincoralwallfan": "dead_brain_coral_wall_fan", + "dead_bubble_coral": { + "material": "DEAD_BUBBLE_CORAL" + }, + "deadbubblecoral": "dead_bubble_coral", "dead_bubble_coral_block": { "material": "DEAD_BUBBLE_CORAL_BLOCK" }, @@ -1861,6 +1869,10 @@ "material": "DEAD_BUSH" }, "deadbush": "dead_bush", + "dead_fire_coral": { + "material": "DEAD_FIRE_CORAL" + }, + "deadfirecoral": "dead_fire_coral", "dead_fire_coral_block": { "material": "DEAD_FIRE_CORAL_BLOCK" }, @@ -1873,6 +1885,10 @@ "material": "DEAD_FIRE_CORAL_WALL_FAN" }, "deadfirecoralwallfan": "dead_fire_coral_wall_fan", + "dead_horn_coral": { + "material": "DEAD_HORN_CORAL" + }, + "deadhorncoral": "dead_horn_coral", "dead_horn_coral_block": { "material": "DEAD_HORN_CORAL_BLOCK" }, @@ -1885,6 +1901,10 @@ "material": "DEAD_HORN_CORAL_WALL_FAN" }, "deadhorncoralwallfan": "dead_horn_coral_wall_fan", + "dead_tube_coral": { + "material": "DEAD_TUBE_CORAL" + }, + "deadtubecoral": "dead_tube_coral", "dead_tube_coral_block": { "material": "DEAD_TUBE_CORAL_BLOCK" }, @@ -7793,7 +7813,7 @@ "material": "POTION", "potionData": { "vanillaType": "empty", - "bukkitType": "empty", + "type": "empty", "upgraded": false, "extended": false } @@ -7805,7 +7825,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "empty", - "bukkitType": "empty", + "type": "empty", "upgraded": false, "extended": false } @@ -7819,7 +7839,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "empty", - "bukkitType": "empty", + "type": "empty", "upgraded": false, "extended": false } @@ -7841,7 +7861,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "empty", - "bukkitType": "empty", + "type": "empty", "upgraded": false, "extended": false } @@ -7851,7 +7871,7 @@ "material": "POTION", "potionData": { "vanillaType": "water", - "bukkitType": "water", + "type": "water", "upgraded": false, "extended": false } @@ -7863,7 +7883,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "water", - "bukkitType": "water", + "type": "water", "upgraded": false, "extended": false } @@ -7877,7 +7897,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "water", - "bukkitType": "water", + "type": "water", "upgraded": false, "extended": false } @@ -7899,7 +7919,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "water", - "bukkitType": "water", + "type": "water", "upgraded": false, "extended": false } @@ -7909,7 +7929,7 @@ "material": "POTION", "potionData": { "vanillaType": "mundane", - "bukkitType": "mundane", + "type": "mundane", "upgraded": false, "extended": false } @@ -7921,7 +7941,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "mundane", - "bukkitType": "mundane", + "type": "mundane", "upgraded": false, "extended": false } @@ -7935,7 +7955,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "mundane", - "bukkitType": "mundane", + "type": "mundane", "upgraded": false, "extended": false } @@ -7957,7 +7977,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "mundane", - "bukkitType": "mundane", + "type": "mundane", "upgraded": false, "extended": false } @@ -7967,7 +7987,7 @@ "material": "POTION", "potionData": { "vanillaType": "thick", - "bukkitType": "thick", + "type": "thick", "upgraded": false, "extended": false } @@ -7979,7 +7999,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "thick", - "bukkitType": "thick", + "type": "thick", "upgraded": false, "extended": false } @@ -7993,7 +8013,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "thick", - "bukkitType": "thick", + "type": "thick", "upgraded": false, "extended": false } @@ -8015,7 +8035,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "thick", - "bukkitType": "thick", + "type": "thick", "upgraded": false, "extended": false } @@ -8025,7 +8045,7 @@ "material": "POTION", "potionData": { "vanillaType": "awkward", - "bukkitType": "awkward", + "type": "awkward", "upgraded": false, "extended": false } @@ -8037,7 +8057,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "awkward", - "bukkitType": "awkward", + "type": "awkward", "upgraded": false, "extended": false } @@ -8051,7 +8071,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "awkward", - "bukkitType": "awkward", + "type": "awkward", "upgraded": false, "extended": false } @@ -8073,7 +8093,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "awkward", - "bukkitType": "awkward", + "type": "awkward", "upgraded": false, "extended": false } @@ -8083,7 +8103,7 @@ "material": "POTION", "potionData": { "vanillaType": "night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": false } @@ -8119,7 +8139,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": false } @@ -8169,7 +8189,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": false } @@ -8275,7 +8295,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": false } @@ -8297,7 +8317,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": true } @@ -8445,7 +8465,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": true } @@ -8663,7 +8683,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": true } @@ -9161,7 +9181,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_night_vision", - "bukkitType": "night_vision", + "type": "night_vision", "upgraded": false, "extended": true } @@ -9239,7 +9259,7 @@ "material": "POTION", "potionData": { "vanillaType": "invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": false } @@ -9263,7 +9283,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": false } @@ -9295,7 +9315,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": false } @@ -9359,7 +9379,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": false } @@ -9375,7 +9395,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": true } @@ -9463,7 +9483,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": true } @@ -9591,7 +9611,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": true } @@ -9879,7 +9899,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_invisibility", - "bukkitType": "invisibility", + "type": "invisibility", "upgraded": false, "extended": true } @@ -9927,7 +9947,7 @@ "material": "POTION", "potionData": { "vanillaType": "leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": false } @@ -9943,7 +9963,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": false } @@ -9963,7 +9983,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": false } @@ -9999,7 +10019,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": false } @@ -10011,7 +10031,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": true, "extended": false } @@ -10043,7 +10063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": true, "extended": false } @@ -10087,7 +10107,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": true, "extended": false } @@ -10179,7 +10199,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": true, "extended": false } @@ -10199,7 +10219,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": true } @@ -10247,7 +10267,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": true } @@ -10315,7 +10335,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": true } @@ -10463,7 +10483,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_leaping", - "bukkitType": "leaping", + "type": "leaping", "upgraded": false, "extended": true } @@ -10491,7 +10511,7 @@ "material": "POTION", "potionData": { "vanillaType": "fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": false } @@ -10511,7 +10531,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": false } @@ -10537,7 +10557,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": false } @@ -10587,7 +10607,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": false } @@ -10601,7 +10621,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": true } @@ -10669,7 +10689,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": true } @@ -10767,7 +10787,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": true } @@ -10985,7 +11005,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_fire_resistance", - "bukkitType": "fire_resistance", + "type": "fire_resistance", "upgraded": false, "extended": true } @@ -11023,7 +11043,7 @@ "material": "POTION", "potionData": { "vanillaType": "swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": false } @@ -11043,7 +11063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": false } @@ -11069,7 +11089,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": false } @@ -11119,7 +11139,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": false } @@ -11133,7 +11153,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": true, "extended": false } @@ -11177,7 +11197,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": true, "extended": false } @@ -11239,7 +11259,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": true, "extended": false } @@ -11373,7 +11393,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": true, "extended": false } @@ -11399,7 +11419,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": true } @@ -11467,7 +11487,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": true } @@ -11565,7 +11585,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": true } @@ -11783,7 +11803,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_swiftness", - "bukkitType": "swiftness", + "type": "swiftness", "upgraded": false, "extended": true } @@ -11821,7 +11841,7 @@ "material": "POTION", "potionData": { "vanillaType": "slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": false } @@ -11837,7 +11857,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": false } @@ -11857,7 +11877,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": false } @@ -11893,7 +11913,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": false } @@ -11905,7 +11925,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": true } @@ -11953,7 +11973,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": true } @@ -12021,7 +12041,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": true } @@ -12169,7 +12189,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_slowness", - "bukkitType": "slowness", + "type": "slowness", "upgraded": false, "extended": true } @@ -12197,7 +12217,7 @@ "material": "POTION", "potionData": { "vanillaType": "water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": false } @@ -12225,7 +12245,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": false } @@ -12263,7 +12283,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": false } @@ -12341,7 +12361,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": false } @@ -12359,7 +12379,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": true } @@ -12467,7 +12487,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": true } @@ -12625,7 +12645,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": true } @@ -12983,7 +13003,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_water_breathing", - "bukkitType": "water_breathing", + "type": "water_breathing", "upgraded": false, "extended": true } @@ -13041,7 +13061,7 @@ "material": "POTION", "potionData": { "vanillaType": "healing", - "bukkitType": "healing", + "type": "healing", "upgraded": false, "extended": false } @@ -13065,7 +13085,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "healing", - "bukkitType": "healing", + "type": "healing", "upgraded": false, "extended": false } @@ -13097,7 +13117,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "healing", - "bukkitType": "healing", + "type": "healing", "upgraded": false, "extended": false } @@ -13161,7 +13181,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "healing", - "bukkitType": "healing", + "type": "healing", "upgraded": false, "extended": false } @@ -13177,7 +13197,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_healing", - "bukkitType": "healing", + "type": "healing", "upgraded": true, "extended": false } @@ -13233,7 +13253,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_healing", - "bukkitType": "healing", + "type": "healing", "upgraded": true, "extended": false } @@ -13313,7 +13333,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_healing", - "bukkitType": "healing", + "type": "healing", "upgraded": true, "extended": false } @@ -13489,7 +13509,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_healing", - "bukkitType": "healing", + "type": "healing", "upgraded": true, "extended": false } @@ -13521,7 +13541,7 @@ "material": "POTION", "potionData": { "vanillaType": "harming", - "bukkitType": "harming", + "type": "harming", "upgraded": false, "extended": false } @@ -13545,7 +13565,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "harming", - "bukkitType": "harming", + "type": "harming", "upgraded": false, "extended": false } @@ -13577,7 +13597,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "harming", - "bukkitType": "harming", + "type": "harming", "upgraded": false, "extended": false } @@ -13641,7 +13661,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "harming", - "bukkitType": "harming", + "type": "harming", "upgraded": false, "extended": false } @@ -13657,7 +13677,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_harming", - "bukkitType": "harming", + "type": "harming", "upgraded": true, "extended": false } @@ -13713,7 +13733,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_harming", - "bukkitType": "harming", + "type": "harming", "upgraded": true, "extended": false } @@ -13793,7 +13813,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_harming", - "bukkitType": "harming", + "type": "harming", "upgraded": true, "extended": false } @@ -13969,7 +13989,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_harming", - "bukkitType": "harming", + "type": "harming", "upgraded": true, "extended": false } @@ -14001,7 +14021,7 @@ "material": "POTION", "potionData": { "vanillaType": "poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": false } @@ -14021,7 +14041,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": false } @@ -14047,7 +14067,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": false } @@ -14097,7 +14117,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": false } @@ -14111,7 +14131,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": true, "extended": false } @@ -14155,7 +14175,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": true, "extended": false } @@ -14217,7 +14237,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": true, "extended": false } @@ -14351,7 +14371,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": true, "extended": false } @@ -14377,7 +14397,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": true } @@ -14445,7 +14465,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": true } @@ -14543,7 +14563,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": true } @@ -14761,7 +14781,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_poison", - "bukkitType": "poison", + "type": "poison", "upgraded": false, "extended": true } @@ -14799,7 +14819,7 @@ "material": "POTION", "potionData": { "vanillaType": "regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": false } @@ -14819,7 +14839,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": false } @@ -14845,7 +14865,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": false } @@ -14895,7 +14915,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": false } @@ -14909,7 +14929,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": true, "extended": false } @@ -14953,7 +14973,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": true, "extended": false } @@ -15015,7 +15035,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": true, "extended": false } @@ -15149,7 +15169,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": true, "extended": false } @@ -15175,7 +15195,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": true } @@ -15243,7 +15263,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": true } @@ -15341,7 +15361,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": true } @@ -15559,7 +15579,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_regeneration", - "bukkitType": "regeneration", + "type": "regeneration", "upgraded": false, "extended": true } @@ -15597,7 +15617,7 @@ "material": "POTION", "potionData": { "vanillaType": "strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": false } @@ -15617,7 +15637,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": false } @@ -15643,7 +15663,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": false } @@ -15693,7 +15713,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": false } @@ -15707,7 +15727,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": true, "extended": false } @@ -15751,7 +15771,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": true, "extended": false } @@ -15813,7 +15833,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": true, "extended": false } @@ -15947,7 +15967,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": true, "extended": false } @@ -15973,7 +15993,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": true } @@ -16041,7 +16061,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": true } @@ -16139,7 +16159,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": true } @@ -16357,7 +16377,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_strength", - "bukkitType": "strength", + "type": "strength", "upgraded": false, "extended": true } @@ -16395,7 +16415,7 @@ "material": "POTION", "potionData": { "vanillaType": "weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": false } @@ -16415,7 +16435,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": false } @@ -16441,7 +16461,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": false } @@ -16491,7 +16511,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": false } @@ -16505,7 +16525,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": true } @@ -16573,7 +16593,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": true } @@ -16671,7 +16691,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": true } @@ -16889,7 +16909,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_weakness", - "bukkitType": "weakness", + "type": "weakness", "upgraded": false, "extended": true } @@ -16927,7 +16947,7 @@ "material": "POTION", "potionData": { "vanillaType": "luck", - "bukkitType": "luck", + "type": "luck", "upgraded": false, "extended": false } @@ -16943,7 +16963,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "luck", - "bukkitType": "luck", + "type": "luck", "upgraded": false, "extended": false } @@ -16963,7 +16983,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "luck", - "bukkitType": "luck", + "type": "luck", "upgraded": false, "extended": false } @@ -16999,7 +17019,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "luck", - "bukkitType": "luck", + "type": "luck", "upgraded": false, "extended": false } @@ -17011,7 +17031,7 @@ "material": "POTION", "potionData": { "vanillaType": "turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": false } @@ -17031,7 +17051,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": false } @@ -17057,7 +17077,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": false } @@ -17107,7 +17127,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": false } @@ -17121,7 +17141,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": true, "extended": false } @@ -17165,7 +17185,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": true, "extended": false } @@ -17227,7 +17247,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": true, "extended": false } @@ -17361,7 +17381,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": true, "extended": false } @@ -17387,7 +17407,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": true } @@ -17455,7 +17475,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": true } @@ -17553,7 +17573,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": true } @@ -17771,7 +17791,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_turtle_master", - "bukkitType": "turtle_master", + "type": "turtle_master", "upgraded": false, "extended": true } @@ -17809,7 +17829,7 @@ "material": "POTION", "potionData": { "vanillaType": "slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": false } @@ -17829,7 +17849,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": false } @@ -17855,7 +17875,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": false } @@ -17905,7 +17925,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": false } @@ -17919,7 +17939,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": true } @@ -17987,7 +18007,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": true } @@ -18085,7 +18105,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": true } @@ -18303,7 +18323,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_slow_falling", - "bukkitType": "slow_falling", + "type": "slow_falling", "upgraded": false, "extended": true } From 452fa61717b8b130bac3a9a2cec44a0e2c18c12c Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 19:58:19 +0100 Subject: [PATCH 35/62] Change tryProvider test values --- nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index c327f1a0f..bdf71e3a4 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -128,8 +128,8 @@ public abstract class ItemDbProvider implements Provider { @Override public boolean tryProvider() { try { - getStack("cstone"); - getStack("diorite"); + getStack("cobblestone"); + getStack("dstone"); getStack("steelbar", 5); getStack("splbreathlevel2pot"); getStack("skeletonhorsespawnegg", 12); From c1c422e03d32e522805a9541de348d683a77129a Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 21:00:57 +0100 Subject: [PATCH 36/62] Update items.json --- Essentials/src/items.json | 336 +++++++++++++++++++------------------- 1 file changed, 168 insertions(+), 168 deletions(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index 116d42c8c..3b952d134 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -7813,7 +7813,7 @@ "material": "POTION", "potionData": { "vanillaType": "empty", - "type": "empty", + "type": "EMPTY", "upgraded": false, "extended": false } @@ -7825,7 +7825,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "empty", - "type": "empty", + "type": "EMPTY", "upgraded": false, "extended": false } @@ -7839,7 +7839,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "empty", - "type": "empty", + "type": "EMPTY", "upgraded": false, "extended": false } @@ -7861,7 +7861,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "empty", - "type": "empty", + "type": "EMPTY", "upgraded": false, "extended": false } @@ -7871,7 +7871,7 @@ "material": "POTION", "potionData": { "vanillaType": "water", - "type": "water", + "type": "WATER", "upgraded": false, "extended": false } @@ -7883,7 +7883,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "water", - "type": "water", + "type": "WATER", "upgraded": false, "extended": false } @@ -7897,7 +7897,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "water", - "type": "water", + "type": "WATER", "upgraded": false, "extended": false } @@ -7919,7 +7919,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "water", - "type": "water", + "type": "WATER", "upgraded": false, "extended": false } @@ -7929,7 +7929,7 @@ "material": "POTION", "potionData": { "vanillaType": "mundane", - "type": "mundane", + "type": "MUNDANE", "upgraded": false, "extended": false } @@ -7941,7 +7941,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "mundane", - "type": "mundane", + "type": "MUNDANE", "upgraded": false, "extended": false } @@ -7955,7 +7955,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "mundane", - "type": "mundane", + "type": "MUNDANE", "upgraded": false, "extended": false } @@ -7977,7 +7977,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "mundane", - "type": "mundane", + "type": "MUNDANE", "upgraded": false, "extended": false } @@ -7987,7 +7987,7 @@ "material": "POTION", "potionData": { "vanillaType": "thick", - "type": "thick", + "type": "THICK", "upgraded": false, "extended": false } @@ -7999,7 +7999,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "thick", - "type": "thick", + "type": "THICK", "upgraded": false, "extended": false } @@ -8013,7 +8013,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "thick", - "type": "thick", + "type": "THICK", "upgraded": false, "extended": false } @@ -8035,7 +8035,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "thick", - "type": "thick", + "type": "THICK", "upgraded": false, "extended": false } @@ -8045,7 +8045,7 @@ "material": "POTION", "potionData": { "vanillaType": "awkward", - "type": "awkward", + "type": "AWKWARD", "upgraded": false, "extended": false } @@ -8057,7 +8057,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "awkward", - "type": "awkward", + "type": "AWKWARD", "upgraded": false, "extended": false } @@ -8071,7 +8071,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "awkward", - "type": "awkward", + "type": "AWKWARD", "upgraded": false, "extended": false } @@ -8093,7 +8093,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "awkward", - "type": "awkward", + "type": "AWKWARD", "upgraded": false, "extended": false } @@ -8103,7 +8103,7 @@ "material": "POTION", "potionData": { "vanillaType": "night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": false } @@ -8139,7 +8139,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": false } @@ -8189,7 +8189,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": false } @@ -8295,7 +8295,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": false } @@ -8317,7 +8317,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": true } @@ -8465,7 +8465,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": true } @@ -8683,7 +8683,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": true } @@ -9181,7 +9181,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_night_vision", - "type": "night_vision", + "type": "NIGHT_VISION", "upgraded": false, "extended": true } @@ -9259,7 +9259,7 @@ "material": "POTION", "potionData": { "vanillaType": "invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": false } @@ -9283,7 +9283,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": false } @@ -9315,7 +9315,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": false } @@ -9379,7 +9379,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": false } @@ -9395,7 +9395,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": true } @@ -9483,7 +9483,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": true } @@ -9611,7 +9611,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": true } @@ -9899,7 +9899,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_invisibility", - "type": "invisibility", + "type": "INVISIBILITY", "upgraded": false, "extended": true } @@ -9947,7 +9947,7 @@ "material": "POTION", "potionData": { "vanillaType": "leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": false } @@ -9963,7 +9963,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": false } @@ -9983,7 +9983,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": false } @@ -10019,7 +10019,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": false } @@ -10031,7 +10031,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": true, "extended": false } @@ -10063,7 +10063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": true, "extended": false } @@ -10107,7 +10107,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": true, "extended": false } @@ -10199,7 +10199,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": true, "extended": false } @@ -10219,7 +10219,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": true } @@ -10267,7 +10267,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": true } @@ -10335,7 +10335,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": true } @@ -10483,7 +10483,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_leaping", - "type": "leaping", + "type": "LEAPING", "upgraded": false, "extended": true } @@ -10511,7 +10511,7 @@ "material": "POTION", "potionData": { "vanillaType": "fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": false } @@ -10531,7 +10531,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": false } @@ -10557,7 +10557,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": false } @@ -10607,7 +10607,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": false } @@ -10621,7 +10621,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": true } @@ -10689,7 +10689,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": true } @@ -10787,7 +10787,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": true } @@ -11005,7 +11005,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_fire_resistance", - "type": "fire_resistance", + "type": "FIRE_RESISTANCE", "upgraded": false, "extended": true } @@ -11043,7 +11043,7 @@ "material": "POTION", "potionData": { "vanillaType": "swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": false } @@ -11063,7 +11063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": false } @@ -11089,7 +11089,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": false } @@ -11139,7 +11139,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": false } @@ -11153,7 +11153,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": true, "extended": false } @@ -11197,7 +11197,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": true, "extended": false } @@ -11259,7 +11259,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": true, "extended": false } @@ -11393,7 +11393,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": true, "extended": false } @@ -11419,7 +11419,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": true } @@ -11487,7 +11487,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": true } @@ -11585,7 +11585,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": true } @@ -11803,7 +11803,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_swiftness", - "type": "swiftness", + "type": "SWIFTNESS", "upgraded": false, "extended": true } @@ -11841,7 +11841,7 @@ "material": "POTION", "potionData": { "vanillaType": "slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": false } @@ -11857,7 +11857,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": false } @@ -11877,7 +11877,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": false } @@ -11913,7 +11913,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": false } @@ -11925,7 +11925,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": true } @@ -11973,7 +11973,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": true } @@ -12041,7 +12041,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": true } @@ -12189,7 +12189,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_slowness", - "type": "slowness", + "type": "SLOWNESS", "upgraded": false, "extended": true } @@ -12217,7 +12217,7 @@ "material": "POTION", "potionData": { "vanillaType": "water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": false } @@ -12245,7 +12245,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": false } @@ -12283,7 +12283,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": false } @@ -12361,7 +12361,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": false } @@ -12379,7 +12379,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": true } @@ -12487,7 +12487,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": true } @@ -12645,7 +12645,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": true } @@ -13003,7 +13003,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_water_breathing", - "type": "water_breathing", + "type": "WATER_BREATHING", "upgraded": false, "extended": true } @@ -13061,7 +13061,7 @@ "material": "POTION", "potionData": { "vanillaType": "healing", - "type": "healing", + "type": "HEALING", "upgraded": false, "extended": false } @@ -13085,7 +13085,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "healing", - "type": "healing", + "type": "HEALING", "upgraded": false, "extended": false } @@ -13117,7 +13117,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "healing", - "type": "healing", + "type": "HEALING", "upgraded": false, "extended": false } @@ -13181,7 +13181,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "healing", - "type": "healing", + "type": "HEALING", "upgraded": false, "extended": false } @@ -13197,7 +13197,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_healing", - "type": "healing", + "type": "HEALING", "upgraded": true, "extended": false } @@ -13253,7 +13253,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_healing", - "type": "healing", + "type": "HEALING", "upgraded": true, "extended": false } @@ -13333,7 +13333,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_healing", - "type": "healing", + "type": "HEALING", "upgraded": true, "extended": false } @@ -13509,7 +13509,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_healing", - "type": "healing", + "type": "HEALING", "upgraded": true, "extended": false } @@ -13541,7 +13541,7 @@ "material": "POTION", "potionData": { "vanillaType": "harming", - "type": "harming", + "type": "HARMING", "upgraded": false, "extended": false } @@ -13565,7 +13565,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "harming", - "type": "harming", + "type": "HARMING", "upgraded": false, "extended": false } @@ -13597,7 +13597,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "harming", - "type": "harming", + "type": "HARMING", "upgraded": false, "extended": false } @@ -13661,7 +13661,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "harming", - "type": "harming", + "type": "HARMING", "upgraded": false, "extended": false } @@ -13677,7 +13677,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_harming", - "type": "harming", + "type": "HARMING", "upgraded": true, "extended": false } @@ -13733,7 +13733,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_harming", - "type": "harming", + "type": "HARMING", "upgraded": true, "extended": false } @@ -13813,7 +13813,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_harming", - "type": "harming", + "type": "HARMING", "upgraded": true, "extended": false } @@ -13989,7 +13989,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_harming", - "type": "harming", + "type": "HARMING", "upgraded": true, "extended": false } @@ -14021,7 +14021,7 @@ "material": "POTION", "potionData": { "vanillaType": "poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": false } @@ -14041,7 +14041,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": false } @@ -14067,7 +14067,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": false } @@ -14117,7 +14117,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": false } @@ -14131,7 +14131,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_poison", - "type": "poison", + "type": "POISON", "upgraded": true, "extended": false } @@ -14175,7 +14175,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_poison", - "type": "poison", + "type": "POISON", "upgraded": true, "extended": false } @@ -14237,7 +14237,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_poison", - "type": "poison", + "type": "POISON", "upgraded": true, "extended": false } @@ -14371,7 +14371,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_poison", - "type": "poison", + "type": "POISON", "upgraded": true, "extended": false } @@ -14397,7 +14397,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": true } @@ -14465,7 +14465,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": true } @@ -14563,7 +14563,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": true } @@ -14781,7 +14781,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_poison", - "type": "poison", + "type": "POISON", "upgraded": false, "extended": true } @@ -14819,7 +14819,7 @@ "material": "POTION", "potionData": { "vanillaType": "regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": false } @@ -14839,7 +14839,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": false } @@ -14865,7 +14865,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": false } @@ -14915,7 +14915,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": false } @@ -14929,7 +14929,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": true, "extended": false } @@ -14973,7 +14973,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": true, "extended": false } @@ -15035,7 +15035,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": true, "extended": false } @@ -15169,7 +15169,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": true, "extended": false } @@ -15195,7 +15195,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": true } @@ -15263,7 +15263,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": true } @@ -15361,7 +15361,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": true } @@ -15579,7 +15579,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_regeneration", - "type": "regeneration", + "type": "REGENERATION", "upgraded": false, "extended": true } @@ -15617,7 +15617,7 @@ "material": "POTION", "potionData": { "vanillaType": "strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": false } @@ -15637,7 +15637,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": false } @@ -15663,7 +15663,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": false } @@ -15713,7 +15713,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": false } @@ -15727,7 +15727,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": true, "extended": false } @@ -15771,7 +15771,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": true, "extended": false } @@ -15833,7 +15833,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": true, "extended": false } @@ -15967,7 +15967,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": true, "extended": false } @@ -15993,7 +15993,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": true } @@ -16061,7 +16061,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": true } @@ -16159,7 +16159,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": true } @@ -16377,7 +16377,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_strength", - "type": "strength", + "type": "STRENGTH", "upgraded": false, "extended": true } @@ -16415,7 +16415,7 @@ "material": "POTION", "potionData": { "vanillaType": "weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": false } @@ -16435,7 +16435,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": false } @@ -16461,7 +16461,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": false } @@ -16511,7 +16511,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": false } @@ -16525,7 +16525,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": true } @@ -16593,7 +16593,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": true } @@ -16691,7 +16691,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": true } @@ -16909,7 +16909,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_weakness", - "type": "weakness", + "type": "WEAKNESS", "upgraded": false, "extended": true } @@ -16947,7 +16947,7 @@ "material": "POTION", "potionData": { "vanillaType": "luck", - "type": "luck", + "type": "LUCK", "upgraded": false, "extended": false } @@ -16963,7 +16963,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "luck", - "type": "luck", + "type": "LUCK", "upgraded": false, "extended": false } @@ -16983,7 +16983,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "luck", - "type": "luck", + "type": "LUCK", "upgraded": false, "extended": false } @@ -17019,7 +17019,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "luck", - "type": "luck", + "type": "LUCK", "upgraded": false, "extended": false } @@ -17031,7 +17031,7 @@ "material": "POTION", "potionData": { "vanillaType": "turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": false } @@ -17051,7 +17051,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": false } @@ -17077,7 +17077,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": false } @@ -17127,7 +17127,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": false } @@ -17141,7 +17141,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": true, "extended": false } @@ -17185,7 +17185,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": true, "extended": false } @@ -17247,7 +17247,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": true, "extended": false } @@ -17381,7 +17381,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": true, "extended": false } @@ -17407,7 +17407,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": true } @@ -17475,7 +17475,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": true } @@ -17573,7 +17573,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": true } @@ -17791,7 +17791,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_turtle_master", - "type": "turtle_master", + "type": "TURTLE_MASTER", "upgraded": false, "extended": true } @@ -17829,7 +17829,7 @@ "material": "POTION", "potionData": { "vanillaType": "slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": false } @@ -17849,7 +17849,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": false } @@ -17875,7 +17875,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": false } @@ -17925,7 +17925,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": false } @@ -17939,7 +17939,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": true } @@ -18007,7 +18007,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": true } @@ -18105,7 +18105,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": true } @@ -18323,7 +18323,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_slow_falling", - "type": "slow_falling", + "type": "SLOW_FALLING", "upgraded": false, "extended": true } From 2ddde37771c71831b4944b1fc57ad5e58920087e Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 21:02:27 +0100 Subject: [PATCH 37/62] Improve FlatItemData#equals --- .../net/ess3/nms/flattened/FlatItemDbProvider.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index f99a5cfd2..1f46b2301 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -183,8 +183,17 @@ public class FlatItemDbProvider extends ItemDbProvider { return false; } ItemData pairo = (ItemData) o; - return this.material == pairo.getMaterial() && - (this.potionData == null && pairo.getPotionData() == null) || this.potionData.equals(pairo.getPotionData()); + return this.material == pairo.getMaterial() && potionDataEquals(pairo); + } + + private boolean potionDataEquals(ItemData o) { + if (this.potionData == null && o.getPotionData() == null) { + return true; + } else if (this.potionData != null && o.getPotionData() != null) { + return this.potionData.equals(o.getPotionData()); + } else { + return false; + } } } } From d74f19970b14ec8d23801e49f20d094dad094f23 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 21:19:15 +0100 Subject: [PATCH 38/62] Strip out legacy ItemDb code, pt 1928371236123897 --- .../src/com/earth2me/essentials/ItemDb.java | 63 ------------------- 1 file changed, 63 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 13e1f1a73..e8daf693e 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -296,67 +296,4 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { public Collection listNames() { return provider.listNames(); } - - static class ItemData { - final private Material material; - private int legacyId; - final private short itemData; - - ItemData(Material material, short itemData) { - this.material = material; - this.itemData = itemData; - } - - @Deprecated - ItemData(Material material, final int legacyId, final short itemData) { - this.material = material; - this.legacyId = legacyId; - this.itemData = itemData; - } - - public Material getMaterial() { - return material; - } - - @Deprecated - public int getItemNo() { - return legacyId; - } - - public short getItemData() { - return itemData; - } - - @Override - public int hashCode() { - return (31 * material.hashCode()) ^ itemData; - } - - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (!(o instanceof ItemData)) { - return false; - } - ItemData pairo = (ItemData) o; - return this.material == pairo.getMaterial() && this.itemData == pairo.getItemData(); - } - } - - - static class LengthCompare implements java.util.Comparator { - - private static final LengthCompare INSTANCE = new LengthCompare(); - - public LengthCompare() { - super(); - } - - @Override - public int compare(String s1, String s2) { - return s1.length() - s2.length(); - } - } } From cdc5f75fcbde9c1911653d5ab13abdbaebf204e1 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 21:19:36 +0100 Subject: [PATCH 39/62] Remove unnecessary equals method on abstract ItemData --- .../src/net/ess3/nms/ItemDbProvider.java | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index bdf71e3a4..11d6d510d 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -215,19 +215,6 @@ public abstract class ItemDbProvider implements Provider { return nbt; } - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (!(o instanceof ItemData)) { - return false; - } - ItemData pairo = (ItemData) o; - // TODO: generalise comparison - return this.material == pairo.getMaterial() && this.itemData == pairo.getItemData() && this.nbt.equals(pairo.getNbt()); - } - public PotionData getPotionData() { return this.potionData; } From 3bf669c42a9f6035be67c9fb12728c0e8d05bd9f Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 27 Aug 2018 21:21:06 +0100 Subject: [PATCH 40/62] ItemDbProvider#resolve returns ItemData More useful than just returning the Material. --- .../src/net/ess3/nms/flattened/FlatItemDbProvider.java | 4 ++-- .../src/net/ess3/nms/ids/LegacyItemDbProvider.java | 2 +- nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 1f46b2301..52f202823 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -20,8 +20,8 @@ public class FlatItemDbProvider extends ItemDbProvider { private final transient Map> names = new HashMap<>(); @Override - public Material resolve(String name) { - return Objects.requireNonNull(getByName(name)).getMaterial(); + public ItemData resolve(String name) { + return getByName(name); } @Override diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 6e04a93a7..2776d6d10 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -24,7 +24,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { private final transient Pattern csvSplitPattern = Pattern.compile("(\"([^\"]*)\"|[^,]*)(,|$)"); @Override - public Material resolve(String name) { + public ItemData resolve(String name) { // TODO: refactor getStack into here return null; } diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java index 11d6d510d..e4a3278cc 100644 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java @@ -50,12 +50,12 @@ public abstract class ItemDbProvider implements Provider { } /** - * Resolves a material name to its corresponding Material + * Resolves a material name to the corresponding ItemData. * - * @param name The material name to look up - * @return The corresponding Material for the given name + * @param name The item name to look up + * @return The corresponding ItemData for the given name */ - public abstract Material resolve(String name); + public abstract ItemData resolve(String name); /** * Whether the provider supports legacy ID values or not. From a89c97409b4325dd9b5cbba997c62e5e9c32794a Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 1 Sep 2018 15:48:14 +0100 Subject: [PATCH 41/62] Use potion data when looking up items --- .../net/ess3/nms/flattened/FlatItemDbProvider.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java index 52f202823..3a58463f0 100644 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java @@ -7,6 +7,7 @@ import com.google.gson.JsonParser; import net.ess3.nms.ItemDbProvider; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.potion.PotionData; @@ -41,7 +42,7 @@ public class FlatItemDbProvider extends ItemDbProvider { @Override public String getPrimaryName(ItemStack item) { - ItemData itemData = new FlatItemData(null, item.getType(), null); + ItemData itemData = new FlatItemData(null, item.getType(), getPotionData(item)); for (Map.Entry entry : primaryNames.entrySet()) { if (entry.getValue().equals(itemData)) { @@ -52,6 +53,15 @@ public class FlatItemDbProvider extends ItemDbProvider { return null; } + private PotionData getPotionData(ItemStack item) { + ItemMeta meta = item.getItemMeta(); + if (meta instanceof PotionMeta) { + return ((PotionMeta) meta).getBasePotionData(); + } + + return null; + } + @Override public List getNames(ItemStack item) { String primaryName = getPrimaryName(item); From cd70662f01fece88d142e27c845f729b004b3101 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 1 Sep 2018 16:27:28 +0100 Subject: [PATCH 42/62] Update items.json Fixes some potions spawning incorrectly where the vanilla name didn't match the Bukkit enum name --- Essentials/src/items.json | 104 +++++++++++++++++++------------------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index 3b952d134..5b967a12d 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -9947,7 +9947,7 @@ "material": "POTION", "potionData": { "vanillaType": "leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": false } @@ -9963,7 +9963,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": false } @@ -9983,7 +9983,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": false } @@ -10019,7 +10019,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": false } @@ -10031,7 +10031,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": true, "extended": false } @@ -10063,7 +10063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": true, "extended": false } @@ -10107,7 +10107,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": true, "extended": false } @@ -10199,7 +10199,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": true, "extended": false } @@ -10219,7 +10219,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": true } @@ -10267,7 +10267,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": true } @@ -10335,7 +10335,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": true } @@ -10483,7 +10483,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_leaping", - "type": "LEAPING", + "type": "JUMP", "upgraded": false, "extended": true } @@ -11043,7 +11043,7 @@ "material": "POTION", "potionData": { "vanillaType": "swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": false } @@ -11063,7 +11063,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": false } @@ -11089,7 +11089,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": false } @@ -11139,7 +11139,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": false } @@ -11153,7 +11153,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": true, "extended": false } @@ -11197,7 +11197,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": true, "extended": false } @@ -11259,7 +11259,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": true, "extended": false } @@ -11393,7 +11393,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": true, "extended": false } @@ -11419,7 +11419,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": true } @@ -11487,7 +11487,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": true } @@ -11585,7 +11585,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": true } @@ -11803,7 +11803,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_swiftness", - "type": "SWIFTNESS", + "type": "SPEED", "upgraded": false, "extended": true } @@ -13061,7 +13061,7 @@ "material": "POTION", "potionData": { "vanillaType": "healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": false, "extended": false } @@ -13085,7 +13085,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": false, "extended": false } @@ -13117,7 +13117,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": false, "extended": false } @@ -13181,7 +13181,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": false, "extended": false } @@ -13197,7 +13197,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": true, "extended": false } @@ -13253,7 +13253,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": true, "extended": false } @@ -13333,7 +13333,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": true, "extended": false } @@ -13509,7 +13509,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_healing", - "type": "HEALING", + "type": "INSTANT_HEAL", "upgraded": true, "extended": false } @@ -13541,7 +13541,7 @@ "material": "POTION", "potionData": { "vanillaType": "harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": false, "extended": false } @@ -13565,7 +13565,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": false, "extended": false } @@ -13597,7 +13597,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": false, "extended": false } @@ -13661,7 +13661,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": false, "extended": false } @@ -13677,7 +13677,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": true, "extended": false } @@ -13733,7 +13733,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": true, "extended": false } @@ -13813,7 +13813,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": true, "extended": false } @@ -13989,7 +13989,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_harming", - "type": "HARMING", + "type": "INSTANT_HARM", "upgraded": true, "extended": false } @@ -14819,7 +14819,7 @@ "material": "POTION", "potionData": { "vanillaType": "regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": false } @@ -14839,7 +14839,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": false } @@ -14865,7 +14865,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": false } @@ -14915,7 +14915,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": false } @@ -14929,7 +14929,7 @@ "material": "POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": true, "extended": false } @@ -14973,7 +14973,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": true, "extended": false } @@ -15035,7 +15035,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "strong_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": true, "extended": false } @@ -15169,7 +15169,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "strong_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": true, "extended": false } @@ -15195,7 +15195,7 @@ "material": "POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": true } @@ -15263,7 +15263,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": true } @@ -15361,7 +15361,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "long_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": true } @@ -15579,7 +15579,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "long_regeneration", - "type": "REGENERATION", + "type": "REGEN", "upgraded": false, "extended": true } From 17d5545804b611c3bc70676c8a873fb29ed16e58 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 1 Sep 2018 16:46:55 +0100 Subject: [PATCH 43/62] Update items.json Fix incorrect type for Uncraftable Potions --- Essentials/src/items.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index 5b967a12d..c58b9233f 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -7813,7 +7813,7 @@ "material": "POTION", "potionData": { "vanillaType": "empty", - "type": "EMPTY", + "type": "UNCRAFTABLE", "upgraded": false, "extended": false } @@ -7825,7 +7825,7 @@ "material": "SPLASH_POTION", "potionData": { "vanillaType": "empty", - "type": "EMPTY", + "type": "UNCRAFTABLE", "upgraded": false, "extended": false } @@ -7839,7 +7839,7 @@ "material": "LINGERING_POTION", "potionData": { "vanillaType": "empty", - "type": "EMPTY", + "type": "UNCRAFTABLE", "upgraded": false, "extended": false } @@ -7861,7 +7861,7 @@ "material": "TIPPED_ARROW", "potionData": { "vanillaType": "empty", - "type": "EMPTY", + "type": "UNCRAFTABLE", "upgraded": false, "extended": false } From 0afa00779ca78430b9e4429712228de2e60a62d4 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 1 Sep 2018 19:31:32 +0100 Subject: [PATCH 44/62] Add some comments to LegacyItemDbProvider --- .../src/net/ess3/nms/ids/LegacyItemDbProvider.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java index 2776d6d10..1d10106f1 100644 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java @@ -13,11 +13,22 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; public class LegacyItemDbProvider extends ItemDbProvider { + // Maps all item names to legacy IDs private final transient Map items = new HashMap<>(); + + // Maps item data to all known names for an item private final transient Map> names = new HashMap<>(); + + // Maps item data to the primary name for an item private final transient Map primaryNames = new HashMap<>(); + + // Maps legacy IDs to item data private final transient Map legacyIds = new HashMap<>(); + + // Maps names for an item to durability/meta values private final transient Map durabilities = new HashMap<>(); + + // Maps names for an item to NBT data private final transient Map nbtData = new HashMap<>(); private final transient Pattern splitPattern = Pattern.compile("((.*)[:+',;.](\\d+))"); @@ -35,6 +46,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { String itemname; short metaData = 0; + // If the user provided id:metadata, split it Matcher parts = splitPattern.matcher(name); if (parts.matches()) { itemname = parts.group(2); @@ -43,6 +55,7 @@ public class LegacyItemDbProvider extends ItemDbProvider { itemname = name; } + // Check whether the user provided an ID if (isInt(itemname)) { itemid = Integer.parseInt(itemname); } else if (isInt(name)) { From 425e955b5d1146df2fff327cf7520190fe2908cf Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 5 Sep 2018 14:19:09 +0100 Subject: [PATCH 45/62] Update items.json Add some more aliases to the file --- Essentials/src/items.json | 183 +++++++++++++++++++++++++++++++++++++- 1 file changed, 182 insertions(+), 1 deletion(-) diff --git a/Essentials/src/items.json b/Essentials/src/items.json index c58b9233f..f8aa2a8e2 100644 --- a/Essentials/src/items.json +++ b/Essentials/src/items.json @@ -188,6 +188,8 @@ "allium": { "material": "ALLIUM" }, + "magentaallium": "allium", + "magentaflower": "allium", "andesite": { "material": "ANDESITE" }, @@ -217,6 +219,10 @@ "material": "AZURE_BLUET" }, "azurebluet": "azure_bluet", + "whiteazurebluet": "azure_bluet", + "abluet": "azure_bluet", + "azureb": "azure_bluet", + "houstonia": "azure_bluet", "baked_potato": { "material": "BAKED_POTATO" }, @@ -735,11 +741,14 @@ "bkglasspane": "black_stained_glass_pane", "bksglasspane": "black_stained_glass_pane", "bkstainedglasspane": "black_stained_glass_pane", + "bkgpane": "black_stained_glass_pane", "blaglasspane": "black_stained_glass_pane", "blasglasspane": "black_stained_glass_pane", "blastainedglasspane": "black_stained_glass_pane", + "blagpane": "black_stained_glass_pane", "blackglasspane": "black_stained_glass_pane", "blacksglasspane": "black_stained_glass_pane", + "blackgpane": "black_stained_glass_pane", "black_terracotta": { "material": "BLACK_TERRACOTTA" }, @@ -844,6 +853,13 @@ "material": "BLUE_ORCHID" }, "blueorchid": "blue_orchid", + "cyanorchid": "blue_orchid", + "lightblueorchid": "blue_orchid", + "lblueorchid": "blue_orchid", + "orchid": "blue_orchid", + "cyanflower": "blue_orchid", + "lightblueflower": "blue_orchid", + "lblueflower": "blue_orchid", "blue_shulker_box": { "material": "BLUE_SHULKER_BOX" }, @@ -867,8 +883,10 @@ "bluglasspane": "blue_stained_glass_pane", "blusglasspane": "blue_stained_glass_pane", "blustainedglasspane": "blue_stained_glass_pane", + "blugpane": "blue_stained_glass_pane", "blueglasspane": "blue_stained_glass_pane", "bluesglasspane": "blue_stained_glass_pane", + "bluegpane": "blue_stained_glass_pane", "blue_terracotta": { "material": "BLUE_TERRACOTTA" }, @@ -1062,8 +1080,10 @@ "broglasspane": "brown_stained_glass_pane", "brosglasspane": "brown_stained_glass_pane", "brostainedglasspane": "brown_stained_glass_pane", + "brogpane": "brown_stained_glass_pane", "brownglasspane": "brown_stained_glass_pane", "brownsglasspane": "brown_stained_glass_pane", + "browngpane": "brown_stained_glass_pane", "brown_terracotta": { "material": "BROWN_TERRACOTTA" }, @@ -1550,8 +1570,10 @@ "cglasspane": "cyan_stained_glass_pane", "csglasspane": "cyan_stained_glass_pane", "cstainedglasspane": "cyan_stained_glass_pane", + "cgpane": "cyan_stained_glass_pane", "cyanglasspane": "cyan_stained_glass_pane", "cyansglasspane": "cyan_stained_glass_pane", + "cyangpane": "cyan_stained_glass_pane", "cyan_terracotta": { "material": "CYAN_TERRACOTTA" }, @@ -1590,6 +1612,11 @@ "dandelion": { "material": "DANDELION" }, + "yellowdandelion": "dandelion", + "ydandelion": "dandelion", + "yellowflower": "dandelion", + "yflower": "dandelion", + "flower": "dandelion", "dandelion_yellow": { "material": "DANDELION_YELLOW" }, @@ -1869,6 +1896,11 @@ "material": "DEAD_BUSH" }, "deadbush": "dead_bush", + "bush": "dead_bush", + "deadshrub": "dead_bush", + "dshrub": "dead_bush", + "dbush": "dead_bush", + "deadsapling": "dead_bush", "dead_fire_coral": { "material": "DEAD_FIRE_CORAL" }, @@ -2085,6 +2117,11 @@ "material": "DRAGON_EGG" }, "dragonegg": "dragon_egg", + "enderdragonegg": "dragon_egg", + "endegg": "dragon_egg", + "degg": "dragon_egg", + "bossegg": "dragon_egg", + "begg": "dragon_egg", "dragon_head": { "material": "DRAGON_HEAD" }, @@ -2118,6 +2155,14 @@ "elytra": { "material": "ELYTRA" }, + "hangglider": "elytra", + "glider": "elytra", + "wings": "elytra", + "wing": "elytra", + "playerwings": "elytra", + "playerwing": "elytra", + "pwings": "elytra", + "pwing": "elytra", "emerald": { "material": "EMERALD" }, @@ -2183,10 +2228,22 @@ "material": "END_PORTAL" }, "endportal": "end_portal", + "endergoo": "end_portal", + "enderportal": "end_portal", + "endgoo": "end_portal", + "eportal": "end_portal", + "egoo": "end_portal", "end_portal_frame": { "material": "END_PORTAL_FRAME" }, "endportalframe": "end_portal_frame", + "endergooframe": "end_portal_frame", + "enderportalframe": "end_portal_frame", + "endgooframe": "end_portal_frame", + "eportalframe": "end_portal_frame", + "egooframe": "end_portal_frame", + "enderframe": "end_portal_frame", + "endframe": "end_portal_frame", "end_rod": { "material": "END_ROD" }, @@ -2195,6 +2252,11 @@ "material": "END_STONE" }, "endstone": "end_stone", + "enderstone": "end_stone", + "endrock": "end_stone", + "enderrock": "end_stone", + "erock": "end_stone", + "estone": "end_stone", "end_stone_bricks": { "material": "END_STONE_BRICKS" }, @@ -2649,29 +2711,38 @@ "graglasspane": "gray_stained_glass_pane", "grasglasspane": "gray_stained_glass_pane", "grastainedglasspane": "gray_stained_glass_pane", + "gragpane": "gray_stained_glass_pane", "greyglasspane": "gray_stained_glass_pane", "greysglasspane": "gray_stained_glass_pane", "greystainedglasspane": "gray_stained_glass_pane", + "greygpane": "gray_stained_glass_pane", "grayglasspane": "gray_stained_glass_pane", "graysglasspane": "gray_stained_glass_pane", + "graygpane": "gray_stained_glass_pane", "dgraglasspane": "gray_stained_glass_pane", "dgrasglasspane": "gray_stained_glass_pane", "dgrastainedglasspane": "gray_stained_glass_pane", + "dgragpane": "gray_stained_glass_pane", "darkgraglasspane": "gray_stained_glass_pane", "darkgrasglasspane": "gray_stained_glass_pane", "darkgrastainedglasspane": "gray_stained_glass_pane", + "darkgragpane": "gray_stained_glass_pane", "dgreyglasspane": "gray_stained_glass_pane", "dgreysglasspane": "gray_stained_glass_pane", "dgreystainedglasspane": "gray_stained_glass_pane", + "dgreygpane": "gray_stained_glass_pane", "dgrayglasspane": "gray_stained_glass_pane", "dgraysglasspane": "gray_stained_glass_pane", "dgraystainedglasspane": "gray_stained_glass_pane", + "dgraygpane": "gray_stained_glass_pane", "darkgreyglasspane": "gray_stained_glass_pane", "darkgreysglasspane": "gray_stained_glass_pane", "darkgreystainedglasspane": "gray_stained_glass_pane", + "darkgreygpane": "gray_stained_glass_pane", "darkgrayglasspane": "gray_stained_glass_pane", "darkgraysglasspane": "gray_stained_glass_pane", "darkgraystainedglasspane": "gray_stained_glass_pane", + "darkgraygpane": "gray_stained_glass_pane", "gray_terracotta": { "material": "GRAY_TERRACOTTA" }, @@ -2913,20 +2984,26 @@ "greglasspane": "green_stained_glass_pane", "gresglasspane": "green_stained_glass_pane", "grestainedglasspane": "green_stained_glass_pane", + "gregpane": "green_stained_glass_pane", "dgreglasspane": "green_stained_glass_pane", "dgresglasspane": "green_stained_glass_pane", "dgrestainedglasspane": "green_stained_glass_pane", + "dgregpane": "green_stained_glass_pane", "darkgreglasspane": "green_stained_glass_pane", "darkgresglasspane": "green_stained_glass_pane", "darkgrestainedglasspane": "green_stained_glass_pane", + "darkgregpane": "green_stained_glass_pane", "greenglasspane": "green_stained_glass_pane", "greensglasspane": "green_stained_glass_pane", + "greengpane": "green_stained_glass_pane", "dgreenglasspane": "green_stained_glass_pane", "dgreensglasspane": "green_stained_glass_pane", "dgreenstainedglasspane": "green_stained_glass_pane", + "dgreengpane": "green_stained_glass_pane", "darkgreenglasspane": "green_stained_glass_pane", "darkgreensglasspane": "green_stained_glass_pane", "darkgreenstainedglasspane": "green_stained_glass_pane", + "darkgreengpane": "green_stained_glass_pane", "green_terracotta": { "material": "GREEN_TERRACOTTA" }, @@ -3090,6 +3167,7 @@ "iaxe": "iron_axe", "steelaxe": "iron_axe", "saxe": "stone_axe", + "staxe": "iron_axe", "iron_bars": { "material": "IRON_BARS" }, @@ -3105,6 +3183,8 @@ "blocksteel": "iron_block", "sblock": "iron_block", "blocks": "iron_block", + "stblock": "iron_block", + "blockst": "iron_block", "iron_boots": { "material": "IRON_BOOTS" }, @@ -3116,6 +3196,8 @@ "steelshoes": "iron_boots", "sboots": "iron_boots", "sshoes": "iron_boots", + "stboots": "iron_boots", + "stshoes": "iron_boots", "iron_chestplate": { "material": "IRON_CHESTPLATE" }, @@ -3139,6 +3221,11 @@ "splate": "stone_pressure_plate", "sshirt": "iron_chestplate", "stunic": "iron_chestplate", + "stchestplate": "iron_chestplate", + "stplatebody": "iron_chestplate", + "stplate": "iron_chestplate", + "stshirt": "iron_chestplate", + "sttunic": "iron_chestplate", "iron_door": { "material": "IRON_DOOR" }, @@ -3162,6 +3249,10 @@ "shelm": "iron_helmet", "shat": "iron_helmet", "scoif": "iron_helmet", + "sthelmet": "iron_helmet", + "sthelm": "iron_helmet", + "sthat": "iron_helmet", + "stcoif": "iron_helmet", "iron_hoe": { "material": "IRON_HOE" }, @@ -3169,6 +3260,7 @@ "ihoe": "iron_hoe", "steelhoe": "iron_hoe", "shoe": "stone_hoe", + "sthoe": "iron_hoe", "iron_horse_armor": { "material": "IRON_HORSE_ARMOR" }, @@ -3194,6 +3286,12 @@ "isteel": "iron_ingot", "singot": "iron_ingot", "sbar": "iron_ingot", + "stingot": "iron_ingot", + "stbar": "iron_ingot", + "sti": "iron_ingot", + "ingotst": "iron_ingot", + "barst": "iron_ingot", + "ist": "iron_ingot", "iron_leggings": { "material": "IRON_LEGGINGS" }, @@ -3209,6 +3307,9 @@ "sleggings": "iron_leggings", "slegs": "iron_leggings", "spants": "iron_leggings", + "stleggings": "iron_leggings", + "stlegs": "iron_leggings", + "stpants": "iron_leggings", "iron_nugget": { "material": "IRON_NUGGET" }, @@ -3228,6 +3329,10 @@ "osteel": "iron_ore", "sore": "iron_ore", "ores": "iron_ore", + "store": "iron_ore", + "sto": "iron_ore", + "orest": "iron_ore", + "ost": "iron_ore", "iron_pickaxe": { "material": "IRON_PICKAXE" }, @@ -3239,6 +3344,8 @@ "steelpick": "iron_pickaxe", "spickaxe": "stone_pickaxe", "spick": "stone_pickaxe", + "stpickaxe": "iron_pickaxe", + "stpick": "iron_pickaxe", "iron_shovel": { "material": "IRON_SHOVEL" }, @@ -3250,6 +3357,8 @@ "steelspade": "iron_shovel", "sshovel": "stone_shovel", "sspade": "stone_shovel", + "stshovel": "iron_shovel", + "stspade": "iron_shovel", "iron_sword": { "material": "IRON_SWORD" }, @@ -3257,6 +3366,7 @@ "isword": "iron_sword", "steelsword": "iron_sword", "ssword": "stone_sword", + "stsword": "iron_sword", "iron_trapdoor": { "material": "IRON_TRAPDOOR" }, @@ -3779,17 +3889,22 @@ "lbglasspane": "light_blue_stained_glass_pane", "lbsglasspane": "light_blue_stained_glass_pane", "lbstainedglasspane": "light_blue_stained_glass_pane", + "lbgpane": "light_blue_stained_glass_pane", "lbluglasspane": "light_blue_stained_glass_pane", "lblusglasspane": "light_blue_stained_glass_pane", "lblustainedglasspane": "light_blue_stained_glass_pane", + "lblugpane": "light_blue_stained_glass_pane", "lightbluglasspane": "light_blue_stained_glass_pane", "lightblusglasspane": "light_blue_stained_glass_pane", "lightblustainedglasspane": "light_blue_stained_glass_pane", + "lightblugpane": "light_blue_stained_glass_pane", "lblueglasspane": "light_blue_stained_glass_pane", "lbluesglasspane": "light_blue_stained_glass_pane", "lbluestainedglasspane": "light_blue_stained_glass_pane", + "lbluegpane": "light_blue_stained_glass_pane", "lightblueglasspane": "light_blue_stained_glass_pane", "lightbluesglasspane": "light_blue_stained_glass_pane", + "lightbluegpane": "light_blue_stained_glass_pane", "light_blue_terracotta": { "material": "LIGHT_BLUE_TERRACOTTA" }, @@ -4059,32 +4174,42 @@ "lgglasspane": "light_gray_stained_glass_pane", "lgsglasspane": "light_gray_stained_glass_pane", "lgstainedglasspane": "light_gray_stained_glass_pane", + "lggpane": "light_gray_stained_glass_pane", "lgraglasspane": "light_gray_stained_glass_pane", "lgrasglasspane": "light_gray_stained_glass_pane", "lgrastainedglasspane": "light_gray_stained_glass_pane", + "lgragpane": "light_gray_stained_glass_pane", "lgreyglasspane": "light_gray_stained_glass_pane", "lgreysglasspane": "light_gray_stained_glass_pane", "lgreystainedglasspane": "light_gray_stained_glass_pane", + "lgreygpane": "light_gray_stained_glass_pane", "lgrayglasspane": "light_gray_stained_glass_pane", "lgraysglasspane": "light_gray_stained_glass_pane", "lgraystainedglasspane": "light_gray_stained_glass_pane", + "lgraygpane": "light_gray_stained_glass_pane", "lightgraglasspane": "light_gray_stained_glass_pane", "lightgrasglasspane": "light_gray_stained_glass_pane", "lightgrastainedglasspane": "light_gray_stained_glass_pane", + "lightgragpane": "light_gray_stained_glass_pane", "lightgreyglasspane": "light_gray_stained_glass_pane", "lightgreysglasspane": "light_gray_stained_glass_pane", "lightgreystainedglasspane": "light_gray_stained_glass_pane", + "lightgreygpane": "light_gray_stained_glass_pane", "lightgrayglasspane": "light_gray_stained_glass_pane", "lightgraysglasspane": "light_gray_stained_glass_pane", + "lightgraygpane": "light_gray_stained_glass_pane", "siglasspane": "light_gray_stained_glass_pane", "sisglasspane": "light_gray_stained_glass_pane", "sistainedglasspane": "light_gray_stained_glass_pane", + "sigpane": "light_gray_stained_glass_pane", "siaglasspane": "light_gray_stained_glass_pane", "siasglasspane": "light_gray_stained_glass_pane", "siastainedglasspane": "light_gray_stained_glass_pane", + "siagpane": "light_gray_stained_glass_pane", "silverglasspane": "light_gray_stained_glass_pane", "silversglasspane": "light_gray_stained_glass_pane", "silverstainedglasspane": "light_gray_stained_glass_pane", + "silvergpane": "light_gray_stained_glass_pane", "light_gray_terracotta": { "material": "LIGHT_GRAY_TERRACOTTA" }, @@ -4352,20 +4477,26 @@ "lglasspane": "lime_stained_glass_pane", "lsglasspane": "lime_stained_glass_pane", "lstainedglasspane": "lime_stained_glass_pane", + "lgpane": "lime_stained_glass_pane", "limeglasspane": "lime_stained_glass_pane", "limesglasspane": "lime_stained_glass_pane", + "limegpane": "lime_stained_glass_pane", "lgreglasspane": "lime_stained_glass_pane", "lgresglasspane": "lime_stained_glass_pane", "lgrestainedglasspane": "lime_stained_glass_pane", + "lgregpane": "lime_stained_glass_pane", "lightgreglasspane": "lime_stained_glass_pane", "lightgresglasspane": "lime_stained_glass_pane", "lightgrestainedglasspane": "lime_stained_glass_pane", + "lightgregpane": "lime_stained_glass_pane", "lgreenglasspane": "lime_stained_glass_pane", "lgreensglasspane": "lime_stained_glass_pane", "lgreenstainedglasspane": "lime_stained_glass_pane", + "lgreengpane": "lime_stained_glass_pane", "lightgreenglasspane": "lime_stained_glass_pane", "lightgreensglasspane": "lime_stained_glass_pane", "lightgreenstainedglasspane": "lime_stained_glass_pane", + "lightgreengpane": "lime_stained_glass_pane", "lime_terracotta": { "material": "LIME_TERRACOTTA" }, @@ -4518,8 +4649,10 @@ "mglasspane": "magenta_stained_glass_pane", "msglasspane": "magenta_stained_glass_pane", "mstainedglasspane": "magenta_stained_glass_pane", + "mgpane": "magenta_stained_glass_pane", "magentaglasspane": "magenta_stained_glass_pane", "magentasglasspane": "magenta_stained_glass_pane", + "magentagpane": "magenta_stained_glass_pane", "magenta_terracotta": { "material": "MAGENTA_TERRACOTTA" }, @@ -5808,8 +5941,10 @@ "oglasspane": "orange_stained_glass_pane", "osglasspane": "orange_stained_glass_pane", "ostainedglasspane": "orange_stained_glass_pane", + "ogpane": "orange_stained_glass_pane", "orangeglasspane": "orange_stained_glass_pane", "orangesglasspane": "orange_stained_glass_pane", + "orangegpane": "orange_stained_glass_pane", "orange_terracotta": { "material": "ORANGE_TERRACOTTA" }, @@ -5831,6 +5966,9 @@ "material": "ORANGE_TULIP" }, "orangetulip": "orange_tulip", + "tuliporange": "orange_tulip", + "otulip": "orange_tulip", + "tulipo": "orange_tulip", "orange_wall_banner": { "material": "ORANGE_WALL_BANNER" }, @@ -5849,6 +5987,15 @@ "material": "OXEYE_DAISY" }, "oxeyedaisy": "oxeye_daisy", + "oxeye": "oxeye_daisy", + "daisy": "oxeye_daisy", + "daisyoxeye": "oxeye_daisy", + "moondaisy": "oxeye_daisy", + "daisymoon": "oxeye_daisy", + "lightgrayoxeye": "oxeye_daisy", + "lgrayoxeye": "oxeye_daisy", + "lightgreyoxeye": "oxeye_daisy", + "lgreyoxeye": "oxeye_daisy", "packed_ice": { "material": "PACKED_ICE" }, @@ -5951,8 +6098,10 @@ "piglasspane": "pink_stained_glass_pane", "pisglasspane": "pink_stained_glass_pane", "pistainedglasspane": "pink_stained_glass_pane", + "pigpane": "pink_stained_glass_pane", "pinkglasspane": "pink_stained_glass_pane", "pinksglasspane": "pink_stained_glass_pane", + "pinkgpane": "pink_stained_glass_pane", "pink_terracotta": { "material": "PINK_TERRACOTTA" }, @@ -5974,6 +6123,9 @@ "material": "PINK_TULIP" }, "pinktulip": "pink_tulip", + "tulippink": "pink_tulip", + "ptulip": "pink_tulip", + "tulipp": "pink_tulip", "pink_wall_banner": { "material": "PINK_WALL_BANNER" }, @@ -6042,6 +6194,12 @@ "poppy": { "material": "POPPY" }, + "rose": "poppy", + "redrose": "poppy", + "rrose": "poppy", + "redflower": "poppy", + "rflower": "poppy", + "redpoppy": "poppy", "porkchop": { "material": "PORKCHOP" }, @@ -6321,8 +6479,10 @@ "puglasspane": "purple_stained_glass_pane", "pusglasspane": "purple_stained_glass_pane", "pustainedglasspane": "purple_stained_glass_pane", + "pugpane": "purple_stained_glass_pane", "purpleglasspane": "purple_stained_glass_pane", "purplesglasspane": "purple_stained_glass_pane", + "purplegpane": "purple_stained_glass_pane", "purple_terracotta": { "material": "PURPLE_TERRACOTTA" }, @@ -6604,8 +6764,10 @@ "rglasspane": "red_stained_glass_pane", "rsglasspane": "red_stained_glass_pane", "rstainedglasspane": "red_stained_glass_pane", + "rgpane": "red_stained_glass_pane", "redglasspane": "red_stained_glass_pane", "redsglasspane": "red_stained_glass_pane", + "redgpane": "red_stained_glass_pane", "red_terracotta": { "material": "RED_TERRACOTTA" }, @@ -6627,6 +6789,9 @@ "material": "RED_TULIP" }, "redtulip": "red_tulip", + "tulipred": "red_tulip", + "rtulip": "red_tulip", + "tulipr": "red_tulip", "red_wall_banner": { "material": "RED_WALL_BANNER" }, @@ -7371,6 +7536,14 @@ "material": "TALL_GRASS" }, "tallgrass": "tall_grass", + "longgrass": "tall_grass", + "wildgrass": "tall_grass", + "grasslong": "tall_grass", + "grasstall": "tall_grass", + "grasswild": "tall_grass", + "lgrass": "tall_grass", + "tgrass": "tall_grass", + "wgrass": "tall_grass", "tall_seagrass": { "material": "TALL_SEAGRASS" }, @@ -7574,11 +7747,14 @@ "whitestainedglasspane": "white_stained_glass_pane", "sglasspane": "white_stained_glass_pane", "stainedglasspane": "white_stained_glass_pane", + "gpane": "white_stained_glass_pane", "wglasspane": "white_stained_glass_pane", "wsglasspane": "white_stained_glass_pane", "wstainedglasspane": "white_stained_glass_pane", + "wgpane": "white_stained_glass_pane", "whiteglasspane": "white_stained_glass_pane", "whitesglasspane": "white_stained_glass_pane", + "whitegpane": "white_stained_glass_pane", "white_terracotta": { "material": "WHITE_TERRACOTTA" }, @@ -7605,6 +7781,9 @@ "material": "WHITE_TULIP" }, "whitetulip": "white_tulip", + "tulipwhite": "white_tulip", + "wtulip": "white_tulip", + "tulipw": "white_tulip", "white_wall_banner": { "material": "WHITE_WALL_BANNER" }, @@ -7752,8 +7931,10 @@ "yglasspane": "yellow_stained_glass_pane", "ysglasspane": "yellow_stained_glass_pane", "ystainedglasspane": "yellow_stained_glass_pane", + "ygpane": "yellow_stained_glass_pane", "yellowglasspane": "yellow_stained_glass_pane", "yellowsglasspane": "yellow_stained_glass_pane", + "yellowgpane": "yellow_stained_glass_pane", "yellow_terracotta": { "material": "YELLOW_TERRACOTTA" }, @@ -18357,4 +18538,4 @@ "sfarrowextended": "arrowslowfalling2", "sfarrowex": "arrowslowfalling2", "sfarrowlevel2": "arrowslowfalling2" -} \ No newline at end of file +} From b70b67fa1f97157151506a61cffb25b4779102cb Mon Sep 17 00:00:00 2001 From: md678685 Date: Wed, 5 Sep 2018 19:20:18 +0100 Subject: [PATCH 46/62] Remove unnecessary CraftBukkit dependency --- nms/FlattenedProvider/pom.xml | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/nms/FlattenedProvider/pom.xml b/nms/FlattenedProvider/pom.xml index ce63a9be3..afa470ee4 100644 --- a/nms/FlattenedProvider/pom.xml +++ b/nms/FlattenedProvider/pom.xml @@ -12,21 +12,7 @@ FlattenedProvider - - - project.local - local repo - file:${project.basedir}/lib - - - - - org.bukkit - craftbukkit - 1.13-R0.1-SNAPSHOT - provided - net.ess3 NMSProvider From 177e5f62f73a967195a722437ccef8e87d66d75e Mon Sep 17 00:00:00 2001 From: md678685 Date: Fri, 12 Oct 2018 17:26:22 +0100 Subject: [PATCH 47/62] Remove providers; move JSON support into ItemDb --- .../com/earth2me/essentials/Essentials.java | 22 +- .../src/com/earth2me/essentials/ItemDb.java | 182 ++++++++-- .../com/earth2me/essentials/api/IItemDb.java | 4 + Essentials/src/net/ess3/api/IEssentials.java | 3 - .../nms/flattened/FlatItemDbProvider.java | 209 ----------- nms/IdProvider/pom.xml | 32 -- .../ess3/nms/ids/LegacyItemDbProvider.java | 331 ------------------ .../src/net/ess3/nms/ItemDbProvider.java | 236 ------------- pom.xml | 1 - 9 files changed, 168 insertions(+), 852 deletions(-) delete mode 100644 nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java delete mode 100644 nms/IdProvider/pom.xml delete mode 100644 nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java delete mode 100644 nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java diff --git a/Essentials/src/com/earth2me/essentials/Essentials.java b/Essentials/src/com/earth2me/essentials/Essentials.java index fa6245677..9f254e447 100644 --- a/Essentials/src/com/earth2me/essentials/Essentials.java +++ b/Essentials/src/com/earth2me/essentials/Essentials.java @@ -34,24 +34,20 @@ import com.google.common.collect.Iterables; import net.ess3.api.*; import net.ess3.api.IEssentials; import net.ess3.api.ISettings; -import net.ess3.nms.ItemDbProvider; import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; import net.ess3.nms.SpawnerProvider; -import net.ess3.nms.flattened.FlatItemDbProvider; import net.ess3.nms.flattened.FlatSpawnEggProvider; -import net.ess3.nms.ids.LegacyItemDbProvider; import net.ess3.nms.legacy.LegacyPotionMetaProvider; +import net.ess3.nms.legacy.LegacySpawnEggProvider; +import net.ess3.nms.legacy.LegacySpawnerProvider; import net.ess3.nms.refl.ReflSpawnEggProvider; import net.ess3.nms.updatedmeta.BasePotionDataProvider; import net.ess3.nms.updatedmeta.BlockMetaSpawnerProvider; -import net.ess3.nms.legacy.LegacySpawnEggProvider; -import net.ess3.nms.legacy.LegacySpawnerProvider; import net.ess3.nms.v1_8_R1.v1_8_R1SpawnerProvider; import net.ess3.nms.v1_8_R2.v1_8_R2SpawnerProvider; import net.ess3.providers.ProviderFactory; import org.bukkit.Bukkit; -import org.bukkit.ChatColor; import org.bukkit.Server; import org.bukkit.World; import org.bukkit.block.Block; @@ -107,7 +103,6 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { private transient EssentialsTimer timer; private final transient Set vanishedPlayers = new LinkedHashSet<>(); private transient Method oldGetOnlinePlayers; - private transient ItemDbProvider itemDbProvider; private transient SpawnerProvider spawnerProvider; private transient SpawnEggProvider spawnEggProvider; private transient PotionMetaProvider potionMetaProvider; @@ -218,11 +213,6 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { confList.add(jails); execTimer.mark("Init(Jails)"); - itemDbProvider = new ProviderFactory<>(getLogger(), - Arrays.asList( - FlatItemDbProvider.class, - LegacyItemDbProvider.class - ), "item database").getProvider(); spawnerProvider = new ProviderFactory<>(getLogger(), Arrays.asList( BlockMetaSpawnerProvider.class, @@ -241,9 +231,6 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { BasePotionDataProvider.class, LegacyPotionMetaProvider.class ), "potion meta").getProvider(); - itemDbProvider.setSpawnerProvider(spawnerProvider); - itemDbProvider.setSpawnEggProvider(spawnEggProvider); - itemDbProvider.setPotionMetaProvider(potionMetaProvider); execTimer.mark("Init(Providers)"); reload(); } catch (YAMLException exception) { @@ -889,11 +876,6 @@ public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials { return potionMetaProvider; } - @Override - public ItemDbProvider getItemDbProvider() { - return itemDbProvider; - } - private static void addDefaultBackPermissionsToWorld(World w) { String permName = "essentials.back.into." + w.getName(); diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index e8daf693e..c9ef5554e 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -1,9 +1,11 @@ package com.earth2me.essentials; import com.earth2me.essentials.utils.StringUtil; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; import net.ess3.api.IEssentials; -import net.ess3.nms.ItemDbProvider; -import net.ess3.nms.ids.LegacyItemDbProvider; import org.bukkit.Color; import org.bukkit.FireworkEffect; import org.bukkit.Material; @@ -13,6 +15,7 @@ import org.bukkit.inventory.ItemFlag; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.*; import org.bukkit.potion.Potion; +import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionEffect; import java.util.*; @@ -23,8 +26,16 @@ import static com.earth2me.essentials.I18n.tl; public class ItemDb implements IConf, net.ess3.api.IItemDb { protected static final Logger LOGGER = Logger.getLogger("Essentials"); - private final transient IEssentials ess; - private transient ItemDbProvider provider = null; + private final transient IEssentials ess;private static Gson gson = new Gson(); + + // Maps primary name to ItemData + private final transient Map items = new HashMap<>(); + + // Maps alias to primary name + private final transient Map itemAliases = new HashMap<>(); + + // Every known alias + private final transient Set allAliases = new HashSet<>(); private transient ManagedFile file = null; @@ -34,30 +45,86 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public void reloadConfig() { - if (provider == null) { - this.provider = ess.getItemDbProvider(); + if (file == null) { + new ManagedFile("items.json", ess); } - if (file == null) { - if (provider instanceof LegacyItemDbProvider) { - file = new ManagedFile("items.csv", ess); + this.rebuild(); + LOGGER.info(String.format("Loaded %s items.", listNames().size())); + } + + private void rebuild() { + this.reset(); + this.loadJSON(String.join("\n", file.getLines())); + } + + private void reset() { + items.clear(); + itemAliases.clear(); + allAliases.clear(); + } + + public void loadJSON(String source) { + JsonObject map = (new JsonParser()).parse(source).getAsJsonObject(); + + for (Map.Entry entry : map.entrySet()) { + String key = entry.getKey(); + JsonElement element = entry.getValue(); + boolean valid = false; + + if (element.isJsonObject()) { + ItemData data = gson.fromJson(element, ItemData.class); + items.put(key, data); + valid = true; } else { - file = new ManagedFile("items.json", ess); + try { + String target = element.getAsString(); + itemAliases.put(key, target); + valid = true; + } catch (Exception e) { + // TODO: log invalid entry + } + } + + if (valid) { + allAliases.add(key); } } - - provider.rebuild(file.getLines()); - LOGGER.info(String.format("Loaded %s items.", provider.listNames().size())); } @Override public ItemStack get(final String id, final int quantity) throws Exception { - return provider.getStack(id, quantity); + ItemStack is = get(id); + is.setAmount(quantity); + return is; } @Override public ItemStack get(final String id) throws Exception { - return provider.getStack(id); + ItemData data = Objects.requireNonNull(getByName(id)); + PotionData potionData = data.getPotionData(); + Material material = data.getMaterial(); + + ItemStack stack = new ItemStack(material); + + if (potionData != null) { + PotionMeta meta = (PotionMeta) stack.getItemMeta(); + meta.setBasePotionData(potionData); + stack.setItemMeta(meta); + } + + return stack; + } + + private ItemData getByName(String name) { + name = name.toLowerCase(); + if (items.containsKey(name)) { + return items.get(name); + } else if (itemAliases.containsKey(name)) { + return items.get(itemAliases.get(name)); + } + + return null; } @Override @@ -95,7 +162,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public String names(ItemStack item) { - List nameList = provider.getNames(item); + List nameList = nameList(item); if (nameList.size() > 15) { nameList = nameList.subList(0, 14); @@ -103,9 +170,37 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { return StringUtil.joinList(", ", nameList); } + @Override + public List nameList(ItemStack item) { + List names = new ArrayList<>(); + String primaryName = name(item); + names.add(primaryName); + + for (Map.Entry entry : itemAliases.entrySet()) { + if (entry.getValue().equalsIgnoreCase(primaryName)) { + names.add(entry.getKey()); + } + } + + return names; + } + @Override public String name(ItemStack item) { - return provider.getPrimaryName(item); + Material type = item.getType(); + PotionData potion = null; + + if ((type.name().contains("POTION") || type.name().equals("TIPPED_ARROW")) && item.getItemMeta() instanceof PotionMeta) { + potion = ((PotionMeta) item.getItemMeta()).getBasePotionData(); + } + + for (Map.Entry entry : items.entrySet()) { + if (entry.getValue().getMaterial().equals(type) && entry.getValue().getPotionData().equals(potion)) { + return entry.getKey(); + } + } + + return null; } @Override @@ -283,17 +378,64 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { } @Override + @Deprecated public Material getFromLegacyId(int id) { - return provider.getFromLegacyId(id); + throw new UnsupportedOperationException("Legacy IDs aren't supported on this version of EssentialsX."); } @Override + @Deprecated public int getLegacyId(Material material) throws Exception { - return provider.getLegacyId(material); + throw new UnsupportedOperationException("Legacy IDs aren't supported on this version of EssentialsX."); } @Override public Collection listNames() { - return provider.listNames(); + return Collections.unmodifiableSet(allAliases); + } + + public static class ItemData { + private String itemName; + private Material material; + private PotionData potionData; + + @Override + public int hashCode() { + return (31 * material.hashCode()) ^ potionData.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (o == null) { + return false; + } + if (!(o instanceof ItemData)) { + return false; + } + ItemData pairo = (ItemData) o; + return this.material == pairo.getMaterial() && potionDataEquals(pairo); + } + + public String getItemName() { + return itemName; + } + + public Material getMaterial() { + return material; + } + + public PotionData getPotionData() { + return this.potionData; + } + + private boolean potionDataEquals(ItemData o) { + if (this.potionData == null && o.getPotionData() == null) { + return true; + } else if (this.potionData != null && o.getPotionData() != null) { + return this.potionData.equals(o.getPotionData()); + } else { + return false; + } + } } } diff --git a/Essentials/src/com/earth2me/essentials/api/IItemDb.java b/Essentials/src/com/earth2me/essentials/api/IItemDb.java index 00f073d5f..5a64069e4 100644 --- a/Essentials/src/com/earth2me/essentials/api/IItemDb.java +++ b/Essentials/src/com/earth2me/essentials/api/IItemDb.java @@ -15,6 +15,8 @@ public interface IItemDb { String names(ItemStack item); + List nameList(ItemStack item); + String name(ItemStack item); List getMatching(User user, String[] args) throws Exception; @@ -23,7 +25,9 @@ public interface IItemDb { Collection listNames(); + @Deprecated Material getFromLegacyId(int id); + @Deprecated int getLegacyId(Material material) throws Exception; } diff --git a/Essentials/src/net/ess3/api/IEssentials.java b/Essentials/src/net/ess3/api/IEssentials.java index dc418b512..1e76dda17 100644 --- a/Essentials/src/net/ess3/api/IEssentials.java +++ b/Essentials/src/net/ess3/api/IEssentials.java @@ -1,6 +1,5 @@ package net.ess3.api; -import net.ess3.nms.ItemDbProvider; import net.ess3.nms.PotionMetaProvider; import net.ess3.nms.SpawnEggProvider; @@ -13,6 +12,4 @@ public interface IEssentials extends com.earth2me.essentials.IEssentials { SpawnEggProvider getSpawnEggProvider(); PotionMetaProvider getPotionMetaProvider(); - - ItemDbProvider getItemDbProvider(); } diff --git a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java b/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java deleted file mode 100644 index 3a58463f0..000000000 --- a/nms/FlattenedProvider/src/net/ess3/nms/flattened/FlatItemDbProvider.java +++ /dev/null @@ -1,209 +0,0 @@ -package net.ess3.nms.flattened; - -import com.google.gson.Gson; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; -import net.ess3.nms.ItemDbProvider; -import org.bukkit.Material; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; -import org.bukkit.inventory.meta.PotionMeta; -import org.bukkit.potion.PotionData; - -import java.util.*; -import java.util.stream.Collectors; - -public class FlatItemDbProvider extends ItemDbProvider { - private static Gson gson = new Gson(); - - private final transient Map primaryNames = new HashMap<>(); - private final transient Map> names = new HashMap<>(); - - @Override - public ItemData resolve(String name) { - return getByName(name); - } - - @Override - public boolean supportsLegacyIds() { - return false; - } - - @Override - public int getLegacyId(Material material) { - return -1; - } - - @Override - public Material getFromLegacyId(int id) { - return null; - } - - @Override - public String getPrimaryName(ItemStack item) { - ItemData itemData = new FlatItemData(null, item.getType(), getPotionData(item)); - - for (Map.Entry entry : primaryNames.entrySet()) { - if (entry.getValue().equals(itemData)) { - return entry.getKey(); - } - } - - return null; - } - - private PotionData getPotionData(ItemStack item) { - ItemMeta meta = item.getItemMeta(); - if (meta instanceof PotionMeta) { - return ((PotionMeta) meta).getBasePotionData(); - } - - return null; - } - - @Override - public List getNames(ItemStack item) { - String primaryName = getPrimaryName(item); - - for (Map.Entry> entry : names.entrySet()) { - if (entry.getKey().equals(primaryName)) { - return Collections.unmodifiableList(entry.getValue()); - } - } - return null; - } - - @Override - public ItemStack getStack(String name) throws Exception { - ItemData data = Objects.requireNonNull(getByName(name)); - PotionData potionData = data.getPotionData(); - Material material = data.getMaterial(); - - ItemStack stack = new ItemStack(material); - - if (potionData != null) { - PotionMeta meta = (PotionMeta) stack.getItemMeta(); - meta.setBasePotionData(potionData); - stack.setItemMeta(meta); - } - - return stack; - } - - @Override - public Collection listNames() { - return Collections.unmodifiableSet(primaryNames.keySet()); - } - - private ItemData getByName(String name) { - if (primaryNames.containsKey(name.toLowerCase())) { - return primaryNames.get(name); - } else { - for (Map.Entry> entry : names.entrySet()) { - if (entry.getValue().contains(name.toLowerCase())) { - return primaryNames.get(entry.getKey()); - } - } - } - - return null; - } - - private void resetDb() { - primaryNames.clear(); - names.clear(); - } - - @Override - public void addFrom(List lines) { - String json = lines.stream() - .filter(line -> !line.startsWith("#")) - .collect(Collectors.joining("\n")); - - JsonObject map = (new JsonParser()).parse(json).getAsJsonObject(); - - for (Map.Entry entry : map.entrySet()) { - String key = entry.getKey(); - JsonElement element = entry.getValue(); - - if (element.isJsonObject()) { - FlatItemData data = gson.fromJson(element, FlatItemData.class); - primaryNames.put(key, data); - } else { - try { - String target = element.getAsString(); - addAlias(target, key); - } catch (Exception e) { - // TODO: log invalid entry - } - } - } - } - - @Override - public void rebuild(List lines) { - resetDb(); - addFrom(lines); - } - - private void addAlias(String primaryName, String alias) { - List aliasList; - - if (names.containsKey(primaryName)) { - aliasList = names.get(primaryName); - } else { - aliasList = new ArrayList<>(); - names.put(primaryName, aliasList); - } - - aliasList.add(alias); - } - - @Override - public boolean tryProvider() { - // Build the database initially so that we can actually test the provider - this.rebuild(this.loadResource("/items.json")); - return super.tryProvider(); - } - - @Override - public String getHumanName() { - return "Post-1.13 item database provider"; - } - - public static class FlatItemData extends ItemData { - private FlatItemData(String itemName, Material material, PotionData potionData) { - this.itemName = itemName; - this.material = material; - this.potionData = potionData; - } - - @Override - public int hashCode() { - return (31 * material.hashCode()) ^ potionData.hashCode(); - } - - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (!(o instanceof ItemData)) { - return false; - } - ItemData pairo = (ItemData) o; - return this.material == pairo.getMaterial() && potionDataEquals(pairo); - } - - private boolean potionDataEquals(ItemData o) { - if (this.potionData == null && o.getPotionData() == null) { - return true; - } else if (this.potionData != null && o.getPotionData() != null) { - return this.potionData.equals(o.getPotionData()); - } else { - return false; - } - } - } -} diff --git a/nms/IdProvider/pom.xml b/nms/IdProvider/pom.xml deleted file mode 100644 index 3756f2e7f..000000000 --- a/nms/IdProvider/pom.xml +++ /dev/null @@ -1,32 +0,0 @@ - - - - EssentialsXParent - net.ess3 - 2.15.0 - ../../pom.xml - - 4.0.0 - - IdProvider - - - - net.ess3 - NMSProvider - 2.15.0 - - - net.ess3 - ReflectionProvider - 2.15.0 - - - org.bukkit - bukkit - 1.12.2-R0.1-SNAPSHOT - - - \ No newline at end of file diff --git a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java b/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java deleted file mode 100644 index 1d10106f1..000000000 --- a/nms/IdProvider/src/net/ess3/nms/ids/LegacyItemDbProvider.java +++ /dev/null @@ -1,331 +0,0 @@ -package net.ess3.nms.ids; - -import net.ess3.nms.ItemDbProvider; -import net.ess3.nms.refl.ReflUtil; -import org.apache.commons.lang.StringUtils; -import org.bukkit.Bukkit; -import org.bukkit.Material; -import org.bukkit.entity.EntityType; -import org.bukkit.inventory.ItemStack; - -import java.util.*; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -public class LegacyItemDbProvider extends ItemDbProvider { - // Maps all item names to legacy IDs - private final transient Map items = new HashMap<>(); - - // Maps item data to all known names for an item - private final transient Map> names = new HashMap<>(); - - // Maps item data to the primary name for an item - private final transient Map primaryNames = new HashMap<>(); - - // Maps legacy IDs to item data - private final transient Map legacyIds = new HashMap<>(); - - // Maps names for an item to durability/meta values - private final transient Map durabilities = new HashMap<>(); - - // Maps names for an item to NBT data - private final transient Map nbtData = new HashMap<>(); - - private final transient Pattern splitPattern = Pattern.compile("((.*)[:+',;.](\\d+))"); - private final transient Pattern csvSplitPattern = Pattern.compile("(\"([^\"]*)\"|[^,]*)(,|$)"); - - @Override - public ItemData resolve(String name) { - // TODO: refactor getStack into here - return null; - } - - @Override - public ItemStack getStack(String name) throws Exception { - int itemid = 0; - String itemname; - short metaData = 0; - - // If the user provided id:metadata, split it - Matcher parts = splitPattern.matcher(name); - if (parts.matches()) { - itemname = parts.group(2); - metaData = Short.parseShort(parts.group(3)); - } else { - itemname = name; - } - - // Check whether the user provided an ID - if (isInt(itemname)) { - itemid = Integer.parseInt(itemname); - } else if (isInt(name)) { - itemid = Integer.parseInt(name); - } else { - itemname = itemname.toLowerCase(Locale.ENGLISH); - } - - if (itemid < 1) { - if (items.containsKey(itemname)) { - itemid = items.get(itemname); - if (durabilities.containsKey(itemname) && metaData == 0) { - metaData = durabilities.get(itemname); - } - } - } - - if (itemid < 1) { - throw new Exception("Unknown item name " + itemname); - } - - ItemData data = legacyIds.get(itemid); - if (data == null) { - throw new Exception("Unknown item ID " + itemid); - } - - Material mat = data.getMaterial(); - ItemStack retval = new ItemStack(mat); - if (nbtData.containsKey(itemname)) { - String nbt = nbtData.get(itemname); - if (nbt.startsWith("*")) { - nbt = nbtData.get(nbt.substring(1)); - } - retval = Bukkit.getServer().getUnsafe().modifyItemStack(retval, nbt); - } - - - Material MOB_SPAWNER; - try { - MOB_SPAWNER = Material.valueOf("SPAWNER"); - } catch (Exception e) { - MOB_SPAWNER = Material.valueOf("MOB_SPAWNER"); - } - if (mat == MOB_SPAWNER) { - if (metaData == 0) metaData = EntityType.PIG.getTypeId(); - try { - retval = getSpawnerProvider().setEntityType(retval, EntityType.fromId(metaData)); - } catch (IllegalArgumentException e) { - throw new Exception("Can't spawn entity ID " + metaData + " from mob spawners."); - } - } else if (mat == Material.MONSTER_EGG) { - EntityType type; - try { - type = EntityType.fromId(metaData); - } catch (IllegalArgumentException e) { - throw new Exception("Can't spawn entity ID " + metaData + " from spawn eggs."); - } - retval = getSpawnEggProvider().createEggItem(type); - } else if ((mat.name().endsWith("POTION") || mat.name().equals("TIPPED_ARROW")) - && ReflUtil.getNmsVersionObject().isLowerThan(ReflUtil.V1_11_R1)) { // Only apply this to pre-1.11 as items.csv might only work in 1.11 - retval = getPotionMetaProvider().createPotionItem(mat, metaData); - } else { - retval.setDurability(metaData); - } - retval.setAmount(mat.getMaxStackSize()); - return retval; - } - - @Override - public Collection listNames() { - return primaryNames.values(); - } - - @Override - public boolean supportsLegacyIds() { - return true; - } - - @Override - public int getLegacyId(Material material) throws Exception { - for (Map.Entry entry : items.entrySet()) { - if (material.name().toLowerCase(Locale.ENGLISH).equalsIgnoreCase(entry.getKey())) { - return entry.getValue(); - } - } - - throw new Exception("Item ID missing for material " + material.name()); - } - - @Override - public Material getFromLegacyId(int id) { - ItemData data = this.legacyIds.get(id); - if (data == null) { - return null; - } - - return data.getMaterial(); - } - - @Override - public String getPrimaryName(ItemStack item) { - ItemData itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); - String name = primaryNames.get(itemData); - if (name == null) { - itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), (short) 0, null); - name = primaryNames.get(itemData); - if (name == null) { - return null; - } - } - return name; - } - - @Override - public List getNames(ItemStack item) { - ItemData itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), item.getDurability(), null); - List nameList = names.get(itemData); - if (nameList == null) { - itemData = new LegacyItemData(null, item.getType(), item.getTypeId(), (short) 0, null); - nameList = names.get(itemData); - if (nameList == null) { - return null; - } - } - - return nameList; - } - - private void resetDb() { - durabilities.clear(); - items.clear(); - names.clear(); - primaryNames.clear(); - } - - @Override - public void addFrom(List lines) { - lines.stream() - .filter(line -> line.length() > 0 && !(line.charAt(0) == '#')) - .map(this::parseLine) - .filter(Objects::nonNull) - .forEach(this::addItem); - - for (List nameList : names.values()) { - nameList.sort(LengthCompare.INSTANCE); - } - } - - @Override - public void rebuild(List lines) { - resetDb(); - addFrom(lines); - } - - private LegacyItemData parseLine(String line) { - String itemName = null; - int numeric = -1; - short data = 0; - String nbt = null; - - int col = 0; - Matcher matcher = csvSplitPattern.matcher(line); - while (matcher.find()) { - String match = matcher.group(1); - if (StringUtils.stripToNull(match) == null) { - continue; - } - match = StringUtils.strip(match.trim(), "\""); - switch (col) { - case 0: - itemName = match.toLowerCase(Locale.ENGLISH); - break; - case 1: - numeric = Integer.parseInt(match); - break; - case 2: - data = Short.parseShort(match); - break; - case 3: - nbt = StringUtils.stripToNull(match); - break; - default: - continue; - } - col++; - } - // Invalid row - if (itemName == null || numeric < 0) { - return null; - } - - Material material = Material.matchMaterial(itemName); - if (material == null) { - return null; - } - - return new LegacyItemData(itemName, material, numeric, data, nbt); - } - - private void addItem(LegacyItemData itemData) { - final String name = itemData.getItemName(); - final int numeric = itemData.getItemNo(); - final short data = itemData.getItemData(); - final String nbt = itemData.getNbt(); - - durabilities.put(name, data); - items.put(name, numeric); - - if (nbt != null) { - nbtData.put(itemData.getItemName(), nbt); - } - - if (names.containsKey(itemData)) { - List nameList = names.get(itemData); - nameList.add(name); - } else { - List nameList = new ArrayList<>(); - nameList.add(name); - names.put(itemData, nameList); - primaryNames.put(itemData, name); - } - - legacyIds.put(numeric, itemData); - } - - @Override - public boolean tryProvider() { - // Build the database initially so that we can actually test the provider - this.rebuild(this.loadResource("/items.csv")); - return super.tryProvider(); - } - - @Override - public String getHumanName() { - return "Pre-1.13 item database provider"; - } - - private boolean isInt(String integer) { - try { - Integer.parseInt(integer); - return true; - } catch (NumberFormatException e) { - return false; - } - } - - public static class LegacyItemData extends ItemData { - private LegacyItemData(String itemName, Material material, final int legacyId, final short itemData, String nbt) { - this.itemName = itemName; - this.material = material; - this.legacyId = legacyId; - this.itemData = itemData; - this.nbt = nbt; - } - - @Override - public int hashCode() { - return (31 * legacyId) ^ itemData; - } - - @Override - public boolean equals(Object o) { - if (o == null) { - return false; - } - if (!(o instanceof ItemData)) { - return false; - } - ItemData pairo = (ItemData) o; - return this.legacyId == pairo.getItemNo() && this.itemData == pairo.getItemData(); - } - } -} diff --git a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java b/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java deleted file mode 100644 index e4a3278cc..000000000 --- a/nms/NMSProvider/src/net/ess3/nms/ItemDbProvider.java +++ /dev/null @@ -1,236 +0,0 @@ -package net.ess3.nms; - -import net.ess3.providers.Provider; -import org.bukkit.Material; -import org.bukkit.inventory.ItemStack; -import org.bukkit.potion.PotionData; -import org.bukkit.potion.PotionType; - -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStreamReader; -import java.util.Collection; -import java.util.List; -import java.util.stream.Collectors; - -public abstract class ItemDbProvider implements Provider { - - private SpawnerProvider spawnerProvider; - private SpawnEggProvider spawnEggProvider; - private PotionMetaProvider potionMetaProvider; - - /** - * Populate the item database using the given lines of data. - * - * @param lines The lines of data from which the database should be populated - */ - public abstract void addFrom(List lines); - - /** - * Reset the database and rebuild it from the given lines of data. - * - * @param lines The lines of the file from which the database should be built - */ - public abstract void rebuild(List lines); - - /** - * Read a resource from the jar. - * Used to build the database before data from a ManagedFile is available. - * - * @param name The name of the resource to load. - * @return The lines of the resource. - */ - protected List loadResource(final String name) { - try (InputStreamReader isr = new InputStreamReader(ItemDbProvider.class.getResourceAsStream(name))) { - BufferedReader br = new BufferedReader(isr); - return br.lines().collect(Collectors.toList()); - } catch (IOException e) { - return null; - } - } - - /** - * Resolves a material name to the corresponding ItemData. - * - * @param name The item name to look up - * @return The corresponding ItemData for the given name - */ - public abstract ItemData resolve(String name); - - /** - * Whether the provider supports legacy ID values or not. - * - * @return True if the provider supports legacy IDs, otherwise false - */ - public abstract boolean supportsLegacyIds(); - - /** - * Get the legacy ID for the material. - * - * @param material The material to look up - * @return The ID corresponding to the material, or null if not supported - */ - public abstract int getLegacyId(Material material) throws Exception; - - /** - * Get the material for the legacy ID. - * - * @param id The ID to look up - * @return The material corresponding to the ID, or -1 if not supported - */ - public abstract Material getFromLegacyId(int id); - - /** - * Get the primary name for the item in the given stack. - * - * @param item The ItemStack to check - * @return The primary name for the item - */ - public abstract String getPrimaryName(ItemStack item); - - /** - * Get all names for the item in the given stack. - * - * @param item The ItemStack to check - * @return The names for the item - */ - public abstract List getNames(ItemStack item); - - /** - * Creates a stack of a given item by its name. - * - * @param name The material name to look up - * @return An ItemStack of size 1 of the given item - */ - public abstract ItemStack getStack(String name) throws Exception; - - /** - * Creates a stack with the given amount of a given item by its name. - * - * @param name The material name to look up - * @param amount The amount of items in the returned ItemStack - * @return An ItemStack with the given amount of the given item - */ - public ItemStack getStack(String name, int amount) throws Exception { - ItemStack is = getStack(name); - is.setAmount(amount); - return is; - } - - /** - * Get all registered primary names for materials. - * This does not include any additional aliases. - * - * @return A collection of primary names - */ - public abstract Collection listNames(); - - @Override - public boolean tryProvider() { - try { - getStack("cobblestone"); - getStack("dstone"); - getStack("steelbar", 5); - getStack("splbreathlevel2pot"); - getStack("skeletonhorsespawnegg", 12); - return true; - } catch (Exception e) { - return false; - } - } - - /** - * Get the current spawner provider. - * - * @return The current spawner provider - */ - protected SpawnerProvider getSpawnerProvider() { - return spawnerProvider; - } - - /** - * Set the current spawner provider. - */ - public void setSpawnerProvider(SpawnerProvider spawnerProvider) { - this.spawnerProvider = spawnerProvider; - } - - /** - * Get the current spawn egg provider. - * - * @return The current spawn egg provider - */ - protected SpawnEggProvider getSpawnEggProvider() { - return spawnEggProvider; - } - - /** - * Set the current spawn egg provider. - */ - public void setSpawnEggProvider(SpawnEggProvider spawnEggProvider) { - this.spawnEggProvider = spawnEggProvider; - } - - /** - * Get the current potion provider. - * - * @return The current potion provider - */ - protected PotionMetaProvider getPotionMetaProvider() { - return potionMetaProvider; - } - - /** - * Set the current potion provider. - */ - public void setPotionMetaProvider(PotionMetaProvider potionMetaProvider) { - this.potionMetaProvider = potionMetaProvider; - } - - public abstract static class ItemData { - protected String itemName; - protected Material material; - protected int legacyId; - protected short itemData; - protected String nbt; - protected PotionData potionData; - - public String getItemName() { - return itemName; - } - - public Material getMaterial() { - return material; - } - - public int getItemNo() { - return legacyId; - } - - public short getItemData() { - return itemData; - } - - public String getNbt() { - return nbt; - } - - public PotionData getPotionData() { - return this.potionData; - } - } - - protected static class LengthCompare implements java.util.Comparator { - - public static final LengthCompare INSTANCE = new LengthCompare(); - - public LengthCompare() { - super(); - } - - @Override - public int compare(String s1, String s2) { - return s1.length() - s2.length(); - } - } -} diff --git a/pom.xml b/pom.xml index 4682d642f..f6b67fb0b 100644 --- a/pom.xml +++ b/pom.xml @@ -47,7 +47,6 @@ nms/1_8_R2Provider nms/LegacyProvider nms/ReflectionProvider - nms/IdProvider nms/FlattenedProvider From e9b151111777abb429a62a9590e6e09e358a28dd Mon Sep 17 00:00:00 2001 From: md678685 Date: Fri, 12 Oct 2018 17:26:41 +0100 Subject: [PATCH 48/62] Remove item ID support in Worth --- .../src/com/earth2me/essentials/Worth.java | 30 +------------------ 1 file changed, 1 insertion(+), 29 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/Worth.java b/Essentials/src/com/earth2me/essentials/Worth.java index ef3c4c034..12779f785 100644 --- a/Essentials/src/com/earth2me/essentials/Worth.java +++ b/Essentials/src/com/earth2me/essentials/Worth.java @@ -23,17 +23,10 @@ public class Worth implements IConf { public BigDecimal getPrice(IEssentials essentials, ItemStack itemStack) { BigDecimal result; - int itemId; - - try { - itemId = essentials.getItemDb().getLegacyId(itemStack.getType()); - } catch (Exception e) { - return null; - } String itemname = itemStack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", ""); - //First check for matches with item name + // Check for matches with item name result = config.getBigDecimal("worth." + itemname + "." + itemStack.getDurability(), BigDecimal.ONE.negate()); if (result.signum() < 0) { final ConfigurationSection itemNameMatch = config.getConfigurationSection("worth." + itemname); @@ -48,27 +41,6 @@ public class Worth implements IConf { result = config.getBigDecimal("worth." + itemname, BigDecimal.ONE.negate()); } - //Now we should check for item ID - if (result.signum() < 0) { - result = config.getBigDecimal("worth." + itemId + "." + itemStack.getDurability(), BigDecimal.ONE.negate()); - } - if (result.signum() < 0) { - final ConfigurationSection itemNumberMatch = config.getConfigurationSection("worth." + itemId); - if (itemNumberMatch != null && itemNumberMatch.getKeys(false).size() == 1) { - result = config.getBigDecimal("worth." + itemId + ".0", BigDecimal.ONE.negate()); - } - } - if (result.signum() < 0) { - result = config.getBigDecimal("worth." + itemId + ".*", BigDecimal.ONE.negate()); - } - if (result.signum() < 0) { - result = config.getBigDecimal("worth." + itemId, BigDecimal.ONE.negate()); - } - - //This is to match the old worth syntax - if (result.signum() < 0) { - result = config.getBigDecimal("worth-" + itemId, BigDecimal.ONE.negate()); - } if (result.signum() < 0) { return null; } From 18feb7967ad7054f35fc5e82174358b7c93c781b Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 15:26:58 +0100 Subject: [PATCH 49/62] Implement missing FakeWorld and OfflinePlayer methods --- .../earth2me/essentials/OfflinePlayer.java | 28 ++++++++++++++++++- .../essentials/craftbukkit/FakeWorld.java | 10 +++++++ 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/Essentials/src/com/earth2me/essentials/OfflinePlayer.java b/Essentials/src/com/earth2me/essentials/OfflinePlayer.java index 9730fa667..2b6b150b8 100644 --- a/Essentials/src/com/earth2me/essentials/OfflinePlayer.java +++ b/Essentials/src/com/earth2me/essentials/OfflinePlayer.java @@ -8,6 +8,7 @@ import org.bukkit.advancement.AdvancementProgress; import org.bukkit.attribute.Attribute; import org.bukkit.attribute.AttributeInstance; import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; import org.bukkit.block.PistonMoveReaction; import org.bukkit.block.data.BlockData; import org.bukkit.conversations.Conversation; @@ -956,6 +957,26 @@ public class OfflinePlayer implements Player { return 0; } + @Override + public boolean discoverRecipe(NamespacedKey recipe) { + return false; + } + + @Override + public int discoverRecipes(Collection recipes) { + return 0; + } + + @Override + public boolean undiscoverRecipe(NamespacedKey recipe) { + return false; + } + + @Override + public int undiscoverRecipes(Collection recipes) { + return 0; + } + @Override public boolean hasLineOfSight(Entity entity) { return false; @@ -1530,7 +1551,12 @@ public class OfflinePlayer implements Player { return null; } - @Override + @Override + public BlockFace getFacing() { + return null; + } + + @Override public void updateCommands() { } } diff --git a/Essentials/src/com/earth2me/essentials/craftbukkit/FakeWorld.java b/Essentials/src/com/earth2me/essentials/craftbukkit/FakeWorld.java index a6497378c..feb412284 100644 --- a/Essentials/src/com/earth2me/essentials/craftbukkit/FakeWorld.java +++ b/Essentials/src/com/earth2me/essentials/craftbukkit/FakeWorld.java @@ -84,6 +84,11 @@ public class FakeWorld implements World { throw new UnsupportedOperationException("Not supported yet."); } + @Override + public boolean isChunkGenerated(int x, int z) { + throw new UnsupportedOperationException("Not supported yet."); + } + @Override public void loadChunk(int i, int i1) { throw new UnsupportedOperationException("Not supported yet."); @@ -714,6 +719,11 @@ public class FakeWorld implements World { throw new UnsupportedOperationException("Not supported yet."); } + @Override + public Location locateNearestStructure(Location origin, StructureType structureType, int radius, boolean findUnexplored) { + throw new UnsupportedOperationException("Not supported yet."); + } + @Override public List getNearbyEntities(Location loc, double x, double y, double z) { throw new UnsupportedOperationException("Not supported yet."); From 3262143c734608485a8971d1bae8efae2f989114 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 15:30:19 +0100 Subject: [PATCH 50/62] Implement missing FakeServer methods --- .../test/com/earth2me/essentials/FakeServer.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/Essentials/test/com/earth2me/essentials/FakeServer.java b/Essentials/test/com/earth2me/essentials/FakeServer.java index 339335f4a..1647c0a64 100644 --- a/Essentials/test/com/earth2me/essentials/FakeServer.java +++ b/Essentials/test/com/earth2me/essentials/FakeServer.java @@ -443,6 +443,16 @@ public class FakeServer implements Server { throw new UnsupportedOperationException("Not supported yet."); } + @Override + public ItemStack createExplorerMap(World world, Location location, StructureType structureType) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public ItemStack createExplorerMap(World world, Location location, StructureType structureType, int radius, boolean findUnexplored) { + throw new UnsupportedOperationException("Not supported yet."); + } + @Override public boolean getAllowFlight() { throw new UnsupportedOperationException("Not supported yet."); From feba535637eb3011322e242cd0262dbc1e1f6d88 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 15:38:45 +0100 Subject: [PATCH 51/62] Actually assign the ManagedFile to file --- Essentials/src/com/earth2me/essentials/ItemDb.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index c9ef5554e..30845f092 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -46,7 +46,7 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public void reloadConfig() { if (file == null) { - new ManagedFile("items.json", ess); + file = new ManagedFile("items.json", ess); } this.rebuild(); From f78887a02ec01b3f52898145b5998c5a0768a68f Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 15:59:25 +0100 Subject: [PATCH 52/62] Remove item IDs from /itemdb --- .../essentials/commands/Commanditemdb.java | 3 +-- Essentials/src/messages.properties | 2 +- Essentials/src/messages_cs.properties | 2 +- Essentials/src/messages_da.properties | 4 ++-- Essentials/src/messages_de.properties | 2 +- Essentials/src/messages_en.properties | 2 +- Essentials/src/messages_es.properties | 4 ++-- Essentials/src/messages_et.properties | 4 ++-- Essentials/src/messages_fi.properties | 4 ++-- Essentials/src/messages_fr.properties | 4 ++-- Essentials/src/messages_hu.properties | 4 ++-- Essentials/src/messages_it.properties | 2 +- Essentials/src/messages_ko.properties | 20 +++++++++---------- Essentials/src/messages_lt.properties | 2 +- Essentials/src/messages_nl.properties | 8 ++++---- Essentials/src/messages_pl.properties | 2 +- Essentials/src/messages_pt.properties | 2 +- Essentials/src/messages_pt_BR.properties | 2 +- Essentials/src/messages_ro.properties | 4 ++-- Essentials/src/messages_ru.properties | 2 +- Essentials/src/messages_sv.properties | 6 +++--- Essentials/src/messages_tr.properties | 4 ++-- Essentials/src/messages_vi.properties | 2 +- Essentials/src/messages_zh.properties | 2 +- Essentials/src/messages_zh_HK.properties | 2 +- Essentials/src/messages_zh_TW.properties | 2 +- 26 files changed, 48 insertions(+), 49 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java b/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java index 43f29e49a..0e5530fde 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java @@ -32,8 +32,7 @@ public class Commanditemdb extends EssentialsCommand { itemStack = ess.getItemDb().get(args[0]); } - int itemId = ess.getItemDb().getLegacyId(itemStack.getType()); - sender.sendMessage(tl("itemType", itemStack.getType().toString(), itemId + ":" + Integer.toString(itemStack.getDurability()))); + sender.sendMessage(tl("itemType", itemStack.getType().toString())); if (itemHeld && itemStack.getType() != Material.AIR) { int maxuses = itemStack.getType().getMaxDurability(); diff --git a/Essentials/src/messages.properties b/Essentials/src/messages.properties index aef95252f..8a5533dc6 100644 --- a/Essentials/src/messages.properties +++ b/Essentials/src/messages.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aSold for \u00a7c{0} \u00a7a({1} {2} at {3} each). itemSoldConsole=\u00a7a{0} \u00a7asold {1} for \u00a7a{2} \u00a7a({3} items at {4} each). itemSpawn=\u00a76Giving\u00a7c {0} \u00a76of\u00a7c {1} -itemType=\u00a76Item\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Item\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Person is already in jail\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74You do the crime, you do the time. diff --git a/Essentials/src/messages_cs.properties b/Essentials/src/messages_cs.properties index 6cda49091..909fc339c 100644 --- a/Essentials/src/messages_cs.properties +++ b/Essentials/src/messages_cs.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Nemas zadne predmety ktere lze prevest na bloky. itemSold=\u00a7aProdano za \u00a7c{0} \u00a7a({1} {2} za cenu {3} kus) itemSoldConsole=\u00a7a{0} \u00a7aProdano {1} za \u00a7a{2} \u00a7a({3} za cenu {4} kus). itemSpawn=\u00a76Davam\u00a7c {0}\u00a7c {1} -itemType=\u00a76Predmet\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Predmet\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Tento hrace ja jiz uveznen\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Porusil jsi pravidla, ted si to odsedis\! diff --git a/Essentials/src/messages_da.properties b/Essentials/src/messages_da.properties index e0d6681b1..db22a3125 100644 --- a/Essentials/src/messages_da.properties +++ b/Essentials/src/messages_da.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Hold venligst et spillerkranie. invalidWarpName=\u00a74Ugyldigt warp navn. invalidWorld=\u00a74Ugyldig verden. inventoryClearFail=\u00a74Spilleren {0} \u00a74har ikke\u00a7c {1} \u00a74af\u00a7c {2}\u00a74. -inventoryClearingAllArmor=\u00a76Rydede alle inventar-elementer og armor fra{0}\u00a76. +inventoryClearingAllArmor=\u00a76Rydede alle inventar-elementer og armor fra{0}\u00a76. inventoryClearingAllItems=\u00a76Ryddede alle inventar-elementer fra {0}\u00a76. inventoryClearingAllStack=\u00a76Ryddede alle\u00a7c {0} \u00a76fra {1}\u00a76. inventoryClearingFromAll=\u00a76Rydder alle spilleres inventar... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aSolgt for \u00a7c{0} \u00a7a({1} {2} for {3} hver). itemSoldConsole=\u00a7a{0} \u00a7asolgt {1} for \u00a7a{2} \u00a7a({3} elementer for {4} hver). itemSpawn=\u00a76Giver\u00a7c {0} \u00a76af\u00a7c {1} -itemType=\u00a76Element\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Element\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Spilleren er allerede i f\u00e6ngsel\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7cDu bryder reglerne, du tager straffen. diff --git a/Essentials/src/messages_de.properties b/Essentials/src/messages_de.properties index 4636439cf..1d40b8198 100644 --- a/Essentials/src/messages_de.properties +++ b/Essentials/src/messages_de.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Du hast keine Items die in Bl\u00f6cke konvertiert werd itemSold=\u00a7aVerkauft f\u00fcr \u00a7c{0}\u00a7a ({1} {2} Einheiten je {3}) itemSoldConsole=\u00a7a{0} $averkauft {1} f\u00fcr \u00a7a{2} \u00a7a({3} Einheiten je {4}) itemSpawn=\u00a76Gebe\u00a7c {0}\u00a76x\u00a7c {1} -itemType=\u00a76Gegenstand\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Gegenstand\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Spieler ist bereits im Gef\u00e4ngnis\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Du hast ein Verbrechen begangen, also musst du deine Zeit absitzen. diff --git a/Essentials/src/messages_en.properties b/Essentials/src/messages_en.properties index 92f5cf3d2..77a2f0b77 100644 --- a/Essentials/src/messages_en.properties +++ b/Essentials/src/messages_en.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aSold for \u00a7c{0} \u00a7a({1} {2} at {3} each). itemSoldConsole=\u00a7a{0} \u00a7asold {1} for \u00a7a{2} \u00a7a({3} items at {4} each). itemSpawn=\u00a76Giving\u00a7c {0} \u00a76of\u00a7c {1} -itemType=\u00a76Item\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Item\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Person is already in jail\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74You do the crime, you do the time. diff --git a/Essentials/src/messages_es.properties b/Essentials/src/messages_es.properties index 9a551c22f..89d139d6e 100644 --- a/Essentials/src/messages_es.properties +++ b/Essentials/src/messages_es.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Por favor sost\u00e9n un cr\u00e1neo de un jugador. invalidWarpName=\u00a74\u00a1Nombre del Warp no reconocido\! invalidWorld=\u00a74Mundo erroneo o no cargado. inventoryClearFail=\u00a74El jugador {0} \u00a74no tiene\u00a7c {1} \u00a74de\u00a7c {2}\u00a74. -inventoryClearingAllArmor=\u00a7eLimpiado objetos y armaduras de\u00a7a {0}\u00a7e. +inventoryClearingAllArmor=\u00a7eLimpiado objetos y armaduras de\u00a7a {0}\u00a7e. inventoryClearingAllItems=\u00a76Limpiado todos los objetos del inventario a\u00a76 {0}. inventoryClearingAllStack=\u00a76Inventario limpiado completamente a \u00a7c {0} \u00a76de {1}\u00a76. inventoryClearingFromAll=\u00a77Limpiando el inventario de todos los usuarios... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74No tienes items que puedan ser convertidos a bloques. itemSold=\u00a77Vendido por \u00a7c {0} \u00a77 ({1} {2} a {3} cada uno). itemSoldConsole={0} Vendio {1} por\u00a77 {2} \u00a77({3} objetos a {4} cada uno) itemSpawn=\u00a76Dando {0} de {1} -itemType=\u00a76Objeto\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Objeto\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Ese jugador ya est\u00e1 en la c\u00e1rcel\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7c\u00a1Por el crimen hacer, a la c\u00e1rcel ir\u00e1s\! diff --git a/Essentials/src/messages_et.properties b/Essentials/src/messages_et.properties index 17d683795..9629d7549 100644 --- a/Essentials/src/messages_et.properties +++ b/Essentials/src/messages_et.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Palun hoia k\u00e4es m\u00e4ngija koljut. invalidWarpName=\u00a74Vigane l\u00f5imu nimi\! invalidWorld=\u00a74Vigane maailm. inventoryClearFail=\u00a74M\u00e4ngijal {0} \u00a74ei ole\u00a7c {1} \u00a74eset\u00a7c {2}\u00a74. -inventoryClearingAllArmor=\u00a76Puhastati k\u00f5ik seljakoti esemed ja armor\: {0}\u00a76. +inventoryClearingAllArmor=\u00a76Puhastati k\u00f5ik seljakoti esemed ja armor\: {0}\u00a76. inventoryClearingAllItems=\u00a76Puhastati k\u00f5ik seljakoti esemed\: {0}\u00a76. inventoryClearingAllStack=\u00a76Eemaldati k\u00f5ik\u00a7c {0} \u00a76m\u00e4ngijalt {1}\u00a76. inventoryClearingFromAll=\u00a76T\u00fchjendan k\u00f5ikide m\u00e4ngijate seljakoti... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aM\u00fc\u00fcs hinnaga \u00a7c{0} \u00a7a({1} {2} asukohas {3} \u00fche eest). itemSoldConsole=\u00a7a{0} \u00a7am\u00fc\u00fcs {1} hinnaga \u00a7a{2} \u00a7a({3} eset asukohas {4} \u00fche eest). itemSpawn=\u00a76Annan\u00a7c {0}\u00a7c {1}\u00a76-i -itemType=\u00a76Ese\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Ese\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74M\u00e4ngija on juba vanglas\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Sooritad kuriteo, oled vangis ka. diff --git a/Essentials/src/messages_fi.properties b/Essentials/src/messages_fi.properties index 97e241367..c5aa6c6b1 100644 --- a/Essentials/src/messages_fi.properties +++ b/Essentials/src/messages_fi.properties @@ -162,7 +162,7 @@ hatPlaced=\u00a7eNauti uudesta hatustasi\! hatRemoved=\u00a76Hattusi on poistettu. haveBeenReleased=\u00a77Sinut on vapautettu heal=\u00a77Sinut on parannettu. -healDead=\u00a74Et voi parantaa pelaajaa, joka on kuollut\! +healDead=\u00a74Et voi parantaa pelaajaa, joka on kuollut\! healOther=\u00a77Paransit pelaajan {0}. helpConsole=Katsoaksesi apua konsolista, kirjoita ?. helpFrom=\u00a77Komennot {0}\: @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a77Myy \u00a7c{0} \u00a77({1} {2} hintaan {3} kpl) itemSoldConsole={0} sold {1} for \u00a77{2} \u00a77({3} items at {4} each) itemSpawn=\u00a77Annetaan {0} kpl {1} -itemType=\u00a76Item\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Item\:\u00a7c {0} jailAlreadyIncarcerated=\u00a7cPelaaja on jo vankilassa\: {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7cSin\u00e4 teet rikoksen, istut my\u00f6s sen mukaan. diff --git a/Essentials/src/messages_fr.properties b/Essentials/src/messages_fr.properties index b0562b6e4..fd2706274 100644 --- a/Essentials/src/messages_fr.properties +++ b/Essentials/src/messages_fr.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Vous devez tenir une t\u00eate de joueur. invalidWarpName=\u00a74Nom de warp invalide. invalidWorld=\u00a7cMonde invalide. inventoryClearFail=\u00a74Le joueur {0} \u00a74n''a pas\u00a7c {1}\u00a7c {2}\u00a74 sur lui. -inventoryClearingAllArmor=\u00a76Tous les items de l''inventaire et l''armure de {0}\u00a76 ont \u00e9t\u00e9 supprim\u00e9s. +inventoryClearingAllArmor=\u00a76Tous les items de l''inventaire et l''armure de {0}\u00a76 ont \u00e9t\u00e9 supprim\u00e9s. inventoryClearingAllItems=\u00a76Tous les items de l''inventaire de {0}\u00a76 ont \u00e9t\u00e9 supprim\u00e9s. inventoryClearingAllStack=\u00a76Tous les\u00a7c {0} \u00a76de l''inventaire de {1}\u00a76 ont \u00e9t\u00e9 supprim\u00e9s. inventoryClearingFromAll=\u00a76Tous les inventaires sont en train d''\u00ea vid\u00e9s... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Vous n''avez pas d''items pouvant \u00eatre convertis e itemSold=\u00a77Vendu pour \u00a7c{0} \u00a77({1} {2} \u00e0 {3} chacun) itemSoldConsole={0} vendu {1} pour \u00a77{2} \u00a77({3} objet(s) \u00e0 {4} chacun) itemSpawn=\u00a77Donne {0} de {1} -itemType=\u00a76Item \:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Item \:\u00a7c {0} jailAlreadyIncarcerated=\u00a7cJoueur d\u00e9j\u00e0 emprisonn\u00e9 \: {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7cVous avez commis un crime, vous en payez le prix. diff --git a/Essentials/src/messages_hu.properties b/Essentials/src/messages_hu.properties index 50c676753..b64363d2b 100644 --- a/Essentials/src/messages_hu.properties +++ b/Essentials/src/messages_hu.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Nincs olyan elem, amely blokk\u00e1 alak\u00edthat\u00f itemSold=\u00a7aEladva \u00a7c{0} \u00a7a({1} {2} {3} minden). itemSoldConsole=\u00a7a{0} \u00a7aeladva {1} \u00a7a{2} \u00a7a({3} elem {4} minden). itemSpawn=\u00a76Lek\u00e9rt\u00e9l\u00a7c {0} \u00a76db \u00a7c {1}-t -itemType=\u00a76T\u00e1rgy\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76T\u00e1rgy\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74A szem\u00e9ly m\u00e1r b\u00f6rt\u00f6nben van\:\u00a7c {0} jailList=\u00a76B\u00f6rt\u00f6n\u00f6k\:\u00a7r {0} jailMessage=\u00a74A b\u0171ncselekm\u00e9nyt megteszed, akkor itt az id\u0151. @@ -257,7 +257,7 @@ lightningUse=\u00a76Vill\u00e1m lesujt\u00e1sa\u00a7c {0}\u00a76-ra/re. listAfkTag=\u00a77[AFK]\u00a7r listAmount=\u00a76Jelenleg \u00a7c{0}\u00a76 j\u00e1t\u00e9kos van fent a maxim\u00e1lis \u00a7c{1}\u00a76 j\u00e1t\u00e9kosb\u00f3l. listAmountHidden=\u00a76Jelenleg \u00a7c{0}\u00a76/{1}\u00a76 j\u00e1t\u00e9kos van fent a maxim\u00e1lis \u00a7c{2}\u00a76 j\u00e1t\u00e9kosb\u00f3l. -listGroupTag={0}\u00a7r\: +listGroupTag={0}\u00a7r\: listHiddenTag=\u00a77[REJTETT]\u00a7r loadWarpError=\u00a74Nem siker\u00fclt a warp bet\u00f6lt\u00e9se {0}. localFormat=[H]<{0}> {1} diff --git a/Essentials/src/messages_it.properties b/Essentials/src/messages_it.properties index 987c04208..692bce867 100644 --- a/Essentials/src/messages_it.properties +++ b/Essentials/src/messages_it.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Non hai oggetti che possono essere convertiti in blocch itemSold=\u00a7aVenduto per \u00a7c{0} \u00a7a({1} {2} a {3} l''uno). itemSoldConsole=\u00a7a{0} \u00a7aha venduto {1} per \u00a7a{2} \u00a7a({3} oggetti a {4} l''uno). itemSpawn=\u00a76Dati\u00a7c {0} \u00a76di\u00a7c {1} -itemType=\u00a76Oggetto\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Oggetto\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Giocatore gi\u00E0 in prigione\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Avrai tempo per riflettere... in prigione. diff --git a/Essentials/src/messages_ko.properties b/Essentials/src/messages_ko.properties index 0c431bed7..ac2a2c4f3 100644 --- a/Essentials/src/messages_ko.properties +++ b/Essentials/src/messages_ko.properties @@ -21,7 +21,7 @@ antiBuildUse=\u00a74\ub2f9\uc2e0\uc740 \u00a7c {0}\u00a74\uc744 \uc0ac\uc6a9\ud5 autoAfkKickReason={0}\ubd84 \uc774\uc0c1\uc758 \uc720\ud734\uc0c1\ud0dc\ub85c \uc788\uc5c8\uae30\uc5d0 \ucd94\ubc29\ub2f9\ud558\uc168\uc2b5\ub2c8\ub2e4. backAfterDeath=\u00a7c/back \u00a76\uba85\ub839\uc5b4\ub85c \uc0ac\ub9dd\ud55c \uc9c0\uc810\uc73c\ub85c \ud154\ub808\ud3ec\ud2b8 \ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4. backupDisabled=\u00a74\uc678\ubd80 \ubc31\uc5c5 \uc2a4\ud06c\ub9bd\ud2b8\uac00 \uc124\uc815\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4. -backupFinished=\u00a76\ubc31\uc5c5\uc774 \uc644\ub8cc\ub418\uc5c8\uc2b5\ub2c8\ub2e4. +backupFinished=\u00a76\ubc31\uc5c5\uc774 \uc644\ub8cc\ub418\uc5c8\uc2b5\ub2c8\ub2e4. backupStarted=\u00a76\ubc31\uc5c5\uc744 \uc2dc\uc791\ud569\ub2c8\ub2e4. backUsageMsg=\u00a76\uc774\uc804 \uc7a5\uc18c\ub85c \ub3cc\uc544\uac00\ub294\uc911.. balance=\u00a76\uc794\uace0\:\u00a7c {0} @@ -37,7 +37,7 @@ bedMissing=\u00a74\ub2f9\uc2e0\uc758 \uce68\ub300\uac00 \ub193\uc5ec\uc9c0\uc9c0 bedNull=\u00a7m\uce68\ub300\u00a7r bedSet=\u00a76\uce68\ub300 \uc2a4\ud3f0\uc9c0\uc810\uc774 \uc124\uc815\ub418\uc5c8\uc2b5\ub2c8\ub2e4\! bigTreeFailure=\u00a7c\ud070 \ub098\ubb34 \uc0dd\uc131\uc911 \uc624\ub958\uac00 \ubc1c\uc0dd\ud558\uc600\uc2b5\ub2c8\ub2e4. \uc794\ub514\ub098 \ud759\uc5d0\uc11c \ub2e4\uc2dc \uc2dc\ub3c4\ud558\uc138\uc694. -bigTreeSuccess=\u00a76\ud070 \ub098\ubb34\ub97c \uc131\uacf5\uc801\uc73c\ub85c \uc0dd\uc131\ud558\uc600\uc2b5\ub2c8\ub2e4. +bigTreeSuccess=\u00a76\ud070 \ub098\ubb34\ub97c \uc131\uacf5\uc801\uc73c\ub85c \uc0dd\uc131\ud558\uc600\uc2b5\ub2c8\ub2e4. blockList=\u00a76\uc5d0\uc13c\uc15c\uc740 \ub2e4\uc74c \ud50c\ub7ec\uadf8\uc778\uc5d0 \uc758\ud574 \ucee4\ub9e8\ub4dc\uac00 \uad50\uccb4\ub429\ub2c8\ub2e4\: bookAuthorSet=\u00a76\ucc45\uc758 \uc800\uc790\ub97c \u00a7c{0}\u00a76\uc73c\ub85c \uc124\uc815\ud569\ub2c8\ub2e4. bookLocked=\u00a76\uc774 \ucc45\uc740 \uc7a0\uae34\uc0c1\ud0dc\ub85c \uc804\ud658\ub418\uc5c8\uc2b5\ub2c8\ub2e4. @@ -72,7 +72,7 @@ connectedPlayers=\u00a76\uc811\uc18d \uc911\uc778 \ud50c\ub808\uc774\uc5b4\u00a7 connectionFailed=\uc5f0\uacb0\uc5d0 \uc2e4\ud328\ud558\uc600\uc2b5\ub2c8\ub2e4. cooldownWithMessage=\u00a7c\uc7ac\uc0ac\uc6a9 \ub300\uae30\: {0} coordsKeyword={0}, {1}, {2} -corruptNodeInConfig=\u00a7c\uc624\ub958\: \u00a74config.yml \ub0b4 {0} \ub178\ub4dc\uc5d0 \uc624\ub958\uac00 \uc788\uc2b5\ub2c8\ub2e4. +corruptNodeInConfig=\u00a7c\uc624\ub958\: \u00a74config.yml \ub0b4 {0} \ub178\ub4dc\uc5d0 \uc624\ub958\uac00 \uc788\uc2b5\ub2c8\ub2e4. couldNotFindTemplate=\ud15c\ud50c\ub9bf {0}\ub97c \ucc3e\uc9c0 \ubabb\ud588\uc2b5\ub2c8\ub2e4. createdKit=\u00a76Created kit \u00a7c{0} \u00a76with \u00a7c{1} \u00a76entries and delay \u00a7c{2} createKitFailed=\u00a74Error occurred whilst creating kit {0}. @@ -89,14 +89,14 @@ defaultBanReason=\ub2f9\uc2e0\uc740 \uad00\ub9ac\uc790\uc5d0 \uc758\ud574 \uc11c deleteFileError={0} \ud30c\uc77c\uc774 \uc0ad\uc81c\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4. deleteHome=\u00a76\uc9d1\u00a7c {0} \uc774 \uc81c\uac70\uac00 \ub418\uc5c8\uc2b5\ub2c8\ub2e4. deleteJail=\u00a77{0} \uac10\uc625\uc774 \uc81c\uac70\ub418\uc5c8\uc2b5\ub2c8\ub2e4. -deleteWarp=\u00a76\uc6cc\ud504 {0}\ub294(\uc740) \uc0ad\uc81c\ub418\uc5c8\uc2b5\ub2c8\ub2e4. +deleteWarp=\u00a76\uc6cc\ud504 {0}\ub294(\uc740) \uc0ad\uc81c\ub418\uc5c8\uc2b5\ub2c8\ub2e4. deniedAccessCommand=\u00a7c{0}\ub2d8\uc740 \ud574\ub2f9 \uba85\ub839\uc5b4\uc5d0 \uc811\uadfc\ud560 \uad8c\ud55c\uc774 \uc5c6\uc2b5\ub2c8\ub2e4. denyBookEdit=\u00a74\ub2f9\uc2e0\uc740 \uc774 \ucc45\uc758 \uc7a0\uae08\uc744 \ud574\uc81c\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. denyChangeAuthor=\u00a74\ub2f9\uc2e0\uc740 \uc774 \ucc45\uc758 \uc800\uc790\ub97c \ubcc0\uacbd\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. denyChangeTitle=\u00a74\ub2f9\uc2e0\uc740 \uc774 \ucc45\uc758 \uc81c\ubaa9\uc744 \ubcc0\uacbd\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. depth=\u00a77\ub2f9\uc2e0\uc740 \ud574\uc218\uba74\uc5d0 \uc788\uc2b5\ub2c8\ub2e4. depthAboveSea=\u00a76\ub2f9\uc2e0\uc740 \ud574\uc218\uba74 {0} \u00a76\ube14\ub85d \uc704\uc5d0 \uc788\uc2b5\ub2c8\ub2e4. -depthBelowSea=\u00a76\ub2f9\uc2e0\uc740 \ud574\uc218\uba74 {0} \u00a76\ube14\ub85d \uc544\ub798\uc5d0 \uc788\uc2b5\ub2c8\ub2e4. +depthBelowSea=\u00a76\ub2f9\uc2e0\uc740 \ud574\uc218\uba74 {0} \u00a76\ube14\ub85d \uc544\ub798\uc5d0 \uc788\uc2b5\ub2c8\ub2e4. destinationNotSet=\ubaa9\uc801\uc9c0\uac00 \uc124\uc815\ub418\uc9c0 \uc54a\uc558\uc2b5\ub2c8\ub2e4. disabled=\ube44\ud65c\uc131\ud654\ub428 disabledToSpawnMob=\u00a74\uc774 \ubaac\uc2a4\ud130\uc758 \uc2a4\ud3f0\uc740 \uc124\uc815 \ud30c\uc77c\uc5d0\uc11c \ud574\uc81c\ub418\uc5c8\uc2b5\ub2c8\ub2e4. @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a77 \u00a7c {0} \u00a77 {{1} \uc640 {2} \uc758 \uc544\uc774\ud15c\uc774 \ud314\ub9ac\ub2e4.) itemSoldConsole={0} \ud310\ub9e4 {1} \uc758 \u00a77 {2} \u00a77 ({3} \uc544\uc774\ud15c\uc758 \ud56d\ubaa9 {4} \uac01\uac01\uc758) itemSpawn=\u00a77\uc544\uc774\ud15c {1}\uc744/\ub97c {0}\uac1c \uc90d\ub2c8\ub2e4. -itemType=\u00a76\uc544\uc774\ud15c\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76\uc544\uc774\ud15c\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\uc0ac\ub78c\uc774 \uc774\ubbf8 \uac10\uc625\uc5d0 \uc788\uc74c\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7c\ub2f9\uc2e0\uc740 \ubc94\uc8c4\ub97c \uc800\uc9c0\ub974\uace0\uc788\uc2b5\ub2c8\ub2e4, \ub2f9\uc2e0\uc740 \uc2dc\uac04\uc774 \ud544\uc694\ud569\ub2c8\ub2e4. @@ -379,7 +379,7 @@ payToggleOn=\u00a76You are now accepting payments. pendingTeleportCancelled=\u00a74\uc21c\uac04\uc774\ub3d9 \uc694\uccad\uc774 \ucde8\uc18c\ub418\uc5c8\uc2b5\ub2c8\ub2e4. playerBanIpAddress=\u00a76Player\u00a7c {0} \u00a76banned IP address\u00a7c {1} \u00a76for\: \u00a7c{2}\u00a76. playerBanned=\u00a76\ud50c\ub808\uc774\uc5b4\u00a7c {0} \u00a76\ub2d8\uc774\u00a7c {1} \u00a76\ub2d8\uc744 \ubca4\ud558\uc600\uc2b5\ub2c8\ub2e4. \uc0ac\uc720\: \u00a7c{2}\u00a76. -playerInJail=\u00a74\uadf8 \ud50c\ub808\uc774\uc5b4\ub294 \uc774\ubbf8 {0}\u00a74 \uac10\uc625\uc5d0 \uc218\uac10\ub418\uc5b4\uc788\uc2b5\ub2c8\ub2e4. +playerInJail=\u00a74\uadf8 \ud50c\ub808\uc774\uc5b4\ub294 \uc774\ubbf8 {0}\u00a74 \uac10\uc625\uc5d0 \uc218\uac10\ub418\uc5b4\uc788\uc2b5\ub2c8\ub2e4. playerJailed=\u00a76{0} \ud50c\ub808\uc774\uc5b4\uac00 \uac10\uae08\ub418\uc5c8\uc2b5\ub2c8\ub2e4. playerJailedFor=\u00a76\ud50c\ub808\uc774\uc5b4 {0}\uc740 {1}\uc5d0 \uac10\uae08\ub418\uc5c8\uc2b5\ub2c8\ub2e4. playerKicked=\u00a76Player\u00a7c {0} \u00a76kicked {1} for {2}. @@ -498,7 +498,7 @@ survival=\uc11c\ubc14\uc774\ubc8c takenFromAccount=\u00a7c{0} \ub9cc\ud07c \uc9c0\ubd88\ud558\uc600\uc2b5\ub2c8\ub2e4. takenFromOthersAccount=\u00a7a{1}\u00a7a\uc758 \uacc4\uc815\uc5d0\uc11c {0}\u00a7a\uc744 \uac00\uc838\uc640 \uc794\uace0\uac00 {2}\u00a7a\uc774 \ub418\uc5c8\uc2b5\ub2c8\ub2e4. teleportAAll=\u00a76\ubaa8\ub4e0 \ud50c\ub808\uc774\uc5b4\uc5d0\uac8c \ud154\ub808\ud3ec\ud2b8 \uc694\uccad\uc744 \ubcf4\ub0c8\uc2b5\ub2c8\ub2e4... -teleportAll=\u00a76\ubaa8\ub4e0 \ud50c\ub808\uc774\uc5b4\ub97c \ud154\ub808\ud3ec\ud2b8 \ud558\ub294\uc911.. +teleportAll=\u00a76\ubaa8\ub4e0 \ud50c\ub808\uc774\uc5b4\ub97c \ud154\ub808\ud3ec\ud2b8 \ud558\ub294\uc911.. teleportationCommencing=\u00a76\ud154\ub808\ud3ec\ud2b8 \uc911... teleportationDisabled=\u00a76\ud154\ub808\ud3ec\ud2b8\uac00 \u00a7c\ube44\ud65c\uc131\ud654\u00a76\ub418\uc5c8\uc2b5\ub2c8\ub2e4. teleportationDisabledFor=\u00a7c{0}\u00a76 \uc5d0 \ub300\ud55c \uc774\ub3d9\uc774 \uc81c\ud55c\ub418\uc5c8\uc2b5\ub2c8\ub2e4. @@ -554,7 +554,7 @@ unlimitedItems=\ubb34\uc81c\ud55c \uc544\uc774\ud15c \ubaa9\ub85d\: unmutedPlayer=\ud50c\ub808\uc774\uc5b4 \u00a7c{0}\u00a76\ub294 \uc774\uc81c \ub9d0\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4. unsafeTeleportDestination=\u00a74\ud154\ub808\ud3ec\ud2b8 \ub300\uc0c1\uc774 \uc548\uc804\ud558\uace0 \ud154\ub808\ud3ec\ud2b8\uac00 \uc548\uc804 \ube44\ud65c\uc131\ud654 \ub429\ub2c8\ub2e4. unvanishedReload=\u00a74A reload has forced you to become visible. -upgradingFilesError=\ud30c\uc77c\uc744 \uc5c5\uadf8\ub808\uc774\ub4dc \ud558\ub358 \ub3c4\uc911, \uc624\ub958\uac00 \ubc1c\uc0dd\ud558\uc600\uc2b5\ub2c8\ub2e4. +upgradingFilesError=\ud30c\uc77c\uc744 \uc5c5\uadf8\ub808\uc774\ub4dc \ud558\ub358 \ub3c4\uc911, \uc624\ub958\uac00 \ubc1c\uc0dd\ud558\uc600\uc2b5\ub2c8\ub2e4. uptime=\u00a76\uac00\ub3d9 \uc2dc\uac04\:\u00a7c {0} userAFK=\u00a77{0} \u00a75\uc740 \ud604\uc7ac \uc7a0\uc218 \uc0c1\ud0dc\uc774\ubbc0\ub85c \uc751\ub2f5\ud558\uc9c0 \uc54a\uc744 \uc218 \uc788\uc2b5\ub2c8\ub2e4. userAFKWithMessage=\u00a77{0} \u00a75\uc740 \ud604\uc7ac \uc7a0\uc218 \uc0c1\ud0dc\uc774\ubbc0\ub85c \uc751\ub2f5\ud558\uc9c0 \uc54a\uc744 \uc218 \uc788\uc2b5\ub2c8\ub2e4. {1} @@ -570,7 +570,7 @@ usingTempFolderForTesting=\ud14c\uc2a4\ud2b8\ub97c \uc704\ud574 temp \ud3f4\ub35 vanish=\u00a76{0}\u00a76\ub2d8\uc758 \uc0ac\ub77c\uc9c0\uae30\uac00 {1}. vanished=\u00a76\ub2f9\uc2e0\uc740 \uc774\uc81c \uc77c\ubc18 \ud50c\ub808\uc774\uc5b4\uc5d0\uac8c \ubcf4\uc774\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4, \uadf8\ub9ac\uace0 \uac8c\uc784 \ub0b4 \uba85\ub839\uc5b4\ub85c\ubd80\ud130 \uc228\uaca8\uc9d1\ub2c8\ub2e4. versionMismatch=\u00a74\ubc84\uc804 \ubd88\uc77c\uce58\! {0}\uc744 \ub3d9\uc77c\ud55c \ubc84\uc804\uc73c\ub85c \uc5c5\ub370\uc774\ud2b8 \ud574 \uc8fc\uc138\uc694 -versionMismatchAll=\ubc84\uc804\uc774 \ubd88\uc77c\uce58\ud569\ub2c8\ub2e4\! \ubaa8\ub4e0 Essentials jar \ud30c\uc77c\ub4e4\uc758 \ubc84\uc804\uc744 \uac19\uc740 \ubc84\uc804\uc73c\ub85c \uc5c5\ub370\uc774\ud2b8 \ud574 \uc8fc\uc138\uc694. +versionMismatchAll=\ubc84\uc804\uc774 \ubd88\uc77c\uce58\ud569\ub2c8\ub2e4\! \ubaa8\ub4e0 Essentials jar \ud30c\uc77c\ub4e4\uc758 \ubc84\uc804\uc744 \uac19\uc740 \ubc84\uc804\uc73c\ub85c \uc5c5\ub370\uc774\ud2b8 \ud574 \uc8fc\uc138\uc694. voiceSilenced=\u00a76\ub2f9\uc2e0\uc758 \ubaa9\uc18c\ub9ac\uac00 \uce68\ubb35\ub418\uc5c8\uc2b5\ub2c8\ub2e4 walking=\uac77\uae30 warpDeleteError=\u00a74\uc6cc\ud504 \ud30c\uc77c \uc0ad\uc81c\uc911 \ubb38\uc81c\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4. diff --git a/Essentials/src/messages_lt.properties b/Essentials/src/messages_lt.properties index efe4ff42e..b82271ded 100644 --- a/Essentials/src/messages_lt.properties +++ b/Essentials/src/messages_lt.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aParduota po \u00a7c{0} \u00a7a({1} {2} uz {3} kiekviena). itemSoldConsole=\u00a7a{0} \u00a7asold {1} for \u00a7a{2} \u00a7a({3} items at {4} each). itemSpawn=\u00a76Giving\u00a7c {0} \u00a76of\u00a7c {1} -itemType=\u00a76Item\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Item\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\u017daid\u0117jas jau yra kal\u0117jime\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Padarei nusikaltim\u0105, laikas atpirkti nuod\u0117mes. diff --git a/Essentials/src/messages_nl.properties b/Essentials/src/messages_nl.properties index f5be39cf4..c0190055c 100644 --- a/Essentials/src/messages_nl.properties +++ b/Essentials/src/messages_nl.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Houd alstublieft een schedel vast. invalidWarpName=\u00a74Ongeldige warp naam. invalidWorld=\u00a7cOngeldige wereld. inventoryClearFail=\u00a74Player {0} \u00a74heeft geen\u00a7c {1} \u00a74stuks\u00a7c {2}\u00a74. -inventoryClearingAllArmor=\u00a76Alle inventaris voorwerpen en het harnas van {0}\u00a76 zijn verwijderd. +inventoryClearingAllArmor=\u00a76Alle inventaris voorwerpen en het harnas van {0}\u00a76 zijn verwijderd. inventoryClearingAllItems=\u00a76Alle inventaris voorwerpen van {0}\u00a76 zijn verwijderd. inventoryClearingAllStack=\u00a76Alle\u00a7c {0} \u00a76van {1}\u00a76 is verwijderd. inventoryClearingFromAll=\u00a76Inventarissen van alle gebruikers leegmaken.... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a77Verkocht voor \u00a7c{0} \u00a77({1} {2} voorwerpen voor {3} per stuk) itemSoldConsole={0} verkocht {1} voor \u00a77{2} \u00a77({3} voorwerpen voor {4} per stuk) itemSpawn=\u00a77Geeft {0} {1} -itemType=\u00a76Voorwerp\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Voorwerp\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Deze persoon zit al in de gevangenis\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74U begaat een misdrijf, U zit uw tijd uit. @@ -457,7 +457,7 @@ requiredBukkit=\u00a76* \! * U heeft op zijn minst build {0} van CraftBukkit nod resetBal=\u00a76Balans is gereset naar \u00a7c{0} \u00a76voor alle online spelers. resetBalAll=\u00a76Saldo is gereset naar \u00a7c{0} \u00a76voor alle spelers. returnPlayerToJailError=\u00a74Een error is verschenen tijdens het proberen om het terugsturen van speler\u00a7c {0} \u00a74naar gevangenis\: \u00a7c{1}\u00a74\! -runningPlayerMatch=\u00a76Zoeken naar spelers die ''\u00a7c{0}\u00a76'' matchen (Dit kan even duren) +runningPlayerMatch=\u00a76Zoeken naar spelers die ''\u00a7c{0}\u00a76'' matchen (Dit kan even duren) second=seconde seconds=seconden seenAccounts=\u00a76Speler is ook bekend als\:\u00a7c {0} @@ -468,7 +468,7 @@ sellHandPermission=\u00a76You do not have permission to hand sell. serverFull=Server is vol. serverTotal=\u00a76Server Totaal\:\u00a7c {0} setBal=\u00a7aUw saldo is ingesteld op {0}. -setBalOthers=\u00a7aU heeft het saldo van {0} \u00a7aingesteld op {1}. +setBalOthers=\u00a7aU heeft het saldo van {0} \u00a7aingesteld op {1}. setSpawner=\u00a76Veranderde oproeper type naar\u00a7c {0}\u00a76. sheepMalformedColor=\u00a74Misvormde kleur. shoutFormat=\u00a76[Schreeuw]\u00a7r {0} diff --git a/Essentials/src/messages_pl.properties b/Essentials/src/messages_pl.properties index e83ba3b2c..d478a7bee 100644 --- a/Essentials/src/messages_pl.properties +++ b/Essentials/src/messages_pl.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74Nie znaleziono przedmiot\u00F3w kt\u00F3re mo\u017Cna z itemSold=\u00a7aSprzedano za \u00a7c{0} \u00a7a({1} {2} po {3} ka\u017Cdy) itemSoldConsole=\u00a7a{0} \u00a7aSprzedano {1} za \u00a7a{2} \u00a7a({3} sztuki po {4} kazda) itemSpawn=\u00a77Otrzymano\u00a7c {0} \u00a77z\u00a7c {1} -itemType=\u00a77Przedmiot\:\u00a7c {0} \u00a77-\u00a7c {1} +itemType=\u00a77Przedmiot\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Ten gracz jest ju\u017C w wi\u0119zieniu \u00a7c{0} \u00a74. jailList=\u00a76Wi\u0119zienia\:\u00a7r {0} jailMessage=\u00a74Za ka\u017Cde przewinienie czeka Ci\u0119 kara. diff --git a/Essentials/src/messages_pt.properties b/Essentials/src/messages_pt.properties index 22363ff5a..4fdf21cd1 100644 --- a/Essentials/src/messages_pt.properties +++ b/Essentials/src/messages_pt.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00A74N\u00E3o tens itens que possam ser transformado em bloc itemSold=\u00A7aVendido por \u00A7c{0} \u00A7a({1} {2} a {3} cada). itemSoldConsole=\u00A7a{0} \u00A7avendeu {1} por \u00A7a{2} \u00A7a({3} itens a {4} cada). itemSpawn=\u00A76A dar\u00A7c {0}\u00A7c {1} -itemType=\u00A76Itens:\u00A7c {0} \u00A76-\u00A7c {1} +itemType=\u00A76Itens:\u00A7c {0} jailAlreadyIncarcerated=\u00A74Esse jogador j\u00E1 est\u00E1 na pris\u00E3o:\u00A7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00A74Foste condenado. Pensa bem antes de voltares a fazer o que fizeste. diff --git a/Essentials/src/messages_pt_BR.properties b/Essentials/src/messages_pt_BR.properties index 3b792c066..737e0f972 100644 --- a/Essentials/src/messages_pt_BR.properties +++ b/Essentials/src/messages_pt_BR.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00A74Voc\u00EA n\u00E3o tem itens que possam virar blocos. itemSold=\u00A7aVendido por \u00A7c{0} \u00A7a({1} {2} a {3} cada). itemSoldConsole=\u00A7a{0} \u00A7avendeu {1} por \u00A7a{2} \u00A7a({3} itens a {4} cada). itemSpawn=\u00A76Dando\u00A7c {0}\u00A7c {1} -itemType=\u00A76Item\:\u00A7c {0} \u00A76-\u00A7c {1} +itemType=\u00A76Item\:\u00A7c {0} jailAlreadyIncarcerated=\u00A74Essa pessoa j\u00E1 est\u00E1 na cadeia\:\u00A7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00A74Voc\u00EA foi condenado. Pense bem antes de fazer o que fez. diff --git a/Essentials/src/messages_ro.properties b/Essentials/src/messages_ro.properties index 74ca61aac..6d97598c2 100644 --- a/Essentials/src/messages_ro.properties +++ b/Essentials/src/messages_ro.properties @@ -202,7 +202,7 @@ invalidSkull=\u00a74Te rog tine un craniu al unui player. invalidWarpName=\u00a74Numele teleportarei este invalida\! invalidWorld=\u00a74Lume invalida. inventoryClearFail=\u00a74Jucatorul {0} \u00a74nu are\u00a7c {1} \u00a74de\u00a7c {2} \u00a74. -inventoryClearingAllArmor=\u00a76Se curata tot inventarul lui {0} \u00a76. +inventoryClearingAllArmor=\u00a76Se curata tot inventarul lui {0} \u00a76. inventoryClearingAllItems=\u00a76Se curata inventarul lui {0} \u00a76. inventoryClearingAllStack=\u00a76Se curata\u00a7c {0} \u00a76ale lui {1} \u00a76. inventoryClearingFromAll=\u00a76Se curata inventarul tuturor jucatorilor... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aVandut pentru \u00a7c{0} \u00a7a({1} {2} la {3} fiecare). itemSoldConsole=\u00a7a{0} \u00a7aa vandut {1} pentru \u00a7a{2} \u00a7a({3} obiecte la {4} fiecare). itemSpawn=\u00a76Ai primit\u00a7c {0} \u00a76bucata(ti) de\u00a7c {1} -itemType=\u00a76Obiect\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Obiect\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Acest jucator este deja in inchisoare\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Incalci reguli, trebuie sa platesti. diff --git a/Essentials/src/messages_ru.properties b/Essentials/src/messages_ru.properties index 42cb77fca..39a8d99f1 100644 --- a/Essentials/src/messages_ru.properties +++ b/Essentials/src/messages_ru.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7a\u041f\u0440\u043e\u0434\u0430\u043d\u043e \u0437\u0430 \u00a7c{0} \u00a7a({1} {2} \u043f\u043e {3} \u043a\u0430\u0436\u0434\u044b\u0439). itemSoldConsole=\u00a7a{0} \u00a7a\u043f\u0440\u043e\u0434\u0430\u043b {1} \u0437\u0430 \u00a7a{2} \u00a7a({3} \u043f\u0440\u0435\u0434\u043c\u0435\u0442\u043e\u0432 \u0437\u0430 {4} \u043a\u0430\u0436\u0434\u044b\u0439). itemSpawn=\u00a76\u0412\u044b\u0434\u0430\u043d\u043e\u00a7c {0} \u00a76\u0448\u0442\u0443\u043a\u00a7c {1} -itemType=\u00a76\u041f\u0440\u0435\u0434\u043c\u0435\u0442\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76\u041f\u0440\u0435\u0434\u043c\u0435\u0442\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\u0438\u0433\u0440\u043e\u043a \u0443\u0436\u0435 \u0432 \u0442\u044e\u0440\u044c\u043c\u0435\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74\u0412\u044b \u043f\u043e\u043f\u0430\u043b\u0438 \u0432 \u0442\u044e\u0440\u044c\u043c\u0443. \u041f\u0440\u0438\u044f\u0442\u043d\u043e\u0433\u043e \u043e\u0442\u0434\u044b\u0445\u0430\! diff --git a/Essentials/src/messages_sv.properties b/Essentials/src/messages_sv.properties index 19a2fdad1..3414f9fe1 100644 --- a/Essentials/src/messages_sv.properties +++ b/Essentials/src/messages_sv.properties @@ -109,7 +109,7 @@ durability=\u00a77Det h\u00e4r verktyget har \u00a7c{0}\u00a77 anv\u00e4ndningar east=E editBookContents=\u00a7eDu kan nu \u00e4ndra inneh\u00e5llet i denna bok. enabled=aktiverad -enableUnlimited=Ger o\u00e4ndligt med pengar till +enableUnlimited=Ger o\u00e4ndligt med pengar till enchantmentApplied=\u00a77F\u00f6rtrollningen {0} har blivit till\u00e4mpad p\u00e5 saken du har i handen. enchantmentNotFound=\u00a7cF\u00f6rtrollningen hittades inte enchantmentPerm=\u00a7cDu har inte beh\u00f6righet att {0} @@ -202,7 +202,7 @@ invalidSkull=\u00a74Sn\u00e4lla h\u00e5ll i ett spelar Huvud. invalidWarpName=\u00a74Ogiltigt warpnamn invalidWorld=\u00a7cOgiltig v\u00e4rld. inventoryClearFail=\u00a74Spelaren {0} \u00a74har inte \u00a7c {1} \u00a74av\u00a7c {2}\u00a74. -inventoryClearingAllArmor=\u00a76Rensade alla inventory objekt och rustning fr\u00e5n {0}\u00a76. +inventoryClearingAllArmor=\u00a76Rensade alla inventory objekt och rustning fr\u00e5n {0}\u00a76. inventoryClearingAllItems=\u00a76Rensade alla inventory saker fr\u00e5n {0}\u00a76. inventoryClearingAllStack=\u00a76Rensade alla\u00a7c {0} \u00a76fr\u00e5n {1}\u00a76. inventoryClearingFromAll=\u00a76Rensar inventoriet f\u00f6r alla spelare... @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a77S\u00e5lde f\u00f6r \u00a7c{0} \u00a77({1} {2} f\u00f6r {3} styck) itemSoldConsole={0} s\u00e5lde {1} f\u00f6r \u00a77{2} \u00a77({3} saker f\u00f6r {4} styck) itemSpawn=\u00a77Ger {0} stycken {1} -itemType=Objekt\: {0} - {1} +itemType=Objekt\: {0} jailAlreadyIncarcerated=\u00a7cPersonen \u00e4r redan i f\u00e4ngelse\: {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a7cBryter du mot reglerna, f\u00e5r du st\u00e5 ditt kast. diff --git a/Essentials/src/messages_tr.properties b/Essentials/src/messages_tr.properties index dc155628f..538ea916b 100644 --- a/Essentials/src/messages_tr.properties +++ b/Essentials/src/messages_tr.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7aSatilan Esya \u00a7c{0} \u00a7a({1} {2} , {3}). itemSoldConsole=\u00a7a{0} \u00a7aSatildi {1} , \u00a7a{2} \u00a7a({3} , {4}). itemSpawn=\u00a76Verilmekte\u00a7c {0} \u00a76-\u00a7c {1} -itemType=\u00a76Esya ve Araclar\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76Esya ve Araclar\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74Bu Oyuncu Zaten Hapse Mahkum\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74Cezalandirildin Lutfen Kurallara Dikkat Et\! @@ -257,7 +257,7 @@ lightningUse=\u00a76Bu Kisi Simsek Atiyor\u00a7c {0} listAfkTag=\u00a77[UzaktaAFK]\u00a7r listAmount=\u00a76Oyuncu Kapasitesi \u00a7c{0}\u00a76 Acik Olan \u00a7c{1}\u00a76. listAmountHidden=\u00a76Suan \u00a7c{0}\u00a76/{1}\u00a76 Sunucudaki \u00a7c{2}\u00a76 oyuncu cevrimici. -listGroupTag={0}\u00a7f\: +listGroupTag={0}\u00a7f\: listHiddenTag=\u00a77[Gizlenmis]\u00a7r loadWarpError=\u00a74Is\u0131nlanma Noktasi Yuklenemedi {0}. localFormat=[L]<{0}> {1} diff --git a/Essentials/src/messages_vi.properties b/Essentials/src/messages_vi.properties index 98de276d2..80d1af6f7 100644 --- a/Essentials/src/messages_vi.properties +++ b/Essentials/src/messages_vi.properties @@ -198,7 +198,7 @@ itemSellAir=\u0042\u1ea1\u006e \u0111\u0061\u006e\u0067 \u0063\u1ed1 \u0067\u1ea itemSold=\u00a7a\u0110\u00e3 \u0062\u00e1\u006e \u0111\u01b0\u1ee3\u0063 \u00a7c{0} \u00a7a({1} {2} \u0076\u1edb\u0069 {3} \u006d\u1ed7\u0069 \u0063\u00e1\u0069). itemSoldConsole=\u00a7a{0} \u00a7a\u0111\u00e3 \u0062\u00e1\u006e {1} \u0076\u00e0 \u006e\u0068\u1ead\u006e \u0111\u01b0\u1ee3\u0063 \u00a7a{2} \u00a7a({3} \u0076\u1ead\u0074 \u0070\u0068\u1ea9\u006d \u0076\u1edb\u0069 {4} \u006d\u1ed7\u0069 \u0063\u00e1\u0069). itemSpawn=\u00a76\u0043\u0068\u006f\u00a7c {0} \u00a76\u0063\u00e1\u0069\u00a7c {1} -itemType=\u00a76\u0056\u1ead\u0074 \u0070\u0068\u1ea9\u006d\:\u00a7c {0} \u00a76-\u00a7c {1} +itemType=\u00a76\u0056\u1ead\u0074 \u0070\u0068\u1ea9\u006d\:\u00a7c {0} itemsCsvNotLoaded=\u004b\u0068\u00f4\u006e\u0067 \u0074\u0068\u1ec3 \u0074\u1ea3\u0069 \u0074\u1ec7\u0070 items.csv\! jailAlreadyIncarcerated=\u00a74\u004e\u0067\u01b0\u1edd\u0069 \u006e\u00e0\u0079 \u0111\u00e3 \u0062\u1ecb \u0067\u0069\u0061\u006d\:\u00a7c {0} jailList=\u00a76Jails\:\u00a7r {0} diff --git a/Essentials/src/messages_zh.properties b/Essentials/src/messages_zh.properties index 4a97ccb8d..69ffcbac9 100644 --- a/Essentials/src/messages_zh.properties +++ b/Essentials/src/messages_zh.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74\u4f60\u6ca1\u6709\u8db3\u591f\u7684\u7269\u54c1\u6765\ itemSold=\u00a7a\u83b7\u5f97 \u00a7c {0} \u00a7a \uff08{1} \u5355\u4f4d{2},\u6bcf\u4e2a\u4ef7\u503c {3}\uff09 itemSoldConsole=\u00a7c{0} \u00a76\u5356\u51fa\u4e86 {1},\u83b7\u5f97\u4e86\u00a76 {2} \u00a76 \uff08{3} \u5355\u4f4d\u7269\u54c1,\u6bcf\u4e2a\u4ef7\u503c {4}\uff09 itemSpawn=\u00a76\u751f\u6210 {0} \u4e2a {1} -itemType=\u00a76\u7269\u54c1\:\u00a7c {0} \u00a76-\u00a74 {1} +itemType=\u00a76\u7269\u54c1\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\u5df2\u5728\u76d1\u72f1\u4e2d\u7684\u73a9\u5bb6\:{0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74\u8bf7\u5728\u76d1\u72f1\u4e2d\u9762\u58c1\u601d\u8fc7\uff01 diff --git a/Essentials/src/messages_zh_HK.properties b/Essentials/src/messages_zh_HK.properties index e552d616b..124dd2a54 100644 --- a/Essentials/src/messages_zh_HK.properties +++ b/Essentials/src/messages_zh_HK.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7a\u7372\u5f97 \u00a7c {0} \u00a7a \uff08{1} \u55ae\u4f4d{2},\u6bcf\u500b\u50f9\u503c {3}\uff09 itemSoldConsole=\u00a7c{0} \u00a76\u8ce3\u51fa\u4e86 {1},\u7372\u5f97\u4e86\u00a76 {2} \u00a76 \uff08{3} \u55ae\u4f4d\u7269\u54c1,\u6bcf\u500b\u50f9\u503c {4}\uff09 itemSpawn=\u00a76\u751f\u6210 {0} \u500b {1} -itemType=\u00a76\u7269\u54c1\:\u00a7c {0} \u00a76-\u00a74 {1} +itemType=\u00a76\u7269\u54c1\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\u5df2\u5728\u76e3\u7344\u4e2d\u7684\u73a9\u5bb6\:{0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74\u8acb\u5728\u76e3\u7344\u4e2d\u9762\u58c1\u601d\u904e\uff01 diff --git a/Essentials/src/messages_zh_TW.properties b/Essentials/src/messages_zh_TW.properties index 4457b482b..4b792c866 100644 --- a/Essentials/src/messages_zh_TW.properties +++ b/Essentials/src/messages_zh_TW.properties @@ -223,7 +223,7 @@ itemsNotConverted=\u00a74You have no items that can be converted into blocks. itemSold=\u00a7a\u7372\u5f97 \u00a7c {0} \u00a7a \uff08{1} \u55ae\u4f4d{2},\u6bcf\u500b\u50f9\u503c {3}\uff09 itemSoldConsole=\u00a7c{0} \u00a76\u8ce3\u51fa\u4e86 {1},\u7372\u5f97\u4e86\u00a76 {2} \u00a76 \uff08{3} \u55ae\u4f4d\u7269\u54c1,\u6bcf\u500b\u50f9\u503c {4}\uff09 itemSpawn=\u00a76\u751f\u6210 {0} \u500b {1} -itemType=\u00a76\u7269\u54c1\:\u00a7c {0} \u00a76-\u00a74 {1} +itemType=\u00a76\u7269\u54c1\:\u00a7c {0} jailAlreadyIncarcerated=\u00a74\u5df2\u5728\u76e3\u7344\u4e2d\u7684\u73a9\u5bb6\:{0} jailList=\u00a76Jails\:\u00a7r {0} jailMessage=\u00a74\u8acb\u5728\u76e3\u7344\u4e2d\u9762\u58c1\u601d\u904e\uff01 From 85111f25cb69d7e5f1df42bc2bd7c186d90770b6 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 16:09:45 +0100 Subject: [PATCH 53/62] Use ItemData#equals when finding item name Avoids accidentally causing an NPE while comparing potion data. --- Essentials/src/com/earth2me/essentials/ItemDb.java | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 30845f092..616ef4ca5 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -194,8 +194,10 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { potion = ((PotionMeta) item.getItemMeta()).getBasePotionData(); } + ItemData data = new ItemData(type, potion); + for (Map.Entry entry : items.entrySet()) { - if (entry.getValue().getMaterial().equals(type) && entry.getValue().getPotionData().equals(potion)) { + if (entry.getValue().equals(data)) { return entry.getKey(); } } @@ -399,6 +401,11 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { private Material material; private PotionData potionData; + public ItemData(Material material, PotionData potionData) { + this.material = material; + this.potionData = potionData; + } + @Override public int hashCode() { return (31 * material.hashCode()) ^ potionData.hashCode(); @@ -412,8 +419,8 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { if (!(o instanceof ItemData)) { return false; } - ItemData pairo = (ItemData) o; - return this.material == pairo.getMaterial() && potionDataEquals(pairo); + ItemData that = (ItemData) o; + return this.material == that.getMaterial() && potionDataEquals(that); } public String getItemName() { From 1e381a59be1d81fa75bddab5c1159f2cb5b8e589 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 16:32:21 +0100 Subject: [PATCH 54/62] Throw meaningful exception when item not found --- Essentials/src/com/earth2me/essentials/ItemDb.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index 616ef4ca5..d2d52abb2 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -101,7 +101,12 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { @Override public ItemStack get(final String id) throws Exception { - ItemData data = Objects.requireNonNull(getByName(id)); + ItemData data = getByName(id); + + if (data == null) { + throw new Exception(tl("unknownItemName", id)); + } + PotionData potionData = data.getPotionData(); Material material = data.getMaterial(); From 5c7fc763fcd71c1a5f1ac584ec8640539fcbe732 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 16:44:24 +0100 Subject: [PATCH 55/62] Formatting --- Essentials/src/com/earth2me/essentials/ItemDb.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index d2d52abb2..efcc3831a 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -26,7 +26,9 @@ import static com.earth2me.essentials.I18n.tl; public class ItemDb implements IConf, net.ess3.api.IItemDb { protected static final Logger LOGGER = Logger.getLogger("Essentials"); - private final transient IEssentials ess;private static Gson gson = new Gson(); + private final transient IEssentials ess; + + private static Gson gson = new Gson(); // Maps primary name to ItemData private final transient Map items = new HashMap<>(); From 4cd8a6636bf361142d9520ae688eba0460dbf00c Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 16:44:50 +0100 Subject: [PATCH 56/62] Log invalid JSON entries --- Essentials/src/com/earth2me/essentials/ItemDb.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ItemDb.java b/Essentials/src/com/earth2me/essentials/ItemDb.java index efcc3831a..674bf4b6d 100644 --- a/Essentials/src/com/earth2me/essentials/ItemDb.java +++ b/Essentials/src/com/earth2me/essentials/ItemDb.java @@ -83,13 +83,13 @@ public class ItemDb implements IConf, net.ess3.api.IItemDb { String target = element.getAsString(); itemAliases.put(key, target); valid = true; - } catch (Exception e) { - // TODO: log invalid entry - } + } catch (Exception ignored) {} } if (valid) { allAliases.add(key); + } else { + LOGGER.warning(String.format("Failed to add item: \"%s\": %s", key, element.toString())); } } } From 0e088c17a8e265a522127599cea98c8c278c9756 Mon Sep 17 00:00:00 2001 From: md678685 Date: Sat, 13 Oct 2018 16:45:20 +0100 Subject: [PATCH 57/62] Remove IdProvider dependency --- Essentials/pom.xml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/Essentials/pom.xml b/Essentials/pom.xml index bd44cb37f..8483f9af2 100644 --- a/Essentials/pom.xml +++ b/Essentials/pom.xml @@ -106,12 +106,6 @@ - - net.ess3 - IdProvider - 2.15.0 - compile - net.ess3 FlattenedProvider From 60c90408e7f3867daae211e70fb8ab8c8ef3e091 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 15 Oct 2018 13:16:10 +0100 Subject: [PATCH 58/62] Remove ID-based permission checks in /give and /item --- .../src/com/earth2me/essentials/commands/Commandgive.java | 3 +-- .../src/com/earth2me/essentials/commands/Commanditem.java | 4 +--- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandgive.java b/Essentials/src/com/earth2me/essentials/commands/Commandgive.java index 0dfda9505..869681f1e 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandgive.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandgive.java @@ -31,10 +31,9 @@ public class Commandgive extends EssentialsCommand { } ItemStack stack = ess.getItemDb().get(args[1]); - int itemId = ess.getItemDb().getLegacyId(stack.getType()); final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", ""); - if (sender.isPlayer() && (ess.getSettings().permissionBasedItemSpawn() ? (!ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.item-all") && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.item-" + itemname) && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.item-" + itemId)) : (!ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.exempt") && !ess.getUser(sender.getPlayer()).canSpawnItem(stack.getType())))) { + if (sender.isPlayer() && (ess.getSettings().permissionBasedItemSpawn() ? (!ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.item-all") && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.item-" + itemname)) : (!ess.getUser(sender.getPlayer()).isAuthorized("essentials.itemspawn.exempt") && !ess.getUser(sender.getPlayer()).canSpawnItem(stack.getType())))) { throw new Exception(tl("cantSpawnItem", itemname)); } diff --git a/Essentials/src/com/earth2me/essentials/commands/Commanditem.java b/Essentials/src/com/earth2me/essentials/commands/Commanditem.java index 8e054a84b..fd86fe0eb 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commanditem.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commanditem.java @@ -27,11 +27,9 @@ public class Commanditem extends EssentialsCommand { } ItemStack stack = ess.getItemDb().get(args[0]); - int itemId = ess.getItemDb().getLegacyId(stack.getType()); - final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", ""); - if (ess.getSettings().permissionBasedItemSpawn() ? (!user.isAuthorized("essentials.itemspawn.item-all") && !user.isAuthorized("essentials.itemspawn.item-" + itemname) && !user.isAuthorized("essentials.itemspawn.item-" + itemId)) : (!user.isAuthorized("essentials.itemspawn.exempt") && !user.canSpawnItem(stack.getType()))) { + if (ess.getSettings().permissionBasedItemSpawn() ? (!user.isAuthorized("essentials.itemspawn.item-all") && !user.isAuthorized("essentials.itemspawn.item-" + itemname)) : (!user.isAuthorized("essentials.itemspawn.exempt") && !user.canSpawnItem(stack.getType()))) { throw new Exception(tl("cantSpawnItem", itemname)); } try { From 79bc34047b86461e752491d08ee8a38a5c07d9dd Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 15 Oct 2018 13:46:12 +0100 Subject: [PATCH 59/62] Allow multiple item names in /clearinventory Allow a comma-separated list of item names in /clearinventory. --- .../commands/Commandclearinventory.java | 68 ++++++++----------- 1 file changed, 29 insertions(+), 39 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java b/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java index da1354d22..0dfea92e6 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandclearinventory.java @@ -14,11 +14,7 @@ import org.bukkit.Server; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Locale; +import java.util.*; public class Commandclearinventory extends EssentialsCommand { @@ -89,7 +85,7 @@ public class Commandclearinventory extends EssentialsCommand { short data = -1; int type = -1; int amount = -1; - Material mat = null; + final Set mats = new HashSet<>(); if (args.length > (offset + 1) && NumberUtil.isInt(args[(offset + 1)])) { amount = Integer.parseInt(args[(offset + 1)]); @@ -98,16 +94,15 @@ public class Commandclearinventory extends EssentialsCommand { if (args[offset].equalsIgnoreCase("**")) { type = -2; } else if (!args[offset].equalsIgnoreCase("*")) { - final String[] split = args[offset].split(":"); - final ItemStack item = ess.getItemDb().get(split[0]); - type = ess.getItemDb().getLegacyId(item.getType()); - mat = item.getType(); + final String[] split = args[offset].split(","); - if (split.length > 1 && NumberUtil.isInt(split[1])) { - data = Short.parseShort(split[1]); - } else { - data = item.getDurability(); + for (String name : split) { + try { + mats.add(ess.getItemDb().get(name).getType()); + } catch (Exception ignored) {} } + + type = 1; } } @@ -127,32 +122,27 @@ public class Commandclearinventory extends EssentialsCommand { InventoryWorkaround.setItemInOffHand(player, null); player.getInventory().setArmorContents(null); } else { - if (data == -1) // data -1 means that all subtypes will be cleared - { - ItemStack stack = new ItemStack(mat); - if (showExtended) { - sender.sendMessage(tl("inventoryClearingAllStack", stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName())); - } - player.getInventory().remove(mat); - } else if (amount == -1) // amount -1 means all items will be cleared - { - ItemStack stack = new ItemStack(mat, BASE_AMOUNT, data); - ItemStack removedStack = player.getInventory().removeItem(stack).get(0); - final int removedAmount = (BASE_AMOUNT - removedStack.getAmount()); - if (removedAmount > 0 || showExtended) { - sender.sendMessage(tl("inventoryClearingStack", removedAmount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName())); - } - } else { - if (amount < 0) { - amount = 1; - } - ItemStack stack = new ItemStack(mat, amount, data); - if (player.getInventory().containsAtLeast(stack, amount)) { - sender.sendMessage(tl("inventoryClearingStack", amount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName())); - player.getInventory().removeItem(stack); + for (Material mat : mats) { + if (amount == -1) // amount -1 means all items will be cleared + { + ItemStack stack = new ItemStack(mat, BASE_AMOUNT, data); + ItemStack removedStack = player.getInventory().removeItem(stack).get(0); + final int removedAmount = (BASE_AMOUNT - removedStack.getAmount()); + if (removedAmount > 0 || showExtended) { + sender.sendMessage(tl("inventoryClearingStack", removedAmount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName())); + } } else { - if (showExtended) { - sender.sendMessage(tl("inventoryClearFail", player.getDisplayName(), amount, stack.getType().toString().toLowerCase(Locale.ENGLISH))); + if (amount < 0) { + amount = 1; + } + ItemStack stack = new ItemStack(mat, amount); + if (player.getInventory().containsAtLeast(stack, amount)) { + sender.sendMessage(tl("inventoryClearingStack", amount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName())); + player.getInventory().removeItem(stack); + } else { + if (showExtended) { + sender.sendMessage(tl("inventoryClearFail", player.getDisplayName(), amount, stack.getType().toString().toLowerCase(Locale.ENGLISH))); + } } } } From 3353061e763a2c4bc09412d875eb7d78049cb661 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 15 Oct 2018 13:49:16 +0100 Subject: [PATCH 60/62] Remove ID-based permission checks in /more --- .../src/com/earth2me/essentials/commands/Commandmore.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandmore.java b/Essentials/src/com/earth2me/essentials/commands/Commandmore.java index efdb1125f..bd18e6f61 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandmore.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandmore.java @@ -21,13 +21,11 @@ public class Commandmore extends EssentialsCommand { throw new Exception(tl("cantSpawnItem", "Air")); } - int itemId = ess.getItemDb().getLegacyId(stack.getType()); - if (stack.getAmount() >= ((user.isAuthorized("essentials.oversizedstacks")) ? ess.getSettings().getOversizedStackSize() : stack.getMaxStackSize())) { throw new Exception(tl("fullStack")); } final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", ""); - if (ess.getSettings().permissionBasedItemSpawn() ? (!user.isAuthorized("essentials.itemspawn.item-all") && !user.isAuthorized("essentials.itemspawn.item-" + itemname) && !user.isAuthorized("essentials.itemspawn.item-" + itemId)) : (!user.isAuthorized("essentials.itemspawn.exempt") && !user.canSpawnItem(stack.getType()))) { + if (ess.getSettings().permissionBasedItemSpawn() ? (!user.isAuthorized("essentials.itemspawn.item-all") && !user.isAuthorized("essentials.itemspawn.item-" + itemname)) : (!user.isAuthorized("essentials.itemspawn.exempt") && !user.canSpawnItem(stack.getType()))) { throw new Exception(tl("cantSpawnItem", itemname)); } if (user.isAuthorized("essentials.oversizedstacks")) { From 010981d3c838cd7ad0656147df420b23586633b8 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 15 Oct 2018 13:51:04 +0100 Subject: [PATCH 61/62] Remove ID-based charges in /repair --- .../com/earth2me/essentials/commands/Commandrepair.java | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/commands/Commandrepair.java b/Essentials/src/com/earth2me/essentials/commands/Commandrepair.java index b60ec05df..34cdca94c 100644 --- a/Essentials/src/com/earth2me/essentials/commands/Commandrepair.java +++ b/Essentials/src/com/earth2me/essentials/commands/Commandrepair.java @@ -47,10 +47,8 @@ public class Commandrepair extends EssentialsCommand { throw new Exception(tl("repairEnchanted")); } - int itemId = ess.getItemDb().getLegacyId(item.getType()); - final String itemName = item.getType().toString().toLowerCase(Locale.ENGLISH); - final Trade charge = new Trade("repair-" + itemName.replace('_', '-'), new Trade("repair-" + itemId, new Trade("repair-item", ess), ess), ess); + final Trade charge = new Trade("repair-" + itemName.replace('_', '-'), new Trade("repair-item", ess), ess); charge.isAffordableFor(user); @@ -96,10 +94,8 @@ public class Commandrepair extends EssentialsCommand { continue; } - int itemId = ess.getItemDb().getLegacyId(item.getType()); - final String itemName = item.getType().toString().toLowerCase(Locale.ENGLISH); - final Trade charge = new Trade("repair-" + itemName.replace('_', '-'), new Trade("repair-" + itemId, new Trade("repair-item", ess), ess), ess); + final Trade charge = new Trade("repair-" + itemName.replace('_', '-'), new Trade("repair-item", ess), ess); try { charge.isAffordableFor(user); } catch (ChargeException ex) { From 0a90d76493ab70522823221f677ff3e32beb2d24 Mon Sep 17 00:00:00 2001 From: md678685 Date: Mon, 15 Oct 2018 13:56:36 +0100 Subject: [PATCH 62/62] Remove item IDs from Worth --- .../com/earth2me/essentials/ISettings.java | 3 +++ .../src/com/earth2me/essentials/Settings.java | 7 +++++++ .../src/com/earth2me/essentials/Worth.java | 21 +++---------------- 3 files changed, 13 insertions(+), 18 deletions(-) diff --git a/Essentials/src/com/earth2me/essentials/ISettings.java b/Essentials/src/com/earth2me/essentials/ISettings.java index 60222ed6d..c3f1aec73 100644 --- a/Essentials/src/com/earth2me/essentials/ISettings.java +++ b/Essentials/src/com/earth2me/essentials/ISettings.java @@ -134,8 +134,11 @@ public interface ISettings extends IConf { boolean isEcoDisabled(); + @Deprecated boolean isTradeInStacks(int id); + boolean isTradeInStacks(Material type); + List itemSpawnBlacklist(); List enabledSigns(); diff --git a/Essentials/src/com/earth2me/essentials/Settings.java b/Essentials/src/com/earth2me/essentials/Settings.java index b6fb4962f..276e785ef 100644 --- a/Essentials/src/com/earth2me/essentials/Settings.java +++ b/Essentials/src/com/earth2me/essentials/Settings.java @@ -649,10 +649,17 @@ public class Settings implements net.ess3.api.ISettings { // #easteregg @Override + @Deprecated public boolean isTradeInStacks(int id) { return config.getBoolean("trade-in-stacks-" + id, false); } + // #easteregg + @Override + public boolean isTradeInStacks(Material type) { + return config.getBoolean("trade-in-stacks." + type.toString().toLowerCase().replace("_", ""), false); + } + // #easteregg private boolean economyDisabled = false; diff --git a/Essentials/src/com/earth2me/essentials/Worth.java b/Essentials/src/com/earth2me/essentials/Worth.java index 12779f785..6aa79bed1 100644 --- a/Essentials/src/com/earth2me/essentials/Worth.java +++ b/Essentials/src/com/earth2me/essentials/Worth.java @@ -1,6 +1,7 @@ package com.earth2me.essentials; import com.earth2me.essentials.commands.NotEnoughArgumentsException; +import com.earth2me.essentials.utils.EnumUtil; import org.bukkit.Material; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.inventory.ItemStack; @@ -52,14 +53,6 @@ public class Worth implements IConf { throw new Exception(tl("itemSellAir")); } - int id; - - try { - id = ess.getItemDb().getLegacyId(is.getType()); - } catch (Exception e) { - return 0; - } - int amount = 0; if (args.length > 1) { @@ -74,7 +67,7 @@ public class Worth implements IConf { } boolean stack = args.length > 1 && args[1].endsWith("s"); - boolean requireStack = ess.getSettings().isTradeInStacks(id); + boolean requireStack = ess.getSettings().isTradeInStacks(is.getType()); if (requireStack && !stack) { throw new Exception(tl("itemMustBeStacked")); @@ -118,15 +111,7 @@ public class Worth implements IConf { // Bukkit-bug: getDurability still contains the correct value, while getData().getData() is 0. config.setProperty("worth." + itemStack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "") + "." + itemStack.getDurability(), price); } - - int itemId; - try { - itemId = ess.getItemDb().getLegacyId(itemStack.getType()); - } catch (Exception e) { - return; - } - - config.removeProperty("worth-" + itemId); + config.save(); }