From f70cc119df3fbb71ecba3cff08be32fc08f6ecc2 Mon Sep 17 00:00:00 2001 From: Naman Date: Thu, 21 Jun 2018 14:16:55 -0500 Subject: [PATCH] 1.7 spectator bug fixed. Placeholderapi is no longer a requirement. /f showclaims lag fixed Scoreboard is now off by default, can be turned on in config. Issue with Flight AutoEnabling when disabled has been fixed. 1.7 itemflag bug fixed --- .../java/com/massivecraft/factions/P.java | 14 + .../com/massivecraft/factions/cmd/CmdFly.java | 6 +- .../factions/cmd/CmdShowClaims.java | 7 +- .../listeners/FactionsPlayerListener.java | 6 + .../factions/scoreboards/FTeamWrapper.java | 6 +- .../{zcore => }/util/InventoryUtil.java | 19 +- .../zcore/fupgrades/FUpgradesGUI.java | 8 +- .../factions/zcore/nbtapi/NBTCompound.java | 193 ++++ .../factions/zcore/nbtapi/NBTContainer.java | 35 + .../factions/zcore/nbtapi/NBTEntity.java | 22 + .../factions/zcore/nbtapi/NBTFile.java | 46 + .../factions/zcore/nbtapi/NBTItem.java | 38 + .../factions/zcore/nbtapi/NBTList.java | 127 +++ .../zcore/nbtapi/NBTListCompound.java | 102 ++ .../zcore/nbtapi/NBTReflectionUtil.java | 982 ++++++++++++++++++ .../factions/zcore/nbtapi/NBTTileEntity.java | 22 + .../factions/zcore/nbtapi/NBTType.java | 34 + .../zcore/nbtapi/utils/GsonWrapper.java | 27 + .../zcore/nbtapi/utils/MethodNames.java | 36 + .../zcore/nbtapi/utils/MinecraftVersion.java | 60 ++ .../factions/zcore/persist/MemoryFaction.java | 4 +- .../massivecraft/factions/zcore/util/TL.java | 2 +- src/main/resources/config.yml | 11 +- src/main/resources/plugin.yml | 2 +- 24 files changed, 1790 insertions(+), 19 deletions(-) rename src/main/java/com/massivecraft/factions/{zcore => }/util/InventoryUtil.java (89%) create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTCompound.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTContainer.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTEntity.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTFile.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTItem.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTList.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTListCompound.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTReflectionUtil.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTTileEntity.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTType.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/GsonWrapper.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MethodNames.java create mode 100644 src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MinecraftVersion.java diff --git a/src/main/java/com/massivecraft/factions/P.java b/src/main/java/com/massivecraft/factions/P.java index 99472398..f95a9cb1 100644 --- a/src/main/java/com/massivecraft/factions/P.java +++ b/src/main/java/com/massivecraft/factions/P.java @@ -49,6 +49,10 @@ public class P extends MPlugin { public static Permission perms = null; + + public boolean PlaceholderApi; + + ItemStack item = new ItemStack(Material.CAKE); // Persistence related private boolean locked = false; @@ -100,6 +104,7 @@ public class P extends MPlugin { public boolean mc17 = false; public boolean mc18 = false; + public boolean factionsFlight = false; @Override @@ -160,6 +165,10 @@ public class P extends MPlugin { mc18 = true; } + if (P.p.getConfig().getBoolean("enable-faction-flight")) { + factionsFlight = true; + } + // Register Event Handlers getServer().getPluginManager().registerEvents(new FactionsPlayerListener(this), this); getServer().getPluginManager().registerEvents(new FactionsChatListener(this), this); @@ -187,8 +196,13 @@ public class P extends MPlugin { if (clip != null && clip.isEnabled()) { this.clipPlaceholderAPIManager = new ClipPlaceholderAPIManager(); if (this.clipPlaceholderAPIManager.register()) { + PlaceholderApi = true; log(Level.INFO, "Successfully registered placeholders with PlaceholderAPI."); + } else { + PlaceholderApi = false; } + } else { + PlaceholderApi = false; } Plugin mvdw = getServer().getPluginManager().getPlugin("MVdWPlaceholderAPI"); diff --git a/src/main/java/com/massivecraft/factions/cmd/CmdFly.java b/src/main/java/com/massivecraft/factions/cmd/CmdFly.java index 5919b37a..b3065d87 100644 --- a/src/main/java/com/massivecraft/factions/cmd/CmdFly.java +++ b/src/main/java/com/massivecraft/factions/cmd/CmdFly.java @@ -47,8 +47,10 @@ public class CmdFly extends FCommand { if (!player.isFlying()) { continue; } - if (player.getGameMode() == GameMode.SPECTATOR){ - continue; + if (!P.p.mc17) { + if (player.getGameMode() == GameMode.SPECTATOR){ + continue; + } } if (FPlayers.getInstance().getByPlayer(player).isVanished()){ continue; diff --git a/src/main/java/com/massivecraft/factions/cmd/CmdShowClaims.java b/src/main/java/com/massivecraft/factions/cmd/CmdShowClaims.java index 7b9b86ee..d9f2a016 100644 --- a/src/main/java/com/massivecraft/factions/cmd/CmdShowClaims.java +++ b/src/main/java/com/massivecraft/factions/cmd/CmdShowClaims.java @@ -40,11 +40,16 @@ public class CmdShowClaims extends FCommand{ } for (String world : chunkMap.keySet()){ String message = TL.COMMAND_SHOWCLAIMS_FORMAT.toString().replace("{world}",world); + sendMessage(message.replace("{chunks}","")); // made {chunks} blank as I removed the placeholder and people wont update their config :shrug: StringBuilder chunks = new StringBuilder(""); for (String chunkString : chunkMap.get(world)){ chunks.append(chunkString + ", "); + if (chunks.toString().length() >= 2000 ) { + sendMessage(chunks.toString()); + chunks.setLength(0); + } } - sendMessage(message.replace("{chunks}",chunks)); + sendMessage(""); } diff --git a/src/main/java/com/massivecraft/factions/listeners/FactionsPlayerListener.java b/src/main/java/com/massivecraft/factions/listeners/FactionsPlayerListener.java index 8a03536b..39147ea3 100644 --- a/src/main/java/com/massivecraft/factions/listeners/FactionsPlayerListener.java +++ b/src/main/java/com/massivecraft/factions/listeners/FactionsPlayerListener.java @@ -408,6 +408,12 @@ public class FactionsPlayerListener implements Listener { } } + + if (!P.p.factionsFlight) { + return; + } + + // enable fly :) if (me.hasFaction() && !me.isFlying()) { if (factionTo == me.getFaction()) { diff --git a/src/main/java/com/massivecraft/factions/scoreboards/FTeamWrapper.java b/src/main/java/com/massivecraft/factions/scoreboards/FTeamWrapper.java index 070d5d55..8efb92cb 100644 --- a/src/main/java/com/massivecraft/factions/scoreboards/FTeamWrapper.java +++ b/src/main/java/com/massivecraft/factions/scoreboards/FTeamWrapper.java @@ -170,8 +170,10 @@ public class FTeamWrapper { Team team = teams.get(fboard); String prefix = TL.DEFAULT_PREFIX.toString(); - prefix = PlaceholderAPI.setPlaceholders(fplayer.getPlayer(),prefix); - prefix = PlaceholderAPI.setBracketPlaceholders(fplayer.getPlayer(),prefix); + if (P.p.PlaceholderApi) { + prefix = PlaceholderAPI.setPlaceholders(fplayer.getPlayer(),prefix); + prefix = PlaceholderAPI.setBracketPlaceholders(fplayer.getPlayer(),prefix); + } prefix = prefix.replace("{relationcolor}", faction.getRelationTo(fplayer).getColor().toString()); prefix = prefix.replace("{faction}", faction.getTag().substring(0, Math.min("{faction}".length() + 16 - prefix.length(), faction.getTag().length()))); if (team.getPrefix() == null || !team.getPrefix().equals(prefix)) { diff --git a/src/main/java/com/massivecraft/factions/zcore/util/InventoryUtil.java b/src/main/java/com/massivecraft/factions/util/InventoryUtil.java similarity index 89% rename from src/main/java/com/massivecraft/factions/zcore/util/InventoryUtil.java rename to src/main/java/com/massivecraft/factions/util/InventoryUtil.java index 256f51a2..ca3b309f 100644 --- a/src/main/java/com/massivecraft/factions/zcore/util/InventoryUtil.java +++ b/src/main/java/com/massivecraft/factions/util/InventoryUtil.java @@ -1,5 +1,7 @@ -package com.massivecraft.factions.zcore.util; +package com.massivecraft.factions.util; +import com.massivecraft.factions.zcore.nbtapi.NBTItem; +import com.massivecraft.factions.zcore.nbtapi.NBTType; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.enchantments.Enchantment; @@ -7,6 +9,7 @@ import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; import java.util.Map; +import java.util.Set; public class InventoryUtil { @@ -44,6 +47,16 @@ public class InventoryUtil { } } + + +/* + NBTItem nbtItem = new NBTItem(is); + Set nbtKeySet = nbtItem.getKeys(); + + for (String nbtKey : nbtKeySet) { + serializedItemStack.append(":n@" + nbtKey + "@" + nbtItem.getType(nbtKey).getId() + "@" + ) + } +*/ // serialization += i + "#" + serializedItemStack + ";"; serialization.append(i + "#" + serializedItemStack + ";"); } @@ -87,4 +100,8 @@ public class InventoryUtil { return deserializedInventory; } + + + + } diff --git a/src/main/java/com/massivecraft/factions/zcore/fupgrades/FUpgradesGUI.java b/src/main/java/com/massivecraft/factions/zcore/fupgrades/FUpgradesGUI.java index 52cce287..41f9ec31 100644 --- a/src/main/java/com/massivecraft/factions/zcore/fupgrades/FUpgradesGUI.java +++ b/src/main/java/com/massivecraft/factions/zcore/fupgrades/FUpgradesGUI.java @@ -237,7 +237,7 @@ public class FUpgradesGUI implements Listener { ItemStack expItem = P.p.createItem(expMaterial, expAmt, expData, expName, expLore); if (expLevel >= 1) { ItemMeta itemMeta = expItem.getItemMeta(); - itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + if (!P.p.mc17) { itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); } itemMeta.addEnchant(Enchantment.DURABILITY, 3, true); expItem.setItemMeta(itemMeta); } @@ -275,7 +275,7 @@ public class FUpgradesGUI implements Listener { cropItem.getItemMeta().setLore(cropLore); if (cropLevel >= 1) { ItemMeta itemMeta = cropItem.getItemMeta(); - itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + if (!P.p.mc17) { itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); } itemMeta.addEnchant(Enchantment.DURABILITY, 3, true); cropItem.setItemMeta(itemMeta); } @@ -288,7 +288,7 @@ public class FUpgradesGUI implements Listener { spawnerItem.getItemMeta().setLore(spawnerLore); if (spawnerLevel >= 1) { ItemMeta itemMeta = spawnerItem.getItemMeta(); - itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + if (!P.p.mc17) { itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); } itemMeta.addEnchant(Enchantment.DURABILITY, 3, true); spawnerItem.setItemMeta(itemMeta); } @@ -314,7 +314,7 @@ public class FUpgradesGUI implements Listener { if (chestlevel >= 1) { ItemMeta itemMeta = chestItem.getItemMeta(); - itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + if (!P.p.mc17) { itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS); } itemMeta.addEnchant(Enchantment.DURABILITY, 3, true); chestItem.setItemMeta(itemMeta); } diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTCompound.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTCompound.java new file mode 100644 index 00000000..2e64c644 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTCompound.java @@ -0,0 +1,193 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import java.util.Set; + +import com.massivecraft.factions.zcore.nbtapi.utils.MinecraftVersion; + + +public class NBTCompound { + + private String compundName; + private NBTCompound parent; + + protected NBTCompound(NBTCompound owner, String name) { + this.compundName = name; + this.parent = owner; + } + + public String getName() { + return compundName; + } + + protected Object getCompound() { + return parent.getCompound(); + } + + protected void setCompound(Object compound) { + parent.setCompound(compound); + } + + public NBTCompound getParent() { + return parent; + } + + public void mergeCompound(NBTCompound comp){ + NBTReflectionUtil.addOtherNBTCompound(this, comp); + } + + public void setString(String key, String value) { + NBTReflectionUtil.setString(this, key, value); + } + + public String getString(String key) { + return NBTReflectionUtil.getString(this, key); + } + + protected String getContent(String key) { + return NBTReflectionUtil.getContent(this, key); + } + + public void setInteger(String key, Integer value) { + NBTReflectionUtil.setInt(this, key, value); + } + + public Integer getInteger(String key) { + return NBTReflectionUtil.getInt(this, key); + } + + public void setDouble(String key, Double value) { + NBTReflectionUtil.setDouble(this, key, value); + } + + public Double getDouble(String key) { + return NBTReflectionUtil.getDouble(this, key); + } + + public void setByte(String key, Byte value) { + NBTReflectionUtil.setByte(this, key, value); + } + + public Byte getByte(String key) { + return NBTReflectionUtil.getByte(this, key); + } + + public void setShort(String key, Short value) { + NBTReflectionUtil.setShort(this, key, value); + } + + public Short getShort(String key) { + return NBTReflectionUtil.getShort(this, key); + } + + public void setLong(String key, Long value) { + NBTReflectionUtil.setLong(this, key, value); + } + + public Long getLong(String key) { + return NBTReflectionUtil.getLong(this, key); + } + + public void setFloat(String key, Float value) { + NBTReflectionUtil.setFloat(this, key, value); + } + + public Float getFloat(String key) { + return NBTReflectionUtil.getFloat(this, key); + } + + public void setByteArray(String key, byte[] value) { + NBTReflectionUtil.setByteArray(this, key, value); + } + + public byte[] getByteArray(String key) { + return NBTReflectionUtil.getByteArray(this, key); + } + + public void setIntArray(String key, int[] value) { + NBTReflectionUtil.setIntArray(this, key, value); + } + + public int[] getIntArray(String key) { + return NBTReflectionUtil.getIntArray(this, key); + } + + public void setBoolean(String key, Boolean value) { + NBTReflectionUtil.setBoolean(this, key, value); + } + + protected void set(String key, Object val) { + NBTReflectionUtil.set(this, key, val); + } + + public Boolean getBoolean(String key) { + return NBTReflectionUtil.getBoolean(this, key); + } + + public void setObject(String key, Object value) { + NBTReflectionUtil.setObject(this, key, value); + } + + public T getObject(String key, Class type) { + return NBTReflectionUtil.getObject(this, key, type); + } + + public Boolean hasKey(String key) { + return NBTReflectionUtil.hasKey(this, key); + } + + public void removeKey(String key) { + NBTReflectionUtil.remove(this, key); + } + + public Set getKeys() { + return NBTReflectionUtil.getKeys(this); + } + + public NBTCompound addCompound(String name) { + NBTReflectionUtil.addNBTTagCompound(this, name); + return getCompound(name); + } + + public NBTCompound getCompound(String name) { + NBTCompound next = new NBTCompound(this, name); + if (NBTReflectionUtil.valideCompound(next)) return next; + return null; + } + + public NBTList getList(String name, NBTType type) { + return NBTReflectionUtil.getList(this, name, type); + } + + public NBTType getType(String name) { + if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_7_R4) return NBTType.NBTTagEnd; + return NBTType.valueOf(NBTReflectionUtil.getType(this, name)); + } + + @Override + public String toString() { + StringBuilder result = new StringBuilder(); + for (String key : getKeys()) { + result.append(toString(key)); + } + return result.toString(); + } + + public String toString(String key) { + StringBuilder result = new StringBuilder(); + NBTCompound compound = this; + while (compound.getParent() != null) { + result.append(" "); + compound = compound.getParent(); + } + if (this.getType(key) == NBTType.NBTTagCompound) { + return this.getCompound(key).toString(); + } else { + return result + "-" + key + ": " + getContent(key) + System.lineSeparator(); + } + } + + public String asNBTString(){ + return NBTReflectionUtil.gettoCompount(getCompound(), this).toString(); + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTContainer.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTContainer.java new file mode 100644 index 00000000..6916e51c --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTContainer.java @@ -0,0 +1,35 @@ +package com.massivecraft.factions.zcore.nbtapi; + +public class NBTContainer extends NBTCompound{ + + private Object nbt; + + public NBTContainer() { + super(null, null); + nbt = NBTReflectionUtil.getNewNBTTag(); + } + + protected NBTContainer(Object nbt){ + super(null, null); + this.nbt = nbt; + } + + public NBTContainer(String nbtString) throws IllegalArgumentException { + super(null, null); + try{ + nbt = NBTReflectionUtil.parseNBT(nbtString); + }catch(Exception ex){ + ex.printStackTrace(); + throw new IllegalArgumentException("Malformed Json: " + ex.getMessage()); + } + } + + protected Object getCompound() { + return nbt; + } + + protected void setCompound(Object tag) { + nbt = tag; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTEntity.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTEntity.java new file mode 100644 index 00000000..e1501af2 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTEntity.java @@ -0,0 +1,22 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import org.bukkit.entity.Entity; + +public class NBTEntity extends NBTCompound { + + private final Entity ent; + + public NBTEntity(Entity entity) { + super(null, null); + ent = entity; + } + + protected Object getCompound() { + return NBTReflectionUtil.getEntityNBTTagCompound(NBTReflectionUtil.getNMSEntity(ent)); + } + + protected void setCompound(Object compound) { + NBTReflectionUtil.setEntityNBTTag(compound, NBTReflectionUtil.getNMSEntity(ent)); + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTFile.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTFile.java new file mode 100644 index 00000000..cfcda445 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTFile.java @@ -0,0 +1,46 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; + +public class NBTFile extends NBTCompound { + + private final File file; + private Object nbt; + + public NBTFile(File file) throws IOException { + super(null, null); + this.file = file; + if (file.exists()) { + FileInputStream inputsteam = new FileInputStream(file); + nbt = NBTReflectionUtil.readNBTFile(inputsteam); + } else { + nbt = NBTReflectionUtil.getNewNBTTag(); + save(); + } + } + + public void save() throws IOException { + if (!file.exists()) { + file.getParentFile().mkdirs(); + file.createNewFile(); + } + FileOutputStream outStream = new FileOutputStream(file); + NBTReflectionUtil.saveNBTFile(nbt, outStream); + } + + public File getFile() { + return file; + } + + protected Object getCompound() { + return nbt; + } + + protected void setCompound(Object compound) { + nbt = compound; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTItem.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTItem.java new file mode 100644 index 00000000..80e3b750 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTItem.java @@ -0,0 +1,38 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import org.bukkit.inventory.ItemStack; + +public class NBTItem extends NBTCompound { + + private ItemStack bukkitItem; + + public NBTItem(ItemStack item) { + super(null, null); + bukkitItem = item.clone(); + } + + protected Object getCompound() { + return NBTReflectionUtil.getItemRootNBTTagCompound(NBTReflectionUtil.getNMSItemStack(bukkitItem)); + } + + protected void setCompound(Object compound) { + bukkitItem = NBTReflectionUtil.getBukkitItemStack(NBTReflectionUtil.setNBTTag(compound, NBTReflectionUtil.getNMSItemStack(bukkitItem))); + } + + public ItemStack getItem() { + return bukkitItem; + } + + protected void setItem(ItemStack item) { + bukkitItem = item; + } + + public static NBTContainer convertItemtoNBT(ItemStack item){ + return NBTReflectionUtil.convertNMSItemtoNBTCompound(NBTReflectionUtil.getNMSItemStack(item)); + } + + public static ItemStack convertNBTtoItem(NBTCompound comp){ + return NBTReflectionUtil.getBukkitItemStack(NBTReflectionUtil.convertNBTCompoundtoNMSItem(comp)); + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTList.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTList.java new file mode 100644 index 00000000..4cb21833 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTList.java @@ -0,0 +1,127 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import com.massivecraft.factions.zcore.nbtapi.utils.MethodNames; + +import java.lang.reflect.Method; + +public class NBTList { + + private String listName; + private NBTCompound parent; + private NBTType type; + private Object listObject; + + protected NBTList(NBTCompound owner, String name, NBTType type, Object list) { + parent = owner; + listName = name; + this.type = type; + this.listObject = list; + if (!(type == NBTType.NBTTagString || type == NBTType.NBTTagCompound)) { + System.err.println("List types != String/Compound are currently not implemented!"); + } + } + + protected void save() { + parent.set(listName, listObject); + } + + public NBTListCompound addCompound() { + if (type != NBTType.NBTTagCompound) { + new Throwable("Using Compound method on a non Compound list!").printStackTrace(); + return null; + } + try { + Method method = listObject.getClass().getMethod("add", NBTReflectionUtil.getNBTBase()); + Object compound = NBTReflectionUtil.getNBTTagCompound().newInstance(); + method.invoke(listObject, compound); + return new NBTListCompound(this, compound); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public NBTListCompound getCompound(int id) { + if (type != NBTType.NBTTagCompound) { + new Throwable("Using Compound method on a non Compound list!").printStackTrace(); + return null; + } + try { + Method method = listObject.getClass().getMethod("get", int.class); + Object compound = method.invoke(listObject, id); + return new NBTListCompound(this, compound); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public String getString(int i) { + if (type != NBTType.NBTTagString) { + new Throwable("Using String method on a non String list!").printStackTrace(); + return null; + } + try { + Method method = listObject.getClass().getMethod("getString", int.class); + return (String) method.invoke(listObject, i); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + @SuppressWarnings("unchecked") + public void addString(String s) { + if (type != NBTType.NBTTagString) { + new Throwable("Using String method on a non String list!").printStackTrace(); + return; + } + try { + Method method = listObject.getClass().getMethod("add", NBTReflectionUtil.getNBTBase()); + method.invoke(listObject, NBTReflectionUtil.getNBTTagString().getConstructor(String.class).newInstance(s)); + save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + @SuppressWarnings("unchecked") + public void setString(int i, String s) { + if (type != NBTType.NBTTagString) { + new Throwable("Using String method on a non String list!").printStackTrace(); + return; + } + try { + Method method = listObject.getClass().getMethod("a", int.class, NBTReflectionUtil.getNBTBase()); + method.invoke(listObject, i, NBTReflectionUtil.getNBTTagString().getConstructor(String.class).newInstance(s)); + save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public void remove(int i) { + try { + Method method = listObject.getClass().getMethod(MethodNames.getRemoveMethodName(), int.class); + method.invoke(listObject, i); + save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public int size() { + try { + Method method = listObject.getClass().getMethod("size"); + return (int) method.invoke(listObject); + } catch (Exception ex) { + ex.printStackTrace(); + } + return -1; + } + + public NBTType getType() { + return type; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTListCompound.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTListCompound.java new file mode 100644 index 00000000..e3d92716 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTListCompound.java @@ -0,0 +1,102 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import java.util.HashSet; +import java.util.Set; + +public class NBTListCompound { + + private NBTList owner; + private Object compound; + + protected NBTListCompound(NBTList parent, Object obj) { + owner = parent; + compound = obj; + } + + public void setString(String key, String value) { + if (value == null) { + remove(key); + return; + } + try { + compound.getClass().getMethod("setString", String.class, String.class).invoke(compound, key, value); + owner.save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public void setInteger(String key, int value) { + try { + compound.getClass().getMethod("setInt", String.class, int.class).invoke(compound, key, value); + owner.save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public int getInteger(String value) { + try { + return (int) compound.getClass().getMethod("getInt", String.class).invoke(compound, value); + } catch (Exception ex) { + ex.printStackTrace(); + } + return 0; + } + + public void setDouble(String key, double value) { + try { + compound.getClass().getMethod("setDouble", String.class, double.class).invoke(compound, key, value); + owner.save(); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public double getDouble(String key) { + try { + return (double) compound.getClass().getMethod("getDouble", String.class).invoke(compound, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return 0; + } + + + public String getString(String key) { + try { + return (String) compound.getClass().getMethod("getString", String.class).invoke(compound, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return ""; + } + + public boolean hasKey(String key) { + try { + return (boolean) compound.getClass().getMethod("hasKey", String.class).invoke(compound, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return false; + } + + @SuppressWarnings("unchecked") + public Set getKeys() { + try { + return (Set) compound.getClass().getMethod("c").invoke(compound); + } catch (Exception ex) { + ex.printStackTrace(); + } + return new HashSet<>(); + } + + public void remove(String key) { + try { + compound.getClass().getMethod("remove", String.class).invoke(compound, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTReflectionUtil.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTReflectionUtil.java new file mode 100644 index 00000000..ddb001d8 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTReflectionUtil.java @@ -0,0 +1,982 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.reflect.Method; +import java.util.Set; +import java.util.Stack; + +import org.bukkit.Bukkit; +import org.bukkit.block.BlockState; +import org.bukkit.entity.Entity; +import org.bukkit.inventory.ItemStack; + +import com.massivecraft.factions.zcore.nbtapi.utils.GsonWrapper; +import com.massivecraft.factions.zcore.nbtapi.utils.MethodNames; +import com.massivecraft.factions.zcore.nbtapi.utils.MinecraftVersion; + +// TODO: finish codestyle cleanup -sgdc3 +public class NBTReflectionUtil { + + private static final String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3]; + + @SuppressWarnings("rawtypes") + private static Class getCraftItemStack() { + + try { + Class clazz = Class.forName("org.bukkit.craftbukkit." + version + ".inventory.CraftItemStack"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + private static Class getCraftEntity() { + try { + Class clazz = Class.forName("org.bukkit.craftbukkit." + version + ".entity.CraftEntity"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getNBTBase() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".NBTBase"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getNBTTagString() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".NBTTagString"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getNMSItemStack() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".ItemStack"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getNBTTagCompound() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".NBTTagCompound"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getNBTCompressedStreamTools() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".NBTCompressedStreamTools"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getMojangsonParser() { + try { + Class c = Class.forName("net.minecraft.server." + version + ".MojangsonParser"); + return c; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getTileEntity() { + try { + Class clazz = Class.forName("net.minecraft.server." + version + ".TileEntity"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + @SuppressWarnings("rawtypes") + protected static Class getCraftWorld() { + try { + Class clazz = Class.forName("org.bukkit.craftbukkit." + version + ".CraftWorld"); + return clazz; + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + public static Object getNewNBTTag() { + String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3]; + try { + @SuppressWarnings("rawtypes") + Class c = Class.forName("net.minecraft.server." + version + ".NBTTagCompound"); + return c.newInstance(); + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + private static Object getNewBlockPosition(int x, int y, int z) { + String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3]; + try { + @SuppressWarnings("rawtypes") + Class clazz = Class.forName("net.minecraft.server." + version + ".BlockPosition"); + return clazz.getConstructor(int.class, int.class, int.class).newInstance(x, y, z); + } catch (Exception ex) { + System.out.println("Error in ItemNBTAPI! (Outdated plugin?)"); + ex.printStackTrace(); + return null; + } + } + + public static Object setNBTTag(Object NBTTag, Object NMSItem) { + try { + Method method; + method = NMSItem.getClass().getMethod("setTag", NBTTag.getClass()); + method.invoke(NMSItem, NBTTag); + return NMSItem; + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + @SuppressWarnings("unchecked") + public static Object getNMSItemStack(ItemStack item) { + @SuppressWarnings("rawtypes") + Class clazz = getCraftItemStack(); + Method method; + try { + method = clazz.getMethod("asNMSCopy", ItemStack.class); + Object answer = method.invoke(clazz, item); + return answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings("unchecked") + public static Object getNMSEntity(Entity entity) { + @SuppressWarnings("rawtypes") + Class clazz = getCraftEntity(); + Method method; + try { + method = clazz.getMethod("getHandle"); + return method.invoke(getCraftEntity().cast(entity)); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object parseNBT(String json) { + @SuppressWarnings("rawtypes") + Class cis = getMojangsonParser(); + Method method; + try { + method = cis.getMethod("parse", String.class); + return method.invoke(null, json); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object readNBTFile(FileInputStream stream) { + @SuppressWarnings("rawtypes") + Class clazz = getNBTCompressedStreamTools(); + Method method; + try { + method = clazz.getMethod("a", InputStream.class); + return method.invoke(clazz, stream); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object saveNBTFile(Object nbt, FileOutputStream stream) { + @SuppressWarnings("rawtypes") + Class clazz = getNBTCompressedStreamTools(); + Method method; + try { + method = clazz.getMethod("a", getNBTTagCompound(), OutputStream.class); + return method.invoke(clazz, nbt, stream); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static ItemStack getBukkitItemStack(Object item) { + @SuppressWarnings("rawtypes") + Class clazz = getCraftItemStack(); + Method method; + try { + method = clazz.getMethod("asCraftMirror", item.getClass()); + Object answer = method.invoke(clazz, item); + return (ItemStack) answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object getItemRootNBTTagCompound(Object nmsitem) { + @SuppressWarnings("rawtypes") + Class clazz = nmsitem.getClass(); + Method method; + try { + method = clazz.getMethod("getTag"); + Object answer = method.invoke(nmsitem); + return answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object convertNBTCompoundtoNMSItem(NBTCompound nbtcompound) { + @SuppressWarnings("rawtypes") + Class clazz = getNMSItemStack(); + try { + Object nmsstack = clazz.getConstructor(getNBTTagCompound()).newInstance(gettoCompount(nbtcompound.getCompound(), nbtcompound)); + return nmsstack; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static NBTContainer convertNMSItemtoNBTCompound(Object nmsitem) { + @SuppressWarnings("rawtypes") + Class clazz = nmsitem.getClass(); + Method method; + try { + method = clazz.getMethod("save", getNBTTagCompound()); + Object answer = method.invoke(nmsitem, getNewNBTTag()); + return new NBTContainer(answer); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @SuppressWarnings({"unchecked"}) + public static Object getEntityNBTTagCompound(Object nmsitem) { + @SuppressWarnings("rawtypes") + Class c = nmsitem.getClass(); + Method method; + try { + method = c.getMethod(MethodNames.getEntityNbtGetterMethodName(), getNBTTagCompound()); + Object nbt = getNBTTagCompound().newInstance(); + Object answer = method.invoke(nmsitem, nbt); + if (answer == null) + answer = nbt; + return answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + public static Object setEntityNBTTag(Object NBTTag, Object NMSItem) { + try { + Method method; + method = NMSItem.getClass().getMethod(MethodNames.getEntityNbtSetterMethodName(), getNBTTagCompound()); + method.invoke(NMSItem, NBTTag); + return NMSItem; + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static Object getTileEntityNBTTagCompound(BlockState tile) { + Method method; + try { + Object pos = getNewBlockPosition(tile.getX(), tile.getY(), tile.getZ()); + Object cworld = getCraftWorld().cast(tile.getWorld()); + Object nmsworld = cworld.getClass().getMethod("getHandle").invoke(cworld); + Object o = nmsworld.getClass().getMethod("getTileEntity", pos.getClass()).invoke(nmsworld, pos); + method = getTileEntity().getMethod(MethodNames.getTileDataMethodName(), getNBTTagCompound()); + Object tag = getNBTTagCompound().newInstance(); + Object answer = method.invoke(o, tag); + if (answer == null) + answer = tag; + return answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + public static void setTileEntityNBTTagCompound(BlockState tile, Object comp) { + Method method; + try { + Object pos = getNewBlockPosition(tile.getX(), tile.getY(), tile.getZ()); + Object cworld = getCraftWorld().cast(tile.getWorld()); + Object nmsworld = cworld.getClass().getMethod("getHandle").invoke(cworld); + Object o = nmsworld.getClass().getMethod("getTileEntity", pos.getClass()).invoke(nmsworld, pos); + method = getTileEntity().getMethod("a", getNBTTagCompound()); + method.invoke(o, comp); + } catch (Exception e) { + e.printStackTrace(); + } + } + + + @SuppressWarnings("unchecked") + public static Object getSubNBTTagCompound(Object compound, String name) { + @SuppressWarnings("rawtypes") + Class c = compound.getClass(); + Method method; + try { + method = c.getMethod("getCompound", String.class); + Object answer = method.invoke(compound, name); + return answer; + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + public static void addNBTTagCompound(NBTCompound comp, String name) { + if (name == null) { + remove(comp, name); + return; + } + Object nbttag = comp.getCompound(); + if (nbttag == null) { + nbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(nbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("set", String.class, getNBTBase()); + method.invoke(workingtag, name, getNBTTagCompound().newInstance()); + comp.setCompound(nbttag); + return; + } catch (Exception ex) { + ex.printStackTrace(); + } + return; + } + + public static Boolean valideCompound(NBTCompound comp) { + Object root = comp.getCompound(); + if (root == null) { + root = getNewNBTTag(); + } + return (gettoCompount(root, comp)) != null; + } + + public static Object gettoCompount(Object nbttag, NBTCompound comp) { + Stack structure = new Stack<>(); + while (comp.getParent() != null) { + structure.add(comp.getName()); + comp = comp.getParent(); + } + while (!structure.isEmpty()) { + nbttag = getSubNBTTagCompound(nbttag, structure.pop()); + if (nbttag == null) { + return null; + } + } + return nbttag; + } + + public static void addOtherNBTCompound(NBTCompound comp, NBTCompound nbtcompound) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("a", getNBTTagCompound()); + method.invoke(workingtag, nbtcompound.getCompound()); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static void setString(NBTCompound comp, String key, String text) { + if (text == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setString", String.class, String.class); + method.invoke(workingtag, key, text); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static String getString(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getString", String.class); + return (String) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static String getContent(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("get", String.class); + return method.invoke(workingtag, key).toString(); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setInt(NBTCompound comp, String key, Integer i) { + if (i == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setInt", String.class, int.class); + method.invoke(workingtag, key, i); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Integer getInt(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getInt", String.class); + return (Integer) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setByteArray(NBTCompound comp, String key, byte[] b) { + if (b == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setByteArray", String.class, byte[].class); + method.invoke(workingtag, key, b); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + return; + } + + public static byte[] getByteArray(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getByteArray", String.class); + return (byte[]) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setIntArray(NBTCompound comp, String key, int[] i) { + if (i == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setIntArray", String.class, int[].class); + method.invoke(workingtag, key, i); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static int[] getIntArray(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getIntArray", String.class); + return (int[]) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setFloat(NBTCompound comp, String key, Float f) { + if (f == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setFloat", String.class, float.class); + method.invoke(workingtag, key, (float) f); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Float getFloat(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getFloat", String.class); + return (Float) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setLong(NBTCompound comp, String key, Long f) { + if (f == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setLong", String.class, long.class); + method.invoke(workingtag, key, (long) f); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Long getLong(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getLong", String.class); + return (Long) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setShort(NBTCompound comp, String key, Short f) { + if (f == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setShort", String.class, short.class); + method.invoke(workingtag, key, (short) f); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Short getShort(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getShort", String.class); + return (Short) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setByte(NBTCompound comp, String key, Byte f) { + if (f == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setByte", String.class, byte.class); + method.invoke(workingtag, key, (byte) f); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Byte getByte(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getByte", String.class); + return (Byte) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setDouble(NBTCompound comp, String key, Double d) { + if (d == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setDouble", String.class, double.class); + method.invoke(workingtag, key, d); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Double getDouble(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getDouble", String.class); + return (Double) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static byte getType(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return 0; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod(MethodNames.getTypeMethodName(), String.class); + return (byte) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return 0; + } + + public static void setBoolean(NBTCompound comp, String key, Boolean d) { + if (d == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("setBoolean", String.class, boolean.class); + method.invoke(workingtag, key, d); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Boolean getBoolean(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getBoolean", String.class); + return (Boolean) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void set(NBTCompound comp, String key, Object val) { + if (val == null) { + remove(comp, key); + return; + } + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) { + new Throwable("InvalideCompound").printStackTrace(); + return; + } + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("set", String.class, getNBTBase()); + method.invoke(workingtag, key, val); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static NBTList getList(NBTCompound comp, String key, NBTType type) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("getList", String.class, int.class); + return new NBTList(comp, key, type, method.invoke(workingtag, key, type.getId())); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + public static void setObject(NBTCompound comp, String key, Object value) { + if (!MinecraftVersion.hasGsonSupport()) return; + try { + String json = GsonWrapper.getString(value); + setString(comp, key, json); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static T getObject(NBTCompound comp, String key, Class type) { + if (!MinecraftVersion.hasGsonSupport()) return null; + String json = getString(comp, key); + if (json == null) { + return null; + } + return GsonWrapper.deserializeJson(json, type); + } + + public static void remove(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("remove", String.class); + method.invoke(workingtag, key); + comp.setCompound(rootnbttag); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Boolean hasKey(NBTCompound comp, String key) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("hasKey", String.class); + return (Boolean) method.invoke(workingtag, key); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + + @SuppressWarnings("unchecked") + public static Set getKeys(NBTCompound comp) { + Object rootnbttag = comp.getCompound(); + if (rootnbttag == null) { + rootnbttag = getNewNBTTag(); + } + if (!valideCompound(comp)) return null; + Object workingtag = gettoCompount(rootnbttag, comp); + Method method; + try { + method = workingtag.getClass().getMethod("c"); + return (Set) method.invoke(workingtag); + } catch (Exception ex) { + ex.printStackTrace(); + } + return null; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTTileEntity.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTTileEntity.java new file mode 100644 index 00000000..721e158a --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTTileEntity.java @@ -0,0 +1,22 @@ +package com.massivecraft.factions.zcore.nbtapi; + +import org.bukkit.block.BlockState; + +public class NBTTileEntity extends NBTCompound { + + private final BlockState tile; + + public NBTTileEntity(BlockState tile) { + super(null, null); + this.tile = tile; + } + + protected Object getCompound() { + return NBTReflectionUtil.getTileEntityNBTTagCompound(tile); + } + + protected void setCompound(Object compound) { + NBTReflectionUtil.setTileEntityNBTTagCompound(tile, compound); + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTType.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTType.java new file mode 100644 index 00000000..7abb4193 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/NBTType.java @@ -0,0 +1,34 @@ +package com.massivecraft.factions.zcore.nbtapi; + +public enum NBTType { + NBTTagEnd(0), + NBTTagByte(1), + NBTTagShort(2), + NBTTagInt(3), + NBTTagLong(4), + NBTTagFloat(5), + NBTTagDouble(6), + NBTTagByteArray(7), + NBTTagIntArray(11), + NBTTagString(8), + NBTTagList(9), + NBTTagCompound(10); + + NBTType(int i) { + id = i; + } + + private final int id; + + public int getId() { + return id; + } + + public static NBTType valueOf(int id) { + for (NBTType t : values()) + if (t.getId() == id) + return t; + return NBTType.NBTTagEnd; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/GsonWrapper.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/GsonWrapper.java new file mode 100644 index 00000000..77492633 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/GsonWrapper.java @@ -0,0 +1,27 @@ +package com.massivecraft.factions.zcore.nbtapi.utils; + +import com.google.gson.Gson; + +public class GsonWrapper { + + private static final Gson gson = new Gson(); + + public static String getString(Object obj) { + return gson.toJson(obj); + } + + public static T deserializeJson(String json, Class type) { + try { + if (json == null) { + return null; + } + + T obj = gson.fromJson(json, type); + return type.cast(obj); + } catch (Exception ex) { + ex.printStackTrace(); + return null; + } + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MethodNames.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MethodNames.java new file mode 100644 index 00000000..01686e24 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MethodNames.java @@ -0,0 +1,36 @@ +package com.massivecraft.factions.zcore.nbtapi.utils; + +public class MethodNames { + + private final static MinecraftVersion MINECRAFT_VERSION = MinecraftVersion.getVersion(); + + public static String getTileDataMethodName() { + if (MINECRAFT_VERSION == MinecraftVersion.MC1_8_R3) { + return "b"; + } + return "save"; + } + + public static String getTypeMethodName() { + if (MINECRAFT_VERSION == MinecraftVersion.MC1_8_R3) { + return "b"; + } + return "d"; + } + + public static String getEntityNbtGetterMethodName() { + return "b"; + } + + public static String getEntityNbtSetterMethodName() { + return "a"; + } + + public static String getRemoveMethodName() { + if (MINECRAFT_VERSION == MinecraftVersion.MC1_8_R3) { + return "a"; + } + return "remove"; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MinecraftVersion.java b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MinecraftVersion.java new file mode 100644 index 00000000..e4023eb2 --- /dev/null +++ b/src/main/java/com/massivecraft/factions/zcore/nbtapi/utils/MinecraftVersion.java @@ -0,0 +1,60 @@ +package com.massivecraft.factions.zcore.nbtapi.utils; + +import org.bukkit.Bukkit; + +public enum MinecraftVersion { + Unknown(0), + MC1_7_R4(174), + MC1_8_R3(183), + MC1_9_R1(191), + MC1_9_R2(192), + MC1_10_R1(1101), + MC1_11_R1(1111), + MC1_12_R1(1121); + + private static MinecraftVersion version; + private static Boolean hasGsonSupport; + + private final int versionId; + + MinecraftVersion(int versionId) { + this.versionId = versionId; + } + + public int getVersionId() { + return versionId; + } + + public static MinecraftVersion getVersion() { + if (version != null) { + return version; + } + final String ver = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3]; + System.out.println("[NBTAPI] Found Spigot: " + ver + "! Trying to find NMS support"); + try { + version = MinecraftVersion.valueOf(ver.replace("v", "MC")); + } catch (IllegalArgumentException ex) { + version = MinecraftVersion.Unknown; + } + if (version != Unknown) { + System.out.println("[NBTAPI] NMS support '" + version.name() + "' loaded!"); + } else { + System.out.println("[NBTAPI] Wasn't able to find NMS Support! Some functions will not work!"); + } + return version; + } + + public static boolean hasGsonSupport() { + if (hasGsonSupport != null) { + return hasGsonSupport; + } + try { + System.out.println("Found Gson: " + Class.forName("com.google.gson.Gson")); + hasGsonSupport = true; + } catch (Exception ex) { + hasGsonSupport = false; + } + return hasGsonSupport; + } + +} diff --git a/src/main/java/com/massivecraft/factions/zcore/persist/MemoryFaction.java b/src/main/java/com/massivecraft/factions/zcore/persist/MemoryFaction.java index 7ba1a7c2..a74e8149 100644 --- a/src/main/java/com/massivecraft/factions/zcore/persist/MemoryFaction.java +++ b/src/main/java/com/massivecraft/factions/zcore/persist/MemoryFaction.java @@ -28,8 +28,8 @@ import java.util.Map.Entry; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Level; -import static com.massivecraft.factions.zcore.util.InventoryUtil.InventoryToString; -import static com.massivecraft.factions.zcore.util.InventoryUtil.StringToInventory; +import static com.massivecraft.factions.util.InventoryUtil.InventoryToString; +import static com.massivecraft.factions.util.InventoryUtil.StringToInventory; public abstract class MemoryFaction implements Faction, EconomyParticipator { protected String id = null; diff --git a/src/main/java/com/massivecraft/factions/zcore/util/TL.java b/src/main/java/com/massivecraft/factions/zcore/util/TL.java index eb676ced..ceb95dc3 100644 --- a/src/main/java/com/massivecraft/factions/zcore/util/TL.java +++ b/src/main/java/com/massivecraft/factions/zcore/util/TL.java @@ -617,7 +617,7 @@ public enum TL { COMMAND_SHOW_NEEDFACTION("&cYou need to join a faction to view your own!"), COMMAND_SHOWCLAIMS_HEADER("&8&m-------------&8<{faction}'s claims&8>&8&m-------------"), - COMMAND_SHOWCLAIMS_FORMAT("&8[{world}]: {chunks}"), + COMMAND_SHOWCLAIMS_FORMAT("&8[{world}]:"), COMMAND_SHOWCLAIMS_CHUNKSFORMAT("&8(&c{x}&8,&c{z}&8)"), COMMAND_SHOWCLAIMS_DESCRIPTION("show your factions claims!"), diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml index c6115d21..835d9ba0 100644 --- a/src/main/resources/config.yml +++ b/src/main/resources/config.yml @@ -1,7 +1,8 @@ -# FactionsUUID by drtshock -# Report issues https://github.com/drtshock/Factions/issues?state=open -# Live support http://webchat.esper.net/?channels=factions&prompt=1 -# Website https://www.spigotmc.org/resources/factionsuuid.1035/ +# SavageFactions by ProSavage +# Report issues https://github.com/ProSavage/SavageFactions/issues/new +# Live support https://github.com/ProSavage/SavageFactions/issues/new +# Spigot Site: https://www.spigotmc.org/resources/savagefactions-factionsuuid-reimagined-1-7-1-12.52891/ +# Website: https://www.prosavage.net/ # Made with love <3 @@ -145,7 +146,7 @@ scoreboard: # {maxPower} - player's max power. # {powerBoost} - player's powerboost. - default-enabled: true # Default to false to keep original functionality. + default-enabled: false # Default to false to keep original functionality. default-title: "&cSavageFactions" # Can use any of the values from above but this won't update once it's set (so don't set {balance}). default-update-interval: 2 # in seconds. diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 305d9b7a..f6da4c37 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -1,5 +1,5 @@ name: Factions -version: ${project.version}-1.4-BETA-2 +version: ${project.version}-1.4-BETA-4 main: com.massivecraft.factions.P authors: [Olof Larsson, Brett Flannigan, drtshock, ProSavage] softdepend: [CoreProtect, PlayerVaults, PlaceholderAPI, MVdWPlaceholderAPI, PermissionsEx, Permissions, Essentials, EssentialsChat, HeroChat, iChat, LocalAreaChat, LWC, nChat, ChatManager, CAPI, AuthMe, Vault, Spout, WorldEdit, WorldGuard, AuthDB, CaptureThePoints, CombatTag, dynmap, FactionsTop]