From aa84ee03b5b89e4e726be0c508c2fb2eae05744a Mon Sep 17 00:00:00 2001 From: kaenganxt Date: Sun, 19 Oct 2014 18:10:52 +0200 Subject: [PATCH] Initial commit --- src/de/anura/core/API.java | 176 ++++ src/de/anura/core/AnuraCore.java | 1283 ++++++++++++++++++++++++ src/de/anura/core/BlockBreak.java | 60 ++ src/de/anura/core/BlockPlace.java | 44 + src/de/anura/core/BlockSpread.java | 25 + src/de/anura/core/CmdPreprocess.java | 34 + src/de/anura/core/EntityDamage.java | 25 + src/de/anura/core/EntityDamageByE.java | 32 + src/de/anura/core/Features.java | 169 ++++ src/de/anura/core/FlowerPots.java | 174 ++++ src/de/anura/core/FoodChange.java | 29 + src/de/anura/core/HangingEBreak.java | 37 + src/de/anura/core/ImgRenderer.java | 21 + src/de/anura/core/InvClick.java | 224 +++++ src/de/anura/core/LanguageSupport.java | 53 + src/de/anura/core/LeavesDecay.java | 32 + src/de/anura/core/MySQL.java | 204 ++++ src/de/anura/core/ParticleEffect.java | 257 +++++ src/de/anura/core/Permissions.java | 216 ++++ src/de/anura/core/PlayerChat.java | 25 + src/de/anura/core/PlayerInteract.java | 261 +++++ src/de/anura/core/PlayerInteractE.java | 60 ++ src/de/anura/core/PlayerJoin.java | 65 ++ src/de/anura/core/PlayerKick.java | 38 + src/de/anura/core/PlayerMove.java | 143 +++ src/de/anura/core/PlayerQuit.java | 21 + src/de/anura/core/PlayerTeleport.java | 49 + src/de/anura/core/ReflectionUtil.java | 158 +++ src/de/anura/core/SignChange.java | 137 +++ src/de/anura/core/Tools.java | 27 + src/de/anura/core/WeatherChange.java | 25 + src/plugin.yml | 72 ++ 32 files changed, 4176 insertions(+) create mode 100644 src/de/anura/core/API.java create mode 100644 src/de/anura/core/AnuraCore.java create mode 100644 src/de/anura/core/BlockBreak.java create mode 100644 src/de/anura/core/BlockPlace.java create mode 100644 src/de/anura/core/BlockSpread.java create mode 100644 src/de/anura/core/CmdPreprocess.java create mode 100644 src/de/anura/core/EntityDamage.java create mode 100644 src/de/anura/core/EntityDamageByE.java create mode 100644 src/de/anura/core/Features.java create mode 100644 src/de/anura/core/FlowerPots.java create mode 100644 src/de/anura/core/FoodChange.java create mode 100644 src/de/anura/core/HangingEBreak.java create mode 100644 src/de/anura/core/ImgRenderer.java create mode 100644 src/de/anura/core/InvClick.java create mode 100644 src/de/anura/core/LanguageSupport.java create mode 100644 src/de/anura/core/LeavesDecay.java create mode 100644 src/de/anura/core/MySQL.java create mode 100644 src/de/anura/core/ParticleEffect.java create mode 100644 src/de/anura/core/Permissions.java create mode 100644 src/de/anura/core/PlayerChat.java create mode 100644 src/de/anura/core/PlayerInteract.java create mode 100644 src/de/anura/core/PlayerInteractE.java create mode 100644 src/de/anura/core/PlayerJoin.java create mode 100644 src/de/anura/core/PlayerKick.java create mode 100644 src/de/anura/core/PlayerMove.java create mode 100644 src/de/anura/core/PlayerQuit.java create mode 100644 src/de/anura/core/PlayerTeleport.java create mode 100644 src/de/anura/core/ReflectionUtil.java create mode 100644 src/de/anura/core/SignChange.java create mode 100644 src/de/anura/core/Tools.java create mode 100644 src/de/anura/core/WeatherChange.java create mode 100644 src/plugin.yml diff --git a/src/de/anura/core/API.java b/src/de/anura/core/API.java new file mode 100644 index 0000000..bcec978 --- /dev/null +++ b/src/de/anura/core/API.java @@ -0,0 +1,176 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import org.bukkit.ChatColor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class API { + + /** + * Use this if you want to change the language + */ + public final static HashMap cachedPlayerLanguage = new HashMap<>(); + + /** + * Gets the current MySQL Object + * @return The working MySQL Object + */ + public static MySQL getMySql() + { + if(!AnuraCore.getSql().isValid) return null; + return AnuraCore.getSql(); + } + + /** + * Gets a language value for the given id and language + * @param id The language id as used in the translation center + * @param lang The short value of a language e.g. de, en + * @return Returns the text for this id + */ + public static String getl(String id, String lang) + { + String val = AnuraCore.getInstance().lang.get(id, lang); + if(val == null || val.equals("")) + { + val = AnuraCore.getInstance().lang.get(id, "en"); + } + return val; + } + + /** + * Gets a language value for the given id for a CommandSender + * @param id The language id as used in the translation center + * @param cs A command sender to automatically detect the language + * @return Returns the text for this id + */ + public static String getl(String id, CommandSender cs) + { + if(cs instanceof Player) + { + return API.getl(id, (Player)cs); + } + else + { + return API.getl(id, "en"); + } + } + + /** + * Gets a language value for the given id for a Player + * @param id The language id as used in the translation center + * @param P A player to use his language setting + * @return Returns the text for this id + */ + public static String getl(String id, Player P) + { + return API.getl(id, API.getPlayerLang(P)); + } + + /** + * Sends a translated and colored message to the given CommandSender + * @param P The CommandSender, whose language is being determined and the language is sended to + * @param id The language id as used in the translation center + * @param status The type of the message(true for green, false for red) + */ + public static void statusMsg(CommandSender P, String id, Boolean status) + { + ChatColor chatColor; + if(status) chatColor = ChatColor.GREEN; + else chatColor = ChatColor.RED; + P.sendMessage(ChatColor.GRAY + "[Anura] "+chatColor+API.getl(id, API.getPlayerLang(P))); + } + /** + * Sends a translated and colored message to the given CommandSender + * @param P The CommandSender, whose language is being determined and the language is sended to + * @param id The language id as used in the translation center + * @param color The color of the message + */ + public static void statusMsg(CommandSender P, String id, ChatColor color) + { + P.sendMessage(ChatColor.GRAY + "[Anura] "+color+API.getl(id, API.getPlayerLang(P))); + } + /** + * Returns the language of the given CommandSender + * @param P The CommandSender, whose language is being determined + * @return Returns the short language name of the player (like de or en) + */ + public static String getPlayerLang(CommandSender P) + { + if(!(P instanceof Player)) + { + return "en"; + } + Player p = (Player)P; + if(!API.cachedPlayerLanguage.containsKey(p)) + { + ResultSet rs = AnuraCore.sql.querySelect("SELECT lang FROM players WHERE uuid = '"+p.getUniqueId().toString()+"'"); + try { + rs.first(); + API.cachedPlayerLanguage.put(p, rs.getString("lang")); + return rs.getString("lang"); + } catch (SQLException ex) { + System.out.println("SQLException in getPlayerLang of API: "+ex.getLocalizedMessage()); + } + } + else + { + return API.cachedPlayerLanguage.get(p); + } + return "en"; + } + + /** + * Returns an extra set of tools + * @return Tools + */ + public static Tools getTools() + { + return AnuraCore.getInstance().tools; + } + + /** + * Returns the available Languages + * @return Returns an iterable set of strings like de or en + */ + public static Set getAvailLangs() + { + return AnuraCore.getInstance().lang.languages.keySet(); + } + + /** + * Get the Key by a given value from a given HashMap + * @param The type of the key in the map + * @param The type of the value in the map + * @param map The HashMap to get the key from + * @param value The value to use to get a key + * @return Returns the found key + */ + public static T getKeyByValue(Map map, E value) { + for (Map.Entry entry : map.entrySet()) { + if (value.equals(entry.getValue())) { + return entry.getKey(); + } + } + return null; + } + + /** + * Updates all lobby features for all players from the database + */ + public static void updateFeatures() { + AnuraCore.getInstance().getFeatures().updateFeaturesAll(); + } + + /** + * Updates all lobby features for the given player from the database + * @param P The player to update the features + */ + public static void updateFeatures(Player P) { + AnuraCore.getInstance().getFeatures().updateFeatures(P); + } +} diff --git a/src/de/anura/core/AnuraCore.java b/src/de/anura/core/AnuraCore.java new file mode 100644 index 0000000..b983f9d --- /dev/null +++ b/src/de/anura/core/AnuraCore.java @@ -0,0 +1,1283 @@ +package de.anura.core; + +import java.awt.Image; +import java.awt.image.BufferedImage; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.imageio.ImageIO; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.OfflinePlayer; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.BlockState; +import org.bukkit.block.CommandBlock; +import org.bukkit.block.Sign; +import org.bukkit.command.BlockCommandSender; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.map.MapRenderer; +import org.bukkit.map.MapView; +import org.bukkit.material.MaterialData; +import org.bukkit.material.Stairs; +import org.bukkit.plugin.java.JavaPlugin; +import org.bukkit.plugin.messaging.PluginMessageListener; +import org.bukkit.util.Vector; + +public class AnuraCore extends JavaPlugin implements PluginMessageListener { + + public static MySQL sql; + public HashMap selectableJumper = new HashMap<>(); + public HashMap permGroup = new HashMap<>(); + private static AnuraCore instance; + public HashMap sittingPlayer = new HashMap<>(); + public HashMap sittingBlocks = new HashMap<>(); + public HashMap warpCompasses = new HashMap<>(); + public static HashMap compassInvs = new HashMap<>(); + public static HashMap minigamesInvs = new HashMap<>(); + public static HashMap lobbyInvs = new HashMap<>(); + public HashMap doors = new HashMap<>(); + public ItemStack selLang = new ItemStack(Material.SIGN); + public Inventory selectLang = Bukkit.createInventory(null, 9, ChatColor.DARK_AQUA + "Choose a language"); + public LanguageSupport lang; + public HashMap flowerPots = new HashMap<>(); + public HashMap flowerPotsWait = new HashMap<>(); + public HashMap lastLoc = new HashMap<>(); + public FlowerPots pots; + public HashMap renderedImgs = new HashMap<>(); + public ArrayList stairMode = new ArrayList<>(); + public ArrayList sittableBlocks = new ArrayList<>(); + public HashMap golfPower = new HashMap<>(); + public HashMap releaseGolf = new HashMap<>(); + public HashMap golfBall = new HashMap<>(); + public HashMap disableCommandsAdventure = new HashMap<>(); + + private Features features; + @Override + public void onEnable() + { + AnuraCore.sql = new MySQL(this); + AnuraCore.instance = this; + if(AnuraCore.sql.isValid) + { + classes(); + this.lang = new LanguageSupport(this); + this.getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord"); + this.getServer().getMessenger().registerIncomingPluginChannel(this, "BungeeCord", this); + this.getConfig().addDefault("no-damage", false); + this.getConfig().addDefault("no-void-death",false); + this.getConfig().addDefault("no-change-blocks", false); + this.getConfig().addDefault("is-main-lobby", false); + this.getConfig().addDefault("no-hunger", false); + this.getConfig().addDefault("no-rain", false); + this.getConfig().addDefault("enable-leaves-decay", true); + this.getConfig().addDefault("server-name", "lobby"); + this.getConfig().addDefault("allow-stairs-sit", false); + this.getConfig().addDefault("disable-mushroom-spread", false); + this.getConfig().addDefault("on-join-to-spawn", false); + this.getConfig().addDefault("golf", false); + this.getConfig().options().copyDefaults(true); + this.getConfig().options().header("Config File of the Anura Core-Plugin:"); + sql.queryUpdate("DELETE FROM coreServers WHERE name = '"+this.getConfig().getString("server-name")+"'"); + sql.queryUpdate("INSERT INTO coreServers (name, maxPlayers) VALUES ('"+this.getConfig().getString("server-name")+"','"+this.getServer().getMaxPlayers()+"')"); + this.getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() { + @Override + public void run() { + AnuraCore.getInstance().updateServerSigns(); + } + }, 20*5, 20*5); + this.getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() { + + @Override + public void run() { + for(Player P : golfPower.keySet()) + { + if(releaseGolf.get(P)) + { + P.setExp(0); + int power = golfPower.get(P); + Entity i = golfBall.get(P); + if(i != null && i.isValid()) + { + Vector v = P.getLocation().getDirection(); + v.multiply(new Vector(power / 10 + 1,1.2,power / 10 + 1)); + i.setVelocity(v); + } + golfPower.remove(P); + releaseGolf.remove(P); + } + else + { + releaseGolf.put(P, true); + } + } + } + + }, 5, 5); + int i = 0; + for(String langu : lang.languages.keySet()) + { + Inventory inv = Bukkit.createInventory(null, 9, ChatColor.DARK_BLUE+lang.get("select_gamemode_inv", langu)); + AnuraCore.compassInvs.put(langu, inv); + ItemStack flower = new ItemStack(Material.RED_ROSE); + flower.setDurability((short)2); + ItemMeta flowerMeta = flower.getItemMeta(); + flowerMeta.setDisplayName(ChatColor.DARK_GREEN + "Lobby-Teleports"); + flower.setItemMeta(flowerMeta); + inv.setItem(0, flower); + ItemStack carrot = new ItemStack(Material.CARROT_STICK); + ItemMeta carrotMeta = carrot.getItemMeta(); + carrotMeta.setDisplayName(ChatColor.BLUE + "Minigames"); + carrot.setItemMeta(carrotMeta); + inv.setItem(2, carrot); + ItemStack pick = new ItemStack(Material.IRON_PICKAXE); + ItemMeta pickMeta = pick.getItemMeta(); + pickMeta.setDisplayName(ChatColor.GOLD + "Freebuild"); + pick.setItemMeta(pickMeta); + inv.setItem(4, pick); + + ItemStack ender = new ItemStack(Material.ENDER_PEARL); + ItemMeta enderMeta = ender.getItemMeta(); + enderMeta.setDisplayName(ChatColor.YELLOW + "Back"); + ender.setItemMeta(enderMeta); + + + Inventory minigames = Bukkit.createInventory(null, 9, ChatColor.DARK_BLUE+lang.get("minigames_inv",langu)); + AnuraCore.minigamesInvs.put(langu, minigames); + ItemStack bow = new ItemStack(Material.BOW); + ItemMeta bowMeta = bow.getItemMeta(); + bowMeta.setDisplayName(""+ChatColor.GREEN + ChatColor.BOLD + "Smash PVP"); + ArrayList bLores = new ArrayList<>(); + bLores.add(ChatColor.BLUE + lang.get("smash_description_1", langu)); + bLores.add(ChatColor.BLUE + lang.get("smash_description_2", langu)); + bLores.add(ChatColor.BLUE + lang.get("smash_description_3", langu)); + bLores.add(ChatColor.BLUE + lang.get("smash_description_4", langu)); + bLores.add(ChatColor.BLUE + lang.get("smash_description_5", langu)); + bLores.add(ChatColor.BLUE + lang.get("smash_description_6", langu)); + bowMeta.setLore(bLores); + bow.setItemMeta(bowMeta); + minigames.setItem(0, bow); + ItemStack wheat = new ItemStack(Material.WHEAT); + ItemMeta wheatMeta = wheat.getItemMeta(); + wheatMeta.setDisplayName(""+ChatColor.RED + "Coming Soon"); + wheat.setItemMeta(wheatMeta); + minigames.setItem(2, wheat); + ItemStack firework = new ItemStack(Material.FIREWORK); + ItemMeta fireworkMeta = firework.getItemMeta(); + fireworkMeta.setDisplayName(""+ChatColor.YELLOW + ChatColor.BOLD + "Rocket Match"); + ArrayList fLores = new ArrayList<>(); + fLores.add(ChatColor.RED + "Coming Soon"); + fireworkMeta.setLore(fLores); + firework.setItemMeta(fireworkMeta); + minigames.setItem(4, firework); + minigames.setItem(8, ender); + + ItemStack door = new ItemStack(Material.WOOD_DOOR); + ItemMeta doorMeta = door.getItemMeta(); + doorMeta.setDisplayName(""+ChatColor.BLUE + "Spawn"); + ArrayList dLores = new ArrayList<>(); + dLores.add(ChatColor.GOLD + lang.get("tp_to_spawn", langu)); + doorMeta.setLore(dLores); + door.setItemMeta(doorMeta); + doors.put(langu, door); + + Inventory lobby = Bukkit.createInventory(null, 9, ChatColor.DARK_BLUE+lang.get("lobby_inv",langu)); + AnuraCore.lobbyInvs.put(langu, lobby); + ItemStack slime = new ItemStack(Material.SLIME_BALL); + ItemMeta slimeMeta = slime.getItemMeta(); + slimeMeta.setDisplayName(ChatColor.DARK_GREEN + "Jump & Run"); + slime.setItemMeta(slimeMeta); + lobby.setItem(0, slime); + lobby.setItem(6, door); + ItemStack waterBucket = new ItemStack(Material.WATER_BUCKET); + ItemMeta waterMeta = waterBucket.getItemMeta(); + waterMeta.setDisplayName(ChatColor.DARK_BLUE + "Schwimmbad"); + waterBucket.setItemMeta(waterMeta); + lobby.setItem(3, waterBucket); + lobby.setItem(8, ender); + + + + ItemStack warpCompass = new ItemStack(Material.COMPASS); + ItemMeta compassMeta = warpCompass.getItemMeta(); + compassMeta.setDisplayName(ChatColor.DARK_AQUA + lang.get("select_game", langu)); + warpCompass.setItemMeta(compassMeta); + warpCompasses.put(langu, warpCompass); + ItemStack language = new ItemStack(Material.BOOK_AND_QUILL); + ItemMeta lMeta = language.getItemMeta(); + String langName = this.lang.languages.get(langu); + lMeta.setDisplayName(ChatColor.DARK_GREEN + langName); + ArrayList lores = new ArrayList<>(); + lores.add(ChatColor.GOLD + "Sets the language to "+langName); + lMeta.setLore(lores); + language.setItemMeta(lMeta); + this.selectLang.setItem(i, language); + i++; + + } + this.pots = new FlowerPots(); + ResultSet rs = sql.querySelect("SELECT id, X, Y, Z, world, type, waitTime FROM corePots"); + try { + while(rs.next()) + { + World w = this.getServer().getWorld(rs.getString("world")); + if(w == null) continue; + Location l = new Location(w, rs.getInt("X"), rs.getInt("Y"), rs.getInt("Z")); + this.flowerPots.put(rs.getInt("id"), l); + if (rs.getBoolean("type")) + { + this.flowerPotsWait.put(rs.getInt("id"), rs.getInt("waitTime")); + } + l.getBlock().setType(Material.BROWN_MUSHROOM); + } + rs = sql.querySelect("SELECT world, X, Y, Z FROM coreStairs WHERE server = '"+this.getConfig().getString("server-name")+"'"); + while(rs.next()) + { + World w = this.getServer().getWorld(rs.getString("world")); + if(w == null) continue; + Location l = new Location(w, rs.getInt("X"), rs.getInt("Y"), rs.getInt("Z")); + if(l.getBlock().getState().getData() instanceof Stairs) + { + this.sittableBlocks.add(l.getBlock()); + } + } + } catch (SQLException ex) { + Logger.getLogger(AnuraCore.class.getName()).log(Level.SEVERE, null, ex); + } + ItemMeta sMeta = this.selLang.getItemMeta(); + sMeta.setDisplayName(ChatColor.DARK_GREEN + "Language"); + this.selLang.setItemMeta(sMeta); + features = new Features(); + features.updateFeaturesAll(); + this.getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() { + + @Override + public void run() { + for(Player p : AnuraCore.getInstance().sittingPlayer.keySet()) + { + Location loc = AnuraCore.getInstance().sittingPlayer.get(p).getLocation(); + Arrow a = loc.getWorld().spawnArrow(loc, new Vector(0,0,0), 0, 0); + a.setPassenger(p); + AnuraCore.getInstance().sittingPlayer.get(p).remove(); + AnuraCore.getInstance().sittingPlayer.put(p, a); + } + } + + }, 600, 600); + } + else + { + Bukkit.getPluginManager().disablePlugin(this); + } + } + @Override + public void onDisable() + { + if(!AnuraCore.sql.isValid) + { + return; + } + File configFile = new File("plugins/Core/","config.yml"); + File dbFile = new File("plugins/Core","database.yml"); + try + { + AnuraCore.sql.config.save(dbFile); + this.getConfig().save(configFile); + } + catch(IOException e) + { } + sql.queryUpdate("DELETE FROM coreServers WHERE name = '"+this.getConfig().getString("server-name")+"'"); + features.reset(); + for(Player P : this.sittingPlayer.keySet()) + { + this.endSitting(P); + } + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String cmdLabel, String[] args) + { + Player P = null; + if(sender instanceof Player) + { + P = (Player)sender; + } + if(cmd.getName().equalsIgnoreCase("setcmd")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!sender.hasPermission("core.commands.editcmd")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length < 1) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + Block b = P.getTargetBlock(null, 100); + if(b.getType().equals(Material.COMMAND)) + { + String command = ""; + for(String arg : args) + { + if(!command.equals("")) + { + command += " "; + } + command += arg; + } + CommandBlock cb = (CommandBlock)b.getState(); + cb.setCommand(command); + cb.update(); + } + return true; + } + else if(cmd.getName().equalsIgnoreCase("updatecommandblocks")) + { + if(!(sender instanceof BlockCommandSender)) + { + API.getTools().sendStatusMsg(sender,"Only command block cmd!",false); + return true; + } + if(args.length % 3 != 0) return false; + for(int i = 0; i < args.length / 3; i++) + { + int x = Integer.parseInt(args[i]); + int y = Integer.parseInt(args[i+1]); + int z = Integer.parseInt(args[i+2]); + Location l = new Location(((BlockCommandSender)sender).getBlock().getWorld(), x, y, z); + if(!l.getBlock().getType().equals(Material.COMMAND)) continue; + l.getBlock().getState().update(); + } + return true; + } + else if(cmd.getName().equalsIgnoreCase("togglecommands")) + { + if(!(sender instanceof BlockCommandSender)) + { + API.getTools().sendStatusMsg(sender,"Only command block cmd!",false); + return true; + } + if(args.length != 2) return false; + String action = args[1]; + if(!action.equals("disable") && !action.equals("enable")) return true; + OfflinePlayer op = this.getServer().getOfflinePlayer(args[0]); + if(!op.isOnline()) return true; + Boolean b = action.equals("disable"); + this.disableCommandsAdventure.put(op.getPlayer(), b); + return true; + } + else if(cmd.getName().equalsIgnoreCase("addcmd")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!sender.hasPermission("core.commands.editcmd")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length != 1) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + Block b = P.getTargetBlock(null, 100); + if(b.getType().equals(Material.COMMAND)) + { + CommandBlock cb = (CommandBlock)b.getState(); + String command = ""; + for(String arg : args) + { + if(!command.equals("")) + { + command += " "; + } + command += arg; + } + command = cb.getCommand() + command; + cb.setCommand(command); + cb.update(); + } + return true; + } + else if(cmd.getName().equalsIgnoreCase("gm")) + { + String command = "gamemode "; + for(String arg : args) + { + command += arg+" "; + } + this.getServer().dispatchCommand(sender, command); + return true; + } + else if(cmd.getName().equalsIgnoreCase("clearArrows")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!sender.hasPermission("core.commands.cleararrows")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + for(Player pl : this.sittingPlayer.keySet()) + { + this.endSitting(pl); + } + for(Arrow a : P.getWorld().getEntitiesByClass(Arrow.class)) + { + a.remove(); + } + API.getTools().sendStatusMsg(sender, "Done!", true); + return true; + } + else if(cmd.getName().equalsIgnoreCase("stairmode")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!P.hasPermission("core.commands.stairmode")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(this.stairMode.contains(P)) this.stairMode.remove(P); + else this.stairMode.add(P); + API.getTools().sendStatusMsg(sender, "Done!", true); + return true; + } + else if(cmd.getName().equalsIgnoreCase("flowerpot")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!P.hasPermission("core.commands.flowerpot")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length != 1) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + Location l = P.getLocation(); + if(this.flowerPots.containsValue(l)) + { + API.statusMsg(sender, "set_arch_exists", false); + return true; + } + API.getMySql().queryUpdate("INSERT INTO corePots(X,Y,Z,world,url,name,money,type) VALUES('"+l.getBlockX()+"','"+l.getBlockY()+"','"+l.getBlockZ()+"','"+l.getWorld().getName()+"','http://mc-anura.de','"+args[0]+"','1','0')"); + ResultSet rs = API.getMySql().querySelect("SELECT id FROM corePots WHERE X = '"+l.getBlockX()+"' AND Y = '"+l.getBlockY()+"' AND Z = '"+l.getBlockZ()+"' AND world = '"+l.getWorld().getName()+"'"); + try { + rs.first(); + this.flowerPots.put(rs.getInt("id"), new Location(l.getWorld(),l.getBlockX(),l.getBlockY(),l.getBlockZ())); + l.getBlock().setType(Material.BROWN_MUSHROOM); + this.pots.refreshPot(rs.getInt("id")); + API.statusMsg(sender, "set_arch_ok", true); + return true; + } catch (SQLException ex) { + System.out.println("Error onCommand. Setpot"); + + } + } + else if(cmd.getName().equalsIgnoreCase("renderMap")) + { + if(!sender.hasPermission("core.commands.addmap")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length != 2) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + final CommandSender cs = sender; + final String url = args[0]; + final String name = args[1]; + API.getTools().sendStatusMsg(cs, "The rendering is starting...", true); + Bukkit.getScheduler().scheduleSyncDelayedTask(this, new Runnable() { + + @Override + public void run() { + try { + URI uri = URI.create(url); + URL locUrl = uri.toURL(); + BufferedImage imgSrc = ImageIO.read(locUrl.openStream()); + Image i = imgSrc.getScaledInstance(128, 128, Image.SCALE_SMOOTH); + BufferedImage imgScaled = new BufferedImage(128, 128, BufferedImage.TYPE_INT_ARGB); + imgScaled.getGraphics().drawImage(i, 0, 0 , null); + AnuraCore.getInstance().renderedImgs.put(name, imgScaled); + API.getTools().sendStatusMsg(cs, "The rendering has finished!", true); + } catch (MalformedURLException ex) { + API.getTools().sendStatusMsg(cs, "Please provide a valid image url!", false); + } catch (IOException ex) { + API.getTools().sendStatusMsg(cs, "Image rendering not working! Did you provide a valid url?", false); + } + } + + }, 1); + return true; + } + else if(cmd.getName().equalsIgnoreCase("addMap")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(!P.hasPermission("core.commands.addmap")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length != 1) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + if(!this.renderedImgs.containsKey(args[0])) + { + API.getTools().sendStatusMsg(sender, "The image with the given name does not exist or this not rendered yet.", true); + return true; + } + MapView mv = this.getServer().createMap(P.getWorld()); + for(MapRenderer mr : mv.getRenderers()) + { + mv.removeRenderer(mr); + } + mv.addRenderer(new ImgRenderer(args[0])); + P.setItemInHand(new ItemStack(Material.MAP, 0, mv.getId())); + API.statusMsg(sender, "addmap_done", true); + return true; + } + else if(cmd.getName().equalsIgnoreCase("hilfe")) + { + if(!cmdLabel.equals("hilfe") && !cmdLabel.equals("help") && !cmdLabel.equals("?")) + { + cmdLabel = "hilfe"; + } + if(sender.hasPermission("core.commands.help")) + { + sender.sendMessage(ChatColor.RED + "Achtung: "+ChatColor.YELLOW+"Die echte Hilfe gibts mit "+ChatColor.BLUE+"/?"+ChatColor.YELLOW+"!"); + } + if(args.length == 0) + { + sender.sendMessage(ChatColor.YELLOW+"-----------"+ChatColor.AQUA+"Hilfe"+ChatColor.YELLOW+"-----------"); + sender.sendMessage(ChatColor.GREEN+"Hilfe zu den Befehlen gibt es mit "+ChatColor.BLUE+"/"+cmdLabel+" commands"); + sender.sendMessage(ChatColor.GOLD+"Informationen zu unseren GameModes erhälst du mit "+ChatColor.BLUE+"/"+cmdLabel+" gamemodes"); + } + else if(args.length == 1) + { + if(args[0].equalsIgnoreCase("commands")) + { + sender.sendMessage(ChatColor.YELLOW+"-----------"+ChatColor.AQUA+"Befehle"+ChatColor.YELLOW+"-----------"); + sender.sendMessage(ChatColor.BLUE+"/lobby "+ChatColor.GREEN+"Bringt dich jederzeit zurück zur Lobby."); + sender.sendMessage(ChatColor.BLUE+"/spawn "+ChatColor.GOLD+"Teleportiert dich zum Spawn."); + sender.sendMessage(ChatColor.BLUE+"/money "+ChatColor.GREEN+"Zeigt dein Geld an."); + sender.sendMessage(ChatColor.RED+"Befehle für den Smash-Gamemode siehst du mit "+ChatColor.BLUE+"/"+cmdLabel+" commands smash"); + } + else if(args[0].equalsIgnoreCase("gamemodes")) + { + sender.sendMessage(ChatColor.YELLOW+"-----------"+ChatColor.AQUA+"Gamemodes"+ChatColor.YELLOW+"-----------"); + sender.sendMessage(ChatColor.GRAY+"----------"+ChatColor.GREEN+"Smash PvP"+ChatColor.GRAY+"-----------"); + sender.sendMessage(ChatColor.BLUE+"In Smash PvP geht es darum, mithilfe von verschiedenen Klassen deine "+ + "Gegner ins Wasser, in die Lava oder aus der Welt zu schlagen. "+ + "Du kannst verschiedenen Arenen beitreten. Es gibt keine Begrenzung, wie "+ + "lange du spielen kannst. Jeder Kill gibt dir Münzen. Stirbst du, verlierst du "+ + "eine Münze."); + sender.sendMessage(ChatColor.GOLD+"Mit "+ChatColor.RED+"/"+cmdLabel+" commands smash"+ChatColor.GOLD+" kannst du dir"); + sender.sendMessage(ChatColor.GOLD+"alle Befehle des Minigames anzeigen lassen."); + } + } + else if(args.length == 2) + { + if(args[0].equalsIgnoreCase("commands") && args[1].equalsIgnoreCase("smash")) + { + sender.sendMessage(ChatColor.YELLOW+"-----------"+ChatColor.AQUA+"Smash Befehle"+ChatColor.YELLOW+"-----------"); + sender.sendMessage(ChatColor.BLUE+"/join "+ChatColor.GREEN+"Hiermit kannst du einem Smash Game beitreten."); + sender.sendMessage(ChatColor.BLUE+"/leave "+ChatColor.GREEN+"Lässt dich ein Spiel verlassen."); + sender.sendMessage(ChatColor.BLUE+"/class "+ChatColor.GREEN+"Damit kannst du während eines Spiels die Klasse wechseln."); + sender.sendMessage(ChatColor.BLUE+"/classes "+ChatColor.GREEN+"Teleportiert dich in einen Raum, in dem du Klassen kaufen kannst."); + sender.sendMessage(ChatColor.BLUE+"/bug "+ChatColor.GREEN+"Wenn du einen Bug gefunden hast, kannst du ihn so reporten."); + } + } + return true; + } + //The day + else if(cmd.getName().equalsIgnoreCase("sun")) + { + if(P != null) + { + if(P.hasPermission("core.commands.sun")) + { + World w = P.getLocation().getWorld(); + w.setTime(2000); + w.setThundering(false); + w.setStorm(false); + this.tools.sendStatusMsg(sender, "Sun!", true); + return true; + } + } + } + else if(cmd.getName().equalsIgnoreCase("none")) + { + API.statusMsg(sender, "cmd_not_found", false); + return true; + } + else if(cmd.getName().equalsIgnoreCase("core")) + { + if(!sender.hasPermission("core.commands.core")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(args.length != 1) + { + API.statusMsg(sender,"wrong_args_count",false); + return false; + } + if((args[0].equalsIgnoreCase("reload") || args[0].equalsIgnoreCase("rl")) && sender.isOp()) + { + try { + this.getConfig().load(new File("plugins/Core/","config.yml")); + this.lang = new LanguageSupport(this); + API.statusMsg(sender,"config_rl_done",true); + } catch (IOException ex) { + API.statusMsg(sender,"config_rl_error_io",false); + } catch (InvalidConfigurationException ex) { + API.statusMsg(sender,"config_rl_invalid",false); + } + return true; + } + else if(args[0].equalsIgnoreCase("save") && sender.isOp()) + { + try { + this.getConfig().save(new File("plugins/Core/","config.yml")); + API.statusMsg(sender,"config_save",true); + } catch (IOException ex) { + API.statusMsg(sender,"config_save_io_err",false); + } + } + else if(args[0].equalsIgnoreCase("debugclosemysql") && sender.isOp()) + { + AnuraCore.sql.closeConnection(); + API.statusMsg(sender, "debug_mysql_closed", true); + return true; + } + } + else if(cmd.getName().equalsIgnoreCase("setjumper")) + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(args.length != 1) + { + return false; + } + if(!P.hasPermission("core.commands.setjumper")) + { + API.statusMsg(sender,"no_perms",false); + return true; + } + if(Double.valueOf(args[0]) > 10 || Double.valueOf(args[0]) < 0.2) + { + API.statusMsg(sender,"setjumper_wrong_number",false); + return true; + } + this.selectableJumper.put(P, Double.valueOf(args[0])); + sender.sendMessage(ChatColor.GRAY + "[Anura] " +ChatColor.GREEN +API.getl("setjumper_select_now",sender)+" "+Double.valueOf(args[0])+")"); + return true; + } + else if(cmd.getName().equalsIgnoreCase("spawn")) + { + if(args.length == 1) + { + if(sender.hasPermission("core.commands.spawn-other") || sender instanceof BlockCommandSender) + { + if(this.getServer().getOfflinePlayer(args[0]).isOnline()) + { + P = this.getServer().getPlayer(args[0]); + } + } + } + if(P == null) + { + API.statusMsg(sender, "only_player_cmd", false); + return true; + } + P.teleport(P.getLocation().getWorld().getSpawnLocation()); + API.statusMsg(P,"spawn_tp_done",true); + return true; + } + else if(cmd.getName().equalsIgnoreCase("setspawn")) + { + if(P != null && P.hasPermission("core.commands.setspawn")) + { + Location l = P.getLocation(); + l.getWorld().setSpawnLocation((int)l.getX(), (int)l.getY(), (int)l.getZ()); + API.statusMsg(P,"spawn_set",true); + return true; + } + } + else if(cmd.getName().equalsIgnoreCase("flyspeed")) + { + if(P == null) + { + API.statusMsg(sender, "only_player_cmd", false); + return true; + } + if(!P.hasPermission("core.commands.flyspeed")) + { + API.statusMsg(P, "no_perms", false); + return true; + } + if(args.length != 1) + { + return false; + } + if(Float.parseFloat(args[0]) >= 10 || Float.parseFloat(args[0]) < 0) + { + API.statusMsg(P, "flyspeed_wrong_number", false); + return true; + } + P.setFlySpeed(Float.parseFloat(args[0])/10); + tools.sendStatusMsg(P, API.getl("flyspeed_set_1", P)+" "+args[0]+API.getl("flyspeed_set_2", P), true); + return true; + } + else if(cmd.getName().equalsIgnoreCase("setwarp")) + { + try { + if(P == null) + { + API.statusMsg(sender, "only_player_cmd", false); + return true; + } + if(!P.hasPermission("core.commands.setwarp")) + { + API.statusMsg(P, "no_perms", false); + return true; + } + if(args.length < 1) + { + API.statusMsg(P, "wrong_args_count", false); + return false; + } + String userWarp = "0"; + if(args.length == 2) + { + if(args[1].equalsIgnoreCase("true")) userWarp = "1"; + } + Location loc = P.getLocation(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = this.getConfig().getString("server-name"); + String name = args[0]; + ResultSet rs = sql.querySelect("SELECT `name` FROM coreWarps WHERE name = '"+name+"'"); + rs.last(); + if(rs.getRow() != 0) + { + API.statusMsg(P, "warp_alr_exist", false); + return true; + } + sql.queryUpdate("INSERT INTO coreWarps(`name`, server, world, X, Y, Z, userWarp) VALUES('"+name+"', '"+server+"', '"+world+"', '"+X+"', '"+Y+"', '"+Z+"', '"+userWarp+"')"); + API.statusMsg(P, "warp_set", true); + return true; + } catch (SQLException ex) { + System.out.println("Error: "+ex.getLocalizedMessage()); + } + } + else if(cmd.getName().equalsIgnoreCase("remwarp")) + { + if(args.length != 1) + { + API.statusMsg(P, "wrong_args_count", false); + return false; + } + if(!sender.hasPermission("core.commands.remwarp")) + { + API.statusMsg(P, "no_perms", false); + return true; + } + String map = args[0]; + ResultSet rs = sql.querySelect("SELECT name FROM coreWarps WHERE name = '"+map+"'"); + try { + rs.last(); + if(rs.getRow() == 0) + { + API.statusMsg(P, "warp_not_exist", false); + return true; + } + sql.queryUpdate("DELETE FROM coreWarps WHERE name = '"+map+"'"); + API.statusMsg(P, "warp_rem_done", true); + return true; + } catch (SQLException ex) { + System.out.println("Error: "+ex.getLocalizedMessage()); + } + + } + else if(cmd.getName().equalsIgnoreCase("warp")) + { + try { + if(args.length == 0 || args.length > 2) + { + API.statusMsg(P, "wrong_args_count", false); + return false; + } + if(P == null) + { + if(args.length != 2) + { + API.statusMsg(P, "wrong_args_count", false); + return false; + } + + } + if(args.length == 2) + { + String p = args[1]; + if(!this.getServer().getOfflinePlayer(p).isOnline()) + { + API.statusMsg(P, "player_not_online", false); + return false; + } + P = this.getServer().getPlayer(p); + } + String warpName = args[0]; + ResultSet rs = sql.querySelect("SELECT world, X, Y, Z, userWarp, server FROM coreWarps WHERE name = '"+warpName+"'"); + rs.last(); + if(rs.getRow() == 0) + { + API.statusMsg(P, "warp_not_exist", false); + return true; + } + rs.first(); + if(P == null) return false; + if(!rs.getBoolean("userWarp") && !P.hasPermission("core.commands.adminWarp")) + { + API.statusMsg(P, "no_perms", false); + return true; + } + int X = rs.getInt("X"); + int Y = rs.getInt("Y"); + int Z = rs.getInt("Z"); + String server = rs.getString("server"); + String world = rs.getString("world"); + if(!server.equals(this.getConfig().getString("server-name"))) + { + API.statusMsg(P, "warp_other_server", false); + return true; + } + World w = this.getServer().getWorld(world); + if(w == null) + { + API.statusMsg(P, "warp_not_avail", false); + return true; + } + Location loc = new Location(this.getServer().getWorld(world), X, Y, Z); + P.teleport(loc); + API.statusMsg(P, "warp_tp_done", true); + return true; + } catch (SQLException ex) { + System.out.println("Error: "+ex.getLocalizedMessage()); + } + } + else if(cmd.getName().equalsIgnoreCase("money")) + { + try { + if(args.length == 0) + { + if(P == null) + { + tools.sendStatusMsg(sender,"only_player_cmd",false); + return true; + } + ResultSet rs = sql.querySelect("SELECT * FROM coreStats WHERE player = (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"')"); + rs.last(); + if(rs.getRow() == 1) + { + Integer money = rs.getInt("money"); + tools.sendStatusMsg(P,API.getl("you_have", P)+" "+money+" "+ API.getl("coins", P),true); + } + else + { + API.statusMsg(P,"unknown_error",true); + } + return true; + } + else if((args[0].equalsIgnoreCase("pay")) && (args.length == 3)) + { + Integer money = Integer.parseInt(args[2]); + boolean canPay; + Integer geld = 0; + if(sender.hasPermission("core.money.endless")) + { + if(P != null) + { + canPay = P.hasPermission("core.money.endless"); + } + else + { + canPay = true; + } + } + else + { + if(P == null) + { + API.statusMsg(sender,"only_player_cmd",false); + return true; + } + if(P.getName().equals(args[1])) + { + API.statusMsg(P,"money_pay_yourself",false); + return true; + } + if(!(money > 0)) + { + API.statusMsg(P,"number_must_positive",false); + return true; + } + ResultSet rs = sql.querySelect("SELECT * FROM coreStats WHERE player = (SELECT id FROM players WHERE uuid LIKE '"+P.getUniqueId().toString()+"')"); + rs.last(); + if(rs.getRow() == 1) + { + if(rs.getInt("money") < money) + { + API.statusMsg(P,"not_enough_money",false); + canPay = false; + } + else + { + geld = rs.getInt("money"); + canPay = true; + } + } + else + { + API.statusMsg(P,"unknown_error",false); + return true; + } + } + if(canPay) + { + OfflinePlayer oP = this.getServer().getOfflinePlayer(args[1]); + if(!oP.hasPlayedBefore() && !oP.isOnline()) + { + API.statusMsg(P, "never_seen_player", false); + return true; + } + ResultSet rs = sql.querySelect("SELECT * FROM coreStats WHERE player = (SELECT id FROM players WHERE uuid LIKE '"+oP.getUniqueId().toString()+"')"); + rs.last(); + if(rs.getRow() == 1) + { + sql.queryUpdate("UPDATE coreStats SET money = '"+(rs.getInt("money")+money)+"' WHERE player = (SELECT id FROM players WHERE uuid = '"+oP.getUniqueId().toString()+"')"); + if(P == null){} + else if(!P.hasPermission("core.money.endless")) + { + sql.queryUpdate("UPDATE coreStats SET money = '"+(geld-rs.getInt("money"))+"' WHERE player = (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"')"); + } + tools.sendStatusMsg(sender,API.getl("money_payed_1", sender)+" "+args[1]+" "+API.getl("money_payed_2", sender)+" "+args[2]+" "+API.getl("money_payed_3", sender),true); + if(oP.isOnline()) + { + tools.sendStatusMsg(oP.getPlayer(),API.getl("money_got_1", oP.getPlayer())+" "+args[2]+" "+API.getl("money_got_2", oP.getPlayer())+" "+sender.getName()+" "+API.getl("money_got_3", oP.getPlayer()),true); + } + return true; + } + else + { + API.statusMsg(sender,"never_seen_player", false); + return true; + } + } + else + { + return true; + } + + } + } catch(SQLException e) + { + API.statusMsg(sender,"unknown_error",true); + System.out.println("SQL-Exception!"); + } + } + return false; + } + public static AnuraCore getInstance() + { + return AnuraCore.instance; + } + public void updateServerSigns() + { + if(this.getServer().getOnlinePlayers().length == 0) return; + ResultSet rs = sql.querySelect("SELECT DISTINCT value FROM coreWarpSigns WHERE type = 'server' AND server = '"+this.getConfig().getString("server-name")+"'"); + try { + rs.last(); + if(rs.getRow() == 0) return; + rs.beforeFirst(); + while(rs.next()) + { + ByteArrayOutputStream b = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(b); + out.writeUTF("PlayerCount"); + out.writeUTF(rs.getString("value")); + Bukkit.getOnlinePlayers()[0].sendPluginMessage(this, "BungeeCord", b.toByteArray()); + ResultSet rs2 = sql.querySelect("SELECT maxPlayers FROM coreServers WHERE name = LOWER('"+rs.getString("value")+"')"); + rs2.last(); + Boolean online = true; + int maxPlayers = 0; + if(rs2.getRow() == 0) { + online = false; + } + else { + rs2.first(); + maxPlayers = rs2.getInt("maxPlayers"); + } + + rs2 = sql.querySelect("SELECT X,Y,Z,world,info FROM coreWarpSigns WHERE type = 'server' AND server = '"+this.getConfig().getString("server-name")+"' AND value = '"+rs.getString("value")+"'"); + rs2.last(); + if(rs2.getRow() == 0) continue; + rs2.beforeFirst(); + while(rs2.next()) + { + Boolean remove = false; + World w = this.getServer().getWorld(rs2.getString("world")); + BlockState bs = null; + if(w == null) remove = true; + else + { + Block bl = w.getBlockAt(rs2.getInt("X"), rs2.getInt("Y"), rs2.getInt("Z")); + if(bl== null || !(bl.getState() instanceof Sign)) remove = true; + else + { + bs = bl.getState(); + } + } + if(remove) + { + String anotherSQL = "DELETE FROM coreWarpSigns WHERE server = '"+this.getConfig().getString("server-name")+"' AND type = 'server' AND value = '"+rs.getString("value")+"'"; + sql.queryUpdate(anotherSQL); + continue; + } + if(bs == null) continue; + Sign s = (Sign)bs; + String rest = s.getLine(1).substring(0, s.getLine(1).length() - 2); + String info = rs2.getString("info"); + if(s.getLocation().getWorld().isChunkLoaded(s.getLocation().getBlockX()/16,s.getLocation().getBlockZ()/16)) + { + if(!online) + { + s.setLine(1, ChatColor.RED + "--"+ChatColor.DARK_GRAY+"/"+ChatColor.RED + "--"); + s.setLine(3, ChatColor.RED + "Offline"); + s.update(); + continue; + } + s.setLine(1, rest + maxPlayers); + s.setLine(3, info); + s.update(); + } + } + } + } catch (SQLException | IOException ex) { + System.err.println("Exception in updateServerSigns()(Core): "+ex.getLocalizedMessage()); + } + + } + public static MySQL getSql() + { + return AnuraCore.sql; + } + private void classes() + { + new PlayerJoin(this); + new PlayerMove(this); + new PlayerInteract(this); + new BlockBreak(this); + new BlockPlace(this); + new PlayerQuit(this); + new PlayerKick(this); + new PlayerChat(this); + new EntityDamage(this); + new WeatherChange(this); + new CmdPreprocess(this); + new HangingEBreak(this); + new FoodChange(this); + new LeavesDecay(this); + new EntityDamageByE(this); + new PlayerInteractE(this); + new SignChange(this); + new PlayerTeleport(this); + new InvClick(this); + new BlockSpread(this); + this.perms = new Permissions(this); + this.tools = new Tools(); + } + + public Permissions perms; + public Tools tools; + + @Override + public void onPluginMessageReceived(String channel, Player player, byte[] message) { + if (!channel.equals("BungeeCord")) { + return; + } + + DataInputStream in = new DataInputStream(new ByteArrayInputStream(message)); + + try { + String subchannel = in.readUTF(); + if(subchannel.equals("PlayerCount")) + { + String server = in.readUTF(); + int playercount = in.readInt(); + String sqlQ = "SELECT X,Y,Z,world FROM coreWarpSigns WHERE server = '"+this.getConfig().getString("server-name")+"' AND type = 'server' AND value = '"+server+"'"; + ResultSet rs = sql.querySelect(sqlQ); + rs.last(); + if(rs.getRow() == 0) return; + rs.beforeFirst(); + while(rs.next()) + { + Boolean remove = false; + World w = this.getServer().getWorld(rs.getString("world")); + BlockState bs = null; + if(w == null) remove = true; + else + { + Block b = w.getBlockAt(rs.getInt("X"), rs.getInt("Y"), rs.getInt("Z")); + if(b == null || !(b.getState() instanceof Sign)) remove = true; + else + { + bs = b.getState(); + } + } + if(remove) + { + String anotherSQL = "DELETE FROM coreWarpSigns WHERE server = '"+this.getConfig().getString("server-name")+"' AND type = 'server' AND value = '"+server+"'"; + sql.queryUpdate(anotherSQL); + continue; + } + if(bs == null) continue; + if(bs instanceof Sign) + { + Sign s = (Sign)bs; + if(s.getLine(3).equalsIgnoreCase(ChatColor.RED + "Offline")) + { + s.setLine(1, ChatColor.RED + "--"+ChatColor.DARK_GRAY+"/"+ChatColor.RED+"--"); + continue; + } + String maxplayers = s.getLine(1).substring(s.getLine(1).length()-2); + Boolean hasPlace = true; + if(maxplayers.equals("--")) hasPlace = true; + else if(Integer.parseInt(maxplayers) == playercount) hasPlace = false; + if(hasPlace) + { + s.setLine(1, ChatColor.GREEN + String.valueOf(playercount) + ChatColor.DARK_GRAY + "/" + ChatColor.GREEN+ maxplayers); + } + else + { + s.setLine(1, ChatColor.RED + String.valueOf(playercount) + ChatColor.DARK_GRAY + "/" + ChatColor.GREEN+ maxplayers); + } + s.update(); + } + } + } + else if(subchannel.equals("updatePermissions")) + { + this.perms.reload(); + this.perms.updateAllPlayers(); + } + } catch (IOException | SQLException ex) { + System.err.println("Exception in updateServerSigns()(Core): "+ex.getLocalizedMessage()); + } + } + public void endSitting(Player P) + { + if(this.sittingPlayer.containsKey(P)) + { + MaterialData md = this.sittingBlocks.get(P).getState().getData(); + if(md instanceof Stairs) + { + Stairs s = (Stairs)md; + Location loc = this.sittingBlocks.get(P).getRelative(s.getFacing()).getLocation(); + Entity a = (Entity)this.sittingPlayer.get(P); + P.teleport(loc); + a.remove(); + this.sittingPlayer.remove(P); + this.sittingBlocks.remove(P); + } + else + { + Location loc = this.sittingPlayer.get(P).getLocation(); + P.teleport(loc); + this.sittingPlayer.get(P).remove(); + this.sittingPlayer.remove(P); + this.sittingBlocks.remove(P); + } + } + } + public void openGameSelectWindow(Player P) + { + P.openInventory(AnuraCore.compassInvs.get(API.getPlayerLang(P))); + } + public boolean isInteger(String s) { + return isInteger(s,10); + } + + public boolean isInteger(String s, int radix) { + if(s.isEmpty()) return false; + for(int i = 0; i < s.length(); i++) { + if(i == 0 && s.charAt(i) == '-') { + if(s.length() == 1) return false; + else continue; + } + if(Character.digit(s.charAt(i),radix) < 0) return false; + } + return true; + } + + public Features getFeatures() { + return features; + } +} diff --git a/src/de/anura/core/BlockBreak.java b/src/de/anura/core/BlockBreak.java new file mode 100644 index 0000000..66a2361 --- /dev/null +++ b/src/de/anura/core/BlockBreak.java @@ -0,0 +1,60 @@ +package de.anura.core; + +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Sign; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.material.Stairs; + + +public class BlockBreak implements Listener +{ + public BlockBreak(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onBlockBreak(BlockBreakEvent event) + { + if(plugin.getConfig().getBoolean("no-change-blocks")) + { + if(!event.getPlayer().hasPermission("core.rules.blocks.break")) + { + event.setCancelled(true); + return; + } + } + if(plugin.flowerPots.containsValue(event.getBlock().getLocation())) event.setCancelled(true); + if((event.getBlock().getType() == Material.ENDER_CHEST || event.getBlock().getType() == Material.RAILS)) + { + int X = (int)event.getBlock().getLocation().getX(); + int Y = (int)event.getBlock().getLocation().getY(); + int Z = (int)event.getBlock().getLocation().getZ(); + String world = event.getBlock().getLocation().getWorld().getName(); + String sql = "DELETE FROM coreJumpers WHERE X = '"+X+"' AND Y = '"+Y+"' AND Z = '"+Z+"' AND world = '"+world+"'"; + AnuraCore.getSql().queryUpdate(sql); + } + else if(event.getBlock().getState() instanceof Sign) + { + Sign s = (Sign)event.getBlock().getState(); + Location loc = s.getLocation(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = plugin.getConfig().getString("server-name"); + AnuraCore.sql.queryUpdate("DELETE FROM coreWarpSigns WHERE X = '"+X+"' AND Y = '"+Y+"' AND Z = '"+Z+"' AND world = '"+world+"' AND server = '"+server+"'"); + } + else if(event.getBlock().getState().getData() instanceof Stairs) + { + if(plugin.sittingBlocks.containsValue(event.getBlock())) + { + event.setCancelled(true); + } + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/BlockPlace.java b/src/de/anura/core/BlockPlace.java new file mode 100644 index 0000000..dcbee15 --- /dev/null +++ b/src/de/anura/core/BlockPlace.java @@ -0,0 +1,44 @@ +package de.anura.core; + +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockPlaceEvent; + + +public class BlockPlace implements Listener +{ + public BlockPlace(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onBlockPlace(BlockPlaceEvent event) + { + if(plugin.getConfig().getBoolean("no-change-blocks")) + { + if(!event.getPlayer().hasPermission("core.rules.blocks.place")) + { + event.setCancelled(true); + } + } + if(plugin.flowerPots.containsValue(event.getBlock().getLocation())) + { + event.setCancelled(true); + final Block b = event.getBlock(); + final int pot = API.getKeyByValue(plugin.flowerPots, b.getLocation()); + plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + + @Override + public void run() { + b.setType(Material.BROWN_MUSHROOM); + AnuraCore.getInstance().pots.refreshPot(pot); + } + + }, 3); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/BlockSpread.java b/src/de/anura/core/BlockSpread.java new file mode 100644 index 0000000..8e602c7 --- /dev/null +++ b/src/de/anura/core/BlockSpread.java @@ -0,0 +1,25 @@ +package de.anura.core; + +import org.bukkit.Material; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockSpreadEvent; + +public class BlockSpread implements Listener +{ + public BlockSpread(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onBlockSpread(BlockSpreadEvent event) + { + if(event.getNewState().getType().equals(Material.BROWN_MUSHROOM) && plugin.getConfig().getBoolean("disable-mushroom-spread")) + { + event.setCancelled(true); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/CmdPreprocess.java b/src/de/anura/core/CmdPreprocess.java new file mode 100644 index 0000000..9b9c038 --- /dev/null +++ b/src/de/anura/core/CmdPreprocess.java @@ -0,0 +1,34 @@ +package de.anura.core; + +import org.bukkit.ChatColor; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; + +public class CmdPreprocess implements Listener +{ + public CmdPreprocess(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onCommandPreprocess(PlayerCommandPreprocessEvent event) + { + if(event.getMessage().startsWith("/?")) + { + if(!event.getPlayer().hasPermission("core.commands.help")) + { + event.setCancelled(true); + API.statusMsg(event.getPlayer(), "help_command_info", true); + } + } + else if(plugin.disableCommandsAdventure.containsKey(event.getPlayer()) && plugin.disableCommandsAdventure.get(event.getPlayer())) + { + event.setCancelled(true); + API.statusMsg(event.getPlayer(), "no_command_red_mg", ChatColor.YELLOW); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/EntityDamage.java b/src/de/anura/core/EntityDamage.java new file mode 100644 index 0000000..de85e91 --- /dev/null +++ b/src/de/anura/core/EntityDamage.java @@ -0,0 +1,25 @@ +package de.anura.core; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageEvent; + +public class EntityDamage implements Listener +{ + public EntityDamage(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onEntityDamage(EntityDamageEvent event) + { + if(event.getEntity() instanceof Player && plugin.getConfig().getBoolean("no-damage")) + { + event.setCancelled(true); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/EntityDamageByE.java b/src/de/anura/core/EntityDamageByE.java new file mode 100644 index 0000000..20afadf --- /dev/null +++ b/src/de/anura/core/EntityDamageByE.java @@ -0,0 +1,32 @@ +package de.anura.core; + +import org.bukkit.entity.ItemFrame; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; + +public class EntityDamageByE implements Listener +{ + public EntityDamageByE(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onEntityDamageByE(EntityDamageByEntityEvent event) + { + if(event.getEntity() instanceof ItemFrame && plugin.getConfig().getBoolean("no-change-blocks")) + { + if(event.getDamager() instanceof Player) + { + if(!((Player)event.getDamager()).hasPermission("core.rules.blocks.break")) + { + event.setCancelled(true); + } + } + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/Features.java b/src/de/anura/core/Features.java new file mode 100644 index 0000000..97c2790 --- /dev/null +++ b/src/de/anura/core/Features.java @@ -0,0 +1,169 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; +import org.bukkit.event.player.PlayerToggleFlightEvent; +import org.bukkit.util.Vector; + + +public class Features implements Listener { + + public enum Feature { + DOUBLE_JUMP(1); + private Feature(int id) { + this.featureId = id; + } + private final int featureId; + private static final HashMap BY_ID = new HashMap<>(); + public static Feature getById(Integer id) + { + return BY_ID.get(id); + } + static { + for (Feature feature : values()) { + BY_ID.put(feature.featureId, feature); + } + } + } + + public Features() + { + Bukkit.getPluginManager().registerEvents(this, AnuraCore.getInstance()); + } + + private final HashMap> playerFeatures = new HashMap<>(); + private final HashMap canDoubleJump = new HashMap<>(); + + public void updateFeatures(Player P) + { + if(!mainLobby()) return; + try { + ResultSet rs = API.getMySql().querySelect("SELECT featureId FROM coreFeatures WHERE playerId = (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"')"); + resetPlayerFeatures(P); + playerFeatures.put(P, new ArrayList()); + while(rs.next()) + { + if(Feature.getById(rs.getInt("featureId")) != null) + { + this.addFeature(P, Feature.getById(rs.getInt("featureId"))); + } + } + } catch (SQLException ex) { + System.err.println("Could not update player features because of a sql exception: "+ex.getLocalizedMessage()); + } + } + public void updateFeaturesAll() + { + if(!mainLobby()) return; + for(Player P : Bukkit.getOnlinePlayers()) + { + updateFeatures(P); + } + } + + public void reset() + { + for(Player P : Bukkit.getOnlinePlayers()) + { + this.resetPlayerFeatures(P); + } + } + + public boolean hasFeature(Player P, Feature f) + { + if(!mainLobby()) return false; + if(playerFeatures.containsKey(P)) + { + return playerFeatures.get(P).contains(f); + } + return false; + } + + private void resetPlayerFeatures(Player P) + { + if(!playerFeatures.containsKey(P)) return; + for(Feature f : (ArrayList)playerFeatures.get(P).clone()) + { + removeFeature(P, f); + } + } + + public void removeFeature(Player P, Feature f) + { + if(!mainLobby()) return; + if(playerFeatures.containsKey(P)) playerFeatures.get(P).remove(f); + if(f.equals(Feature.DOUBLE_JUMP)) + { + if(!P.getGameMode().equals(GameMode.CREATIVE)) + { + P.setAllowFlight(false); + P.setFoodLevel(20); + } + this.canDoubleJump.put(P, false); + } + } + + public void addFeature(Player P, Feature f) + { + if(!mainLobby()) return; + if(playerFeatures.containsKey(P) && !hasFeature(P, f)) playerFeatures.get(P).add(f); + if(f.equals(Feature.DOUBLE_JUMP)) + { + P.setAllowFlight(true); + this.canDoubleJump.put(P, true); + } + } + private boolean mainLobby() + { + return AnuraCore.getInstance().getConfig().getBoolean("is-main-lobby"); + } + + @EventHandler + public void onPlayerMove(PlayerMoveEvent event) + { + if(!mainLobby()) return; + Player P = event.getPlayer(); + if(this.hasFeature(P, Feature.DOUBLE_JUMP)) + { + if(this.canDoubleJump.containsKey(P) && !this.canDoubleJump.get(P) && ((Entity)P).isOnGround()) + { + this.canDoubleJump.put(P, true); + P.setFoodLevel(20); + } + } + } + + @EventHandler + public void onToggleFlight(PlayerToggleFlightEvent event) + { + if(!mainLobby()) return; + Player P = event.getPlayer(); + + if(this.hasFeature(P, Feature.DOUBLE_JUMP) && !P.getGameMode().equals(GameMode.CREATIVE)) + { + if(this.canDoubleJump.containsKey(P) && this.canDoubleJump.get(P)) + { + this.canDoubleJump.put(P, false); + P.setFoodLevel(1); + Vector v = P.getLocation().getDirection(); + P.setVelocity(v.multiply(new Vector(1,2,1))); + P.setVelocity(P.getVelocity().setY(1)); + } + else + { + Vector v = P.getVelocity(); + P.setVelocity(v.setY(-0.4)); + } + event.setCancelled(true); + } + } +} diff --git a/src/de/anura/core/FlowerPots.java b/src/de/anura/core/FlowerPots.java new file mode 100644 index 0000000..dacbb87 --- /dev/null +++ b/src/de/anura/core/FlowerPots.java @@ -0,0 +1,174 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Map; +import org.bukkit.ChatColor; +import org.bukkit.Effect; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.entity.Player; + + +public class FlowerPots { + private final HashMap> foundCache = new HashMap<>(); + private final HashMap> foundTimestamp = new HashMap<>(); + + public boolean foundPot(Player P, Integer pot) + { + if(!foundCache.containsKey(P)) refreshCache(P); + if(foundCache.get(P).containsKey(pot)) + { + if(foundCache.get(P).get(pot) && foundTimestamp.get(P).containsKey(pot)) + { + if((System.currentTimeMillis() / 1000 - foundTimestamp.get(P).get(pot)) >= getPotWaitTime(pot)) + { + return false; + } + } + return true; + } + return false; + } + + private int getPotWaitTime(Integer pot) + { + if (AnuraCore.getInstance().flowerPots.containsKey(pot)) + { + if (AnuraCore.getInstance().flowerPotsWait.containsKey(pot)) + { + return AnuraCore.getInstance().flowerPotsWait.get(pot); + } + return -1; + } + return 0; + } + + public void refreshCache(Player P) + { + try { + ResultSet rs = AnuraCore.getSql().querySelect("SELECT id, timestamp, type FROM coreFoundPots WHERE player = (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"')"); + HashMap list = new HashMap<>(); + HashMap listTimes = new HashMap<>(); + while(rs.next()) + { + list.put(rs.getInt("id"), rs.getBoolean("type")); + if(rs.getBoolean("type")) + { + listTimes.put(rs.getInt("id"), rs.getInt("timestamp")); + } + } + this.foundCache.put(P, list); + this.foundTimestamp.put(P, listTimes); + } catch (SQLException ex) { + System.out.println("Error refreshCache(FlowerPots)"); + } + } + + public void refreshPot(Integer pot) + { + Location l = AnuraCore.getInstance().flowerPots.get(pot); + for(Player P : l.getWorld().getPlayers()) + { + if(P.getLocation().distance(l) < 20) + { + refreshPlayerPot(P, pot, l); + } + } + } + + public void refreshPlayerPot(Player p, Integer pot, Location l) + { + if(!this.foundPot(p, pot)) + { + p.sendBlockChange(l, Material.FLOWER_POT, (byte)0); + } + else + { + p.sendBlockChange(l, Material.AIR, (byte)0); + } + } + + public void refreshPlayer(Player p) + { + for(Map.Entry pots : AnuraCore.getInstance().flowerPots.entrySet()) + { + if(pots.getValue().getWorld().equals(p.getLocation().getWorld()) && pots.getValue().distance(p.getLocation()) < 20) + { + refreshPlayerPot(p, pots.getKey(), pots.getValue()); + } + } + AnuraCore.getInstance().lastLoc.put(p, p.getLocation()); + } + + public void playerFoundPot(Player P, Integer pot) + { + if(!foundPot(P, pot)) + { + Integer time = getPotWaitTime(pot); + boolean alreadyFound = foundCache.get(P).containsKey(pot); + int type = 0; + if(time == -1) + { + foundCache.get(P).put(pot, false); + } + else + { + type = 1; + foundCache.get(P).put(pot, true); + foundTimestamp.get(P).put(pot, (int)(System.currentTimeMillis() / 1000)); + } + String sql; + if(alreadyFound) + { + sql = "UPDATE coreFoundPots SET timestamp = '"+(System.currentTimeMillis() / 1000)+"', type = 1 WHERE player = (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"')"; + } + else + { + sql = "INSERT INTO coreFoundPots(id, player, timestamp, type) VALUES('"+pot+"', (SELECT id FROM players WHERE uuid = '"+P.getUniqueId().toString()+"'),'"+(int) (System.currentTimeMillis() / 1000)+"','"+type+"')"; + } + AnuraCore.getSql().queryUpdate(sql); + Location loc = AnuraCore.getInstance().flowerPots.get(pot); + for(int i = 0; i < 20; i++) + { + loc.getWorld().playEffect(loc, Effect.FIREWORKS_SPARK, 4); + } + P.playSound(loc, Sound.LEVEL_UP, 1, (float)1.5); + ResultSet rs = AnuraCore.getSql().querySelect("SELECT url, name, money FROM corePots WHERE id = '"+pot+"'"); + try { + rs.first(); + AnuraCore.getSql().queryUpdate("UPDATE players SET money = money + '"+rs.getInt("money")+"' WHERE uuid = '"+P.getUniqueId().toString()+"'"); + P.sendMessage(ChatColor.RED + "---------- "+ChatColor.YELLOW + "Achievement"+ChatColor.RED+ " ----------"); + P.sendMessage(ChatColor.BLUE + rs.getString("name")); + P.sendMessage("" + ChatColor.GOLD + ChatColor.UNDERLINE + rs.getString("url")); + P.sendMessage(""); + P.sendMessage(ChatColor.RED + "---------- "+ChatColor.YELLOW + "Achievement"+ChatColor.RED+ " ----------"); + } catch (SQLException ex) { + System.out.println("Error playerFoundPot(FlowerPot)"); + } + } + else if(getPotWaitTime(pot) != -1 && foundCache.containsKey(P) && foundCache.get(P).containsKey(pot) && foundTimestamp.containsKey(P) && foundTimestamp.get(P).containsKey(pot)) + { + int current = (int)(System.currentTimeMillis() / 1000); + int found = foundTimestamp.get(P).get(pot); + int waitTime = getPotWaitTime(pot); + int toWait = (found + waitTime) - current; + if (toWait <= 0) return; + String text = ChatColor.RED + API.getl("ach_wait_1", P); + if (toWait < 60) { + text += " "+ChatColor.GREEN+toWait+" "+ChatColor.RED+API.getl("ach_wait_seconds", P); + } else if (toWait < 60*60) { + text += " "+ChatColor.GREEN+Math.round(toWait/60)+" "+ChatColor.RED+API.getl("ach_wait_minutes", P); + } else if (toWait < 60*60*24) { + text += " "+ChatColor.GREEN+Math.round(toWait/60/60)+" "+ChatColor.RED+API.getl("ach_wait_hours", P); + } else { + text += " "+ChatColor.GREEN+Math.round(toWait/60/60/24)+" "+ChatColor.RED+API.getl("ach_wait_days", P); + } + text += " "+API.getl("ach_wait_2", P); + + P.sendMessage(text); + } + } +} \ No newline at end of file diff --git a/src/de/anura/core/FoodChange.java b/src/de/anura/core/FoodChange.java new file mode 100644 index 0000000..1c0525b --- /dev/null +++ b/src/de/anura/core/FoodChange.java @@ -0,0 +1,29 @@ +package de.anura.core; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.FoodLevelChangeEvent; + + +public class FoodChange implements Listener +{ + public FoodChange(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onFoodLChange(FoodLevelChangeEvent event) + { + if(plugin.getConfig().getBoolean("no-hunger")) + { + if(event.getEntity() instanceof Player) + { + ((Player)event.getEntity()).setFoodLevel(20); + } + event.setCancelled(true); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/HangingEBreak.java b/src/de/anura/core/HangingEBreak.java new file mode 100644 index 0000000..b457d9b --- /dev/null +++ b/src/de/anura/core/HangingEBreak.java @@ -0,0 +1,37 @@ +package de.anura.core; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.hanging.HangingBreakByEntityEvent; + + +public class HangingEBreak implements Listener +{ + public HangingEBreak(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onHangingBreakByE(HangingBreakByEntityEvent event) + { + Player P; + if(event.getRemover() instanceof Player) + { + P = (Player)event.getRemover(); + } + else + { + return; + } + if(plugin.getConfig().getBoolean("no-change-blocks")) + { + if(!P.hasPermission("core.rules.blocks.break")) + { + event.setCancelled(true); + } + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/ImgRenderer.java b/src/de/anura/core/ImgRenderer.java new file mode 100644 index 0000000..8acfe36 --- /dev/null +++ b/src/de/anura/core/ImgRenderer.java @@ -0,0 +1,21 @@ + +package de.anura.core; + +import org.bukkit.entity.Player; +import org.bukkit.map.MapCanvas; +import org.bukkit.map.MapRenderer; +import org.bukkit.map.MapView; + +class ImgRenderer extends MapRenderer { + + private final String name; + public ImgRenderer(String name) { + this.name = name; + } + + @Override + public void render(MapView mv, MapCanvas mc, Player player) { + mc.drawImage(0, 0, AnuraCore.getInstance().renderedImgs.get(this.name)); + } + +} diff --git a/src/de/anura/core/InvClick.java b/src/de/anura/core/InvClick.java new file mode 100644 index 0000000..dbb46a7 --- /dev/null +++ b/src/de/anura/core/InvClick.java @@ -0,0 +1,224 @@ +package de.anura.core; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.PlayerInventory; + +public class InvClick implements Listener +{ + private final AnuraCore plugin; + public InvClick(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onInvClick(InventoryClickEvent event) + { + Player player = (Player) event.getWhoClicked(); + ItemStack clicked = event.getCurrentItem(); + Inventory inventory = event.getInventory(); + if(inventory.getName().equals(AnuraCore.minigamesInvs.get(API.getPlayerLang(player)).getName()) && clicked != null) + { + if(clicked.getType().equals(Material.BOW)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + try { + ByteArrayOutputStream b = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(b); + out.writeUTF("Connect"); + out.writeUTF("smash"); + player.sendPluginMessage(plugin, "BungeeCord", b.toByteArray()); + + } catch (IOException ex) { + } + } + else if(clicked.getType().equals(Material.WHEAT)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + plugin.tools.sendStatusMsg(player, "Coming Soon", false); + } + else if(clicked.getType().equals(Material.FIREWORK)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + plugin.tools.sendStatusMsg(player, "Coming Soon", false); + } + else if(clicked.getType().equals(Material.ENDER_PEARL)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.openInventory(AnuraCore.compassInvs.get(API.getPlayerLang(player))); + } + else + { + event.setCancelled(true); + final Player p = player; + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.setItemOnCursor(new ItemStack(Material.AIR)); + p.updateInventory(); + } + }, 1); + } + + } + else if(inventory.getName().equals(AnuraCore.compassInvs.get(API.getPlayerLang(player)).getName()) && clicked != null) + { + if(clicked.getType().equals(Material.RED_ROSE)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.openInventory(AnuraCore.lobbyInvs.get(API.getPlayerLang(player))); + } + + else if(clicked.getType().equals(Material.CARROT_STICK)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.openInventory(AnuraCore.minigamesInvs.get(API.getPlayerLang(player))); + } + else if(clicked.getType().equals(Material.IRON_PICKAXE)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + API.getTools().sendStatusMsg(player, "Coming Soon", false); + } + else + { + event.setCancelled(true); + final Player p = player; + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.setItemOnCursor(new ItemStack(Material.AIR)); + p.updateInventory(); + } + }, 1); + } + } + else if(inventory.getName().equals(AnuraCore.lobbyInvs.get(API.getPlayerLang(player)).getName()) && clicked != null) + { + if(clicked.getType().equals(Material.WATER_BUCKET)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.teleport(new Location(Bukkit.getWorld("lobby"), -288, 32, -1714)); + } + else if(clicked.getType().equals(Material.SLIME_BALL)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + plugin.getServer().dispatchCommand(player, "jumpinv"); + } + else if(clicked.getType().equals(Material.WOODEN_DOOR)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.teleport(player.getWorld().getSpawnLocation()); + } + else if(clicked.getType().equals(Material.ENDER_PEARL)) + { + event.setCancelled(true); + player.setItemOnCursor(new ItemStack(Material.AIR)); + player.updateInventory(); + player.closeInventory(); + player.openInventory(AnuraCore.compassInvs.get(API.getPlayerLang(player))); + } + else + { + event.setCancelled(true); + final Player p = player; + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.setItemOnCursor(new ItemStack(Material.AIR)); + p.updateInventory(); + } + }, 1); + } + } + else if(inventory.getName().equals(plugin.selectLang.getName()) && clicked != null) + { + if(clicked.getType().equals(Material.BOOK_AND_QUILL)) + { + String language = API.getKeyByValue(plugin.lang.languages, clicked.getItemMeta().getDisplayName().substring(2)); + event.setCancelled(true); + player.closeInventory(); + API.cachedPlayerLanguage.put(player,language); + AnuraCore.sql.queryUpdate("UPDATE players SET lang = '"+language+"' WHERE uuid = '"+player.getUniqueId().toString()+"'"); + PlayerInventory pi = player.getInventory(); + if(pi.getItem(0) != null) + { + pi.setItem(0, plugin.warpCompasses.get(language)); + } + if(pi.getItem(8) != null) + { + pi.setItem(8, plugin.doors.get(language)); + } + API.statusMsg(player, "lang_changed", true); + } + else + { + event.setCancelled(true); + final Player p = player; + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.setItemOnCursor(new ItemStack(Material.AIR)); + p.updateInventory(); + } + }, 1); + } + } + else if(!player.hasPermission("core.inventory.interact") && plugin.getConfig().getBoolean("is-main-lobby")) + { + event.setCancelled(true); + final Player p = player; + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.setItemOnCursor(new ItemStack(Material.AIR)); + p.updateInventory(); + } + }, 1); + } + } +} diff --git a/src/de/anura/core/LanguageSupport.java b/src/de/anura/core/LanguageSupport.java new file mode 100644 index 0000000..df21215 --- /dev/null +++ b/src/de/anura/core/LanguageSupport.java @@ -0,0 +1,53 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import org.bukkit.ChatColor; + +public class LanguageSupport +{ + private final AnuraCore plugin; + public HashMap languages = new HashMap<>(); + private HashMap> languageValues = new HashMap<>(); + + public LanguageSupport(AnuraCore plugin) + { + this.plugin = plugin; + ResultSet al = AnuraCore.sql.querySelect("SELECT name, short_name FROM coreAvailableLanguages"); + try { + if(!al.next()) return; + al.beforeFirst(); + String languageString = ""; + while(al.next()) + { + languages.put(al.getString("short_name"), al.getString("name")); + languageString += ", "+al.getString("short_name"); + languageValues.put(al.getString("short_name"), new HashMap()); + } + ResultSet lv = AnuraCore.sql.querySelect("SELECT id"+languageString+" FROM coreLanguages"); + while(lv.next()) + { + for(String lang : languages.keySet()) + { + languageValues.get(lang).put(lv.getString("id"), lv.getString(lang)); + } + } + } catch (SQLException ex) { + System.out.println("Language data could not be loaded: "+ex.getLocalizedMessage()); + } + } + public String get(String id, String lang) + { + String value; + if(languageValues.get(lang).containsKey(id)) + { + value = languageValues.get(lang).get(id); + } + else + { + value = id; + } + return ChatColor.translateAlternateColorCodes('&', value); + } +} \ No newline at end of file diff --git a/src/de/anura/core/LeavesDecay.java b/src/de/anura/core/LeavesDecay.java new file mode 100644 index 0000000..441b196 --- /dev/null +++ b/src/de/anura/core/LeavesDecay.java @@ -0,0 +1,32 @@ +package de.anura.core; + +import org.bukkit.block.Block; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.LeavesDecayEvent; + +public class LeavesDecay implements Listener +{ + public LeavesDecay(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onLeavesDecay(LeavesDecayEvent event) + { + if(!plugin.getConfig().getBoolean("enable-leaves-decay")) + { + Block b = event.getBlock(); + byte data = b.getData(); + if((data & 0x4) == 0) + { + data = (byte) (data | 0x4); + } + b.setData(data); + event.setCancelled(true); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/MySQL.java b/src/de/anura/core/MySQL.java new file mode 100644 index 0000000..548c265 --- /dev/null +++ b/src/de/anura/core/MySQL.java @@ -0,0 +1,204 @@ +package de.anura.core; + +import java.io.File; +import java.io.IOException; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; + +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; + +public class MySQL { + private final String host; + private final int port; + private final String username; + private final String pw; + private final String db; + private Connection conn; + public FileConfiguration config; + private final AnuraCore plugin; + public boolean isValid = true; + private boolean reconnecting = false; + public MySQL(AnuraCore plugin) + { + this.plugin = plugin; + File file = new File("plugins/Core/","database.yml"); + FileConfiguration cfg = YamlConfiguration.loadConfiguration(file); + String dbLoc = "database."; + cfg.addDefault(dbLoc+"host","localhost"); + cfg.addDefault(dbLoc+"port",3306); + cfg.addDefault(dbLoc+"username","username"); + cfg.addDefault(dbLoc+"pw","pw"); + cfg.addDefault(dbLoc+"db","db"); + cfg.options().copyDefaults(true); + try + { + cfg.save(file); + } + catch(IOException e) + {} + this.host = cfg.getString(dbLoc+"host"); + this.port = cfg.getInt(dbLoc+"port"); + this.username = cfg.getString(dbLoc+"username"); + this.pw = cfg.getString(dbLoc+"pw"); + this.db = cfg.getString(dbLoc+"db"); + if(!this.openConnection()) + { + Bukkit.broadcastMessage(ChatColor.RED + "No database connection available, please contact a server administrator!"); + this.isValid = false; + return; + } + this.config = cfg; + } + public String escapeString(String text) + { + return text; + } + private Boolean openConnection() { + try { + Class.forName("com.mysql.jdbc.Driver"); + Connection connLoc = DriverManager.getConnection("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.db, this.username, this.pw); + this.conn = connLoc; + return true; + } catch (ClassNotFoundException | SQLException e) { + return false; + } + } + private boolean hasConnection() { + try { + Boolean validConn = true; + if(this.conn == null) validConn = false; + else if(!this.conn.isValid(1)) validConn = false; + return validConn; + } catch (SQLException e) { + return false; + } + } + private Boolean reconnect() + { + if(this.reconnecting) + { + return false; + } + this.reconnecting = true; + System.out.println("Reconnecting..."); + Bukkit.broadcastMessage(ChatColor.YELLOW + "Bitte warten... Plugin-Daten werden geladen..."); + this.closeConnection(); + if(!this.openConnection()) + { + Bukkit.broadcastMessage(ChatColor.RED + "Database reconnect failed! Please contact a server administrator!"); + } + else System.out.println("Database reconnect successful!"); + this.reconnecting = false; + return true; + } + private void queryRedo(final String query, final String type) + { + if(!this.reconnect()) + { + this.plugin.getServer().getScheduler().scheduleSyncDelayedTask(this.plugin, new Runnable() { + @Override + public void run() { + switch (type) { + case "update": + AnuraCore.sql.queryUpdate(query); + break; + case "select": + AnuraCore.sql.querySelect(query); + break; + } + } + }, 4); + } + } + public void queryUpdate(String query) + { + if(!this.hasConnection()) + { + queryRedo(query, "update"); + } + Connection connLoc = this.conn; + PreparedStatement st = null; + try { + st = connLoc.prepareStatement(query); + st.executeUpdate(); + } catch (SQLException e) { + System.err.println("Failed to send Update '" +query+"'! ("+e.getLocalizedMessage()+")"); + } + this.closeRessources(null, st); + } + public ResultSet querySelect(final String query) + { + if(!this.hasConnection()) + { + queryRedo(query, "select"); + return null; + } + try { + PreparedStatement st = this.conn.prepareStatement(query); + ResultSet returns = this.querySelect(st); + if(returns == null) + { + queryRedo(query, "select"); + } + else + { + return returns; + } + } + catch(SQLException e) + { + System.err.println("Unknown error whilst trying to build Prepared Statement!"); + queryRedo(query, "select"); + } + return null; + } + private ResultSet querySelect(PreparedStatement st) + { + if(!this.hasConnection()) + { + return null; + } + ResultSet rs; + try { + rs = st.executeQuery(); + } + catch(SQLException e) + { + System.err.println("Failed to send 'SELECT'-Query!("+st.toString()+") Will try to reconnect to database just in case... you know..."); + System.err.println("Caused by: "+e.getMessage()); + return null; + } + return rs; + } + private void closeRessources(ResultSet rs, PreparedStatement st) { + if(rs != null) { + try { + rs.close(); + } catch (SQLException e) { + + } + } + if(st != null) { + try { + st.close(); + } catch (SQLException e) { + + } + } + } + public void closeConnection() { + try { + if(this.conn != null) this.conn.close(); + } catch (SQLException e) {} + finally + { + this.conn = null; + } + } +} \ No newline at end of file diff --git a/src/de/anura/core/ParticleEffect.java b/src/de/anura/core/ParticleEffect.java new file mode 100644 index 0000000..d687fac --- /dev/null +++ b/src/de/anura/core/ParticleEffect.java @@ -0,0 +1,257 @@ +package de.anura.core; + +import de.anura.core.ReflectionUtil.DynamicPackage; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.logging.Level; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +/** + * ParticleEffect Library v1.3 + * + * This library was created by @DarkBlade12 based on content related to particles of @microgeek (names and packet values), it allows you to display all Minecraft particle effects on a Bukkit server + * + * You are welcome to use it, modify it and redistribute it under the following conditions: + * 1. Don't claim this class as your own + * 2. Don't remove this text + * + * (Would be nice if you provide credit to me) + * + * @author DarkBlade12 + */ +public enum ParticleEffect { + HUGE_EXPLOSION("hugeexplosion", 0), + LARGE_EXPLODE("largeexplode", 1), + FIREWORKS_SPARK("fireworksSpark", 2), + BUBBLE("bubble", 3), + SUSPEND("suspend", 4), + DEPTH_SUSPEND("depthSuspend", 5), + TOWN_AURA("townaura", 6), + CRIT("crit", 7), + MAGIC_CRIT("magicCrit", 8), + MOB_SPELL("mobSpell", 9), + MOB_SPELL_AMBIENT("mobSpellAmbient", 10), + SPELL("spell", 11), + INSTANT_SPELL("instantSpell", 12), + WITCH_MAGIC("witchMagic", 13), + NOTE("note", 14), + PORTAL("portal", 15), + ENCHANTMENT_TABLE("enchantmenttable", 16), + EXPLODE("explode", 17), + FLAME("flame", 18), + LAVA("lava", 19), + FOOTSTEP("footstep", 20), + SPLASH("splash", 21), + LARGE_SMOKE("largesmoke", 22), + CLOUD("cloud", 23), + RED_DUST("reddust", 24), + SNOWBALL_POOF("snowballpoof", 25), + DRIP_WATER("dripWater", 26), + DRIP_LAVA("dripLava", 27), + SNOW_SHOVEL("snowshovel", 28), + SLIME("slime", 29), + HEART("heart", 30), + ANGRY_VILLAGER("angryVillager", 31), + HAPPY_VILLAGER("happyVillager", 32); + + private static final Map NAME_MAP = new HashMap<>(); + private static final Map ID_MAP = new HashMap<>(); + private static final double MAX_RANGE = 20.0D; + private static Constructor PARTICLE_PACKET_CONSTRUCTOR; + + static { + for (ParticleEffect effect : values()) { + NAME_MAP.put(effect.name, effect); + ID_MAP.put(effect.id, effect); + } + try { + PARTICLE_PACKET_CONSTRUCTOR = ReflectionUtil.getConstructor(ReflectionUtil.getClass("PacketPlayOutWorldParticles", DynamicPackage.MINECRAFT_SERVER), String.class, float.class, float.class, + float.class, float.class, float.class, float.class, float.class, int.class); + } catch (Exception e) { + System.out.println(e.getStackTrace()); + } + } + + private String name; + private int id; + + ParticleEffect(String name, int id) { + this.name = name; + this.id = id; + } + + public String getName() { + return name; + } + + public int getId() { + return id; + } + + public static ParticleEffect fromName(String name) { + if (name != null) + for (Entry e : NAME_MAP.entrySet()) + if (e.getKey().equalsIgnoreCase(name)) + return e.getValue(); + return null; + } + + public static ParticleEffect fromId(int id) { + return ID_MAP.get(id); + } + + private static List getPlayersInRange(Location loc, double range) { + List players = new ArrayList<>(); + double sqr = range * range; + for (Player p : loc.getWorld().getPlayers()) + if (p.getLocation().distanceSquared(loc) <= sqr) + players.add(p); + return players; + } + + private static Object createPacket(String name, Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + if (amount <= 0) + throw new IllegalArgumentException("Amount of particles has to be greater than 0"); + try { + Object p = PARTICLE_PACKET_CONSTRUCTOR.newInstance(name, (float) loc.getX(), (float) loc.getY(), (float) loc.getZ(), offsetX, offsetY, offsetZ, speed, amount); + return p; + } catch (IllegalAccessException | IllegalArgumentException | InstantiationException | InvocationTargetException e) { + Bukkit.getLogger().warning("[ParticleEffect] Failed to create a particle packet!"); + return null; + } + } + + private Object createPacket(Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + return createPacket(this.getName(), loc, offsetX, offsetY, offsetZ, speed, amount); + } + + private static Object createIconCrackPacket(int id, Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + return createPacket("iconcrack_" + id, loc, offsetX, offsetY, offsetZ, speed, amount); + } + + private static Object createBlockCrackPacket(int id, byte data, Location loc, float offsetX, float offsetY, float offsetZ, int amount) { + return createPacket("blockcrack_" + id + "_" + data, loc, offsetX, offsetY, offsetZ, 1.0F, amount); + } + + private static Object createBlockDustPacket(int id, byte data, Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + return createPacket("blockdust_" + id + "_" + data, loc, offsetX, offsetY, offsetZ, speed, amount); + } + + private static void sendPacket(Player p, Object packet) { + if (packet != null) + try { + Object entityPlayer = ReflectionUtil.invokeMethod("getHandle", p.getClass(), p); + Object playerConnection = ReflectionUtil.getValue("playerConnection", entityPlayer); + ReflectionUtil.invokeMethod("sendPacket", playerConnection.getClass(), playerConnection, packet); + } catch (Exception e) { + Bukkit.getLogger().log(Level.WARNING, "[ParticleEffect] Failed to send a particle packet to {0}!", p.getName()); + } + } + + private static void sendPacket(Collection players, Object packet) { + for (Player p : players) + sendPacket(p, packet); + } + + /** + * Displays a particle effect which is only visible for specific players + */ + public void display(Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount, Player... players) { + sendPacket(Arrays.asList(players), createPacket(loc, offsetX, offsetY, offsetZ, speed, amount)); + } + + /** + * Displays a particle effect which is visible for all players whitin the maximum range of 20 blocks in the world of @param loc + */ + public void display(Location loc, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + display(loc, MAX_RANGE, offsetX, offsetY, offsetZ, speed, amount); + } + + /** + * Displays a particle effect which is visible for all players whitin a certain range in the the world of @param loc + */ + public void display(Location loc, double range, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + if (range > MAX_RANGE) + throw new IllegalArgumentException("Range has to be lower/equal the maximum of 20"); + sendPacket(getPlayersInRange(loc, range), createPacket(loc, offsetX, offsetY, offsetZ, speed, amount)); + } + + /** + * Displays an icon crack (item break) effect which is only visible for specific players + */ + public static void displayIconCrack(Location loc, int id, float offsetX, float offsetY, float offsetZ, float speed, int amount, Player... players) { + sendPacket(Arrays.asList(players), createIconCrackPacket(id, loc, offsetX, offsetY, offsetZ, speed, amount)); + } + + /** + * Displays an icon crack (item break) effect which is visible for all players whitin the maximum range of 20 blocks in the world of @param loc + */ + public static void displayIconCrack(Location loc, int id, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + displayIconCrack(loc, MAX_RANGE, id, offsetX, offsetY, offsetZ, speed, amount); + } + + /** + * Displays an icon crack (item break) effect which is visible for all players whitin a certain range in the the world of @param loc + */ + public static void displayIconCrack(Location loc, double range, int id, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + if (range > MAX_RANGE) + throw new IllegalArgumentException("Range has to be lower/equal the maximum of 20"); + sendPacket(getPlayersInRange(loc, range), createIconCrackPacket(id, loc, offsetX, offsetY, offsetZ, speed, amount)); + } + + /** + * Displays a block crack (block break) effect which is only visible for specific players + */ + public static void displayBlockCrack(Location loc, int id, byte data, float offsetX, float offsetY, float offsetZ, int amount, Player... players) { + sendPacket(Arrays.asList(players), createBlockCrackPacket(id, data, loc, offsetX, offsetY, offsetZ, amount)); + } + + /** + * Displays a block crack (block break) effect which is visible for all players whitin the maximum range of 20 blocks in the world of @param loc + */ + public static void displayBlockCrack(Location loc, int id, byte data, float offsetX, float offsetY, float offsetZ, int amount) { + displayBlockCrack(loc, MAX_RANGE, id, data, offsetX, offsetY, offsetZ, amount); + } + + /** + * Displays a block crack (block break) effect which is visible for all players whitin a certain range in the the world of @param loc + */ + public static void displayBlockCrack(Location loc, double range, int id, byte data, float offsetX, float offsetY, float offsetZ, int amount) { + if (range > MAX_RANGE) + throw new IllegalArgumentException("Range has to be lower/equal the maximum of 20"); + sendPacket(getPlayersInRange(loc, range), createBlockCrackPacket(id, data, loc, offsetX, offsetY, offsetZ, amount)); + } + + /** + * Displays a block dust effect which is only visible for specific players + */ + public static void displayBlockDust(Location loc, int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Player... players) { + sendPacket(Arrays.asList(players), createBlockDustPacket(id, data, loc, offsetX, offsetY, offsetZ, speed, amount)); + } + + /** + * Displays a block dust effect which is visible for all players whitin the maximum range of 20 blocks in the world of @param loc + */ + public static void displayBlockDust(Location loc, int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + displayBlockDust(loc, MAX_RANGE, id, data, offsetX, offsetY, offsetZ, speed, amount); + } + + /** + * Displays a block dust effect which is visible for all players whitin a certain range in the the world of @param loc + */ + public static void displayBlockDust(Location loc, double range, int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount) { + if (range > MAX_RANGE) + throw new IllegalArgumentException("Range has to be lower/equal the maximum of 20"); + sendPacket(getPlayersInRange(loc, range), createBlockDustPacket(id, data, loc, offsetX, offsetY, offsetZ, speed, amount)); + } +} \ No newline at end of file diff --git a/src/de/anura/core/Permissions.java b/src/de/anura/core/Permissions.java new file mode 100644 index 0000000..485c7e4 --- /dev/null +++ b/src/de/anura/core/Permissions.java @@ -0,0 +1,216 @@ + +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.UUID; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerKickEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.permissions.PermissionAttachment; + +public final class Permissions implements Listener { + + private final HashMap groupNames = new HashMap<>(); + private final HashMap> groupPerms = new HashMap<>(); + private final HashMap> playerGroups = new HashMap<>(); + private final HashMap groupParents = new HashMap<>(); + private final HashMap groupPrefix = new HashMap<>(); + private final HashMap groupSuffix = new HashMap<>(); + private final HashMap groupListColor = new HashMap<>(); + private final HashMap permAttachments = new HashMap<>(); + + private int groupAutoIncrement = 0; + private final AnuraCore plugin; + + public Permissions(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.reload(); + this.plugin = plugin; + this.createPermAttachs(); + this.updateAllPlayers(); + } + + //Event handlers + @EventHandler + public void playerJoin(PlayerJoinEvent event) + { + Player P = event.getPlayer(); + this.permAttachments.put(P, P.addAttachment(this.plugin)); + this.updatePlayer(P); + } + + @EventHandler + public void playerKick(PlayerKickEvent event) + { + Player P = event.getPlayer(); + if(this.permAttachments.get(P) == null) return; + P.removeAttachment(this.permAttachments.get(P)); + this.permAttachments.remove(P); + } + + @EventHandler + public void playerQuit(PlayerQuitEvent event) + { + Player P = event.getPlayer(); + if(this.permAttachments.get(P) == null) return; + P.removeAttachment(this.permAttachments.get(P)); + this.permAttachments.remove(P); + } + + //The permission stuff + private void createPermAttachs() + { + for(Player P : Bukkit.getOnlinePlayers()) + { + this.permAttachments.put(P, P.addAttachment(this.plugin)); + } + } + public void updateAllPlayers() + { + for(Player P : Bukkit.getOnlinePlayers()) + { + this.updatePlayer(P); + } + } + public void updatePlayer(Player P) + { + PermissionAttachment pa = this.permAttachments.get(P); + for(String p : pa.getPermissions().keySet()) + { + pa.unsetPermission(p); + } + if(!this.playerGroups.containsKey(P.getUniqueId())) + { + this.playerGroups.put(P.getUniqueId(), new ArrayList()); + } + ArrayList groups = this.playerGroups.get(P.getUniqueId()); + ArrayList assignedGroups = new ArrayList<>(); + String prefixes = ""; + String suffixes = ""; + String listColor = ""; + for(Integer g : groups) + { + if(assignedGroups.contains(g)) continue; + assignedGroups.add(g); + for(String perm : this.groupPerms.get(g)) + { + pa.setPermission(perm, true); + } + ArrayList perms = this.getParentPerms(g, assignedGroups); + for(String perm : perms) + { + pa.setPermission(perm, true); + } + if(this.groupPrefix.containsKey(g)) prefixes += this.groupPrefix.get(g); + if(this.groupSuffix.containsKey(g)) suffixes += this.groupSuffix.get(g); + if(this.groupListColor.containsKey(g)) listColor = this.groupListColor.get(g); + } + String name = prefixes + P.getName() + suffixes; + P.setDisplayName(name); + P.setPlayerListName(listColor + P.getName()); + } + private ArrayList getParentPerms(Integer group, ArrayList assigned) + { + ArrayList toReturn = new ArrayList<>(); + if(this.groupParents.get(group) == -1) + { + return toReturn; + } + if(assigned.contains(this.groupParents.get(group))) + { + return toReturn; + } + for(String perm : this.groupPerms.get(this.groupParents.get(group))) + { + toReturn.add(perm); + } + for(String perm : this.getParentPerms(this.groupParents.get(group), assigned)) + { + toReturn.add(perm); + } + return toReturn; + } + public String reload() + { + ResultSet groupsRs = AnuraCore.sql.querySelect("SELECT prefix, suffix, parent, name, id, listColor FROM permGroups"); + ResultSet permsRs = AnuraCore.sql.querySelect("SELECT `group`, name FROM permPerms"); + ResultSet userRs = AnuraCore.sql.querySelect("SELECT playerUUID, `group` FROM permPlayerGroups"); + this.groupNames.clear(); + this.groupPerms.clear(); + this.playerGroups.clear(); + this.groupParents.clear(); + this.groupPrefix.clear(); + this.groupSuffix.clear(); + HashMap groupIds = new HashMap<>(); + this.groupAutoIncrement = 0; + try { + groupsRs.last(); + if(groupsRs.getRow() != 0) + { + groupsRs.beforeFirst(); + while(groupsRs.next()) + { + int id = this.groupAutoIncrement; + this.groupNames.put(id, groupsRs.getString("name")); + this.groupPerms.put(id, new ArrayList()); + this.groupParents.put(id, groupsRs.getInt("parent")); + if(groupsRs.getString("prefix") != null) this.groupPrefix.put(id, groupsRs.getString("prefix")); + if(groupsRs.getString("suffix") != null) this.groupSuffix.put(id, groupsRs.getString("suffix")); + if(groupsRs.getString("listColor") != null) this.groupListColor.put(id, groupsRs.getString("listColor")); + groupIds.put(groupsRs.getInt("id"), id); + this.groupAutoIncrement++; + } + } + permsRs.last(); + if(permsRs.getRow() != 0) + { + permsRs.beforeFirst(); + while(permsRs.next()) + { + int groupId = groupIds.get(permsRs.getInt("group")); + if(this.groupNames.containsKey(groupId)) + { + + this.groupPerms.get(groupId).add(permsRs.getString("name")); + } + } + } + userRs.last(); + if(userRs.getRow() != 0) + { + userRs.beforeFirst(); + while(userRs.next()) + { + int groupId = groupIds.get(userRs.getInt("group")); + if(this.groupNames.containsKey(groupId)) + { + ArrayList groupList = this.playerGroups.get(UUID.fromString(userRs.getString("playerUUID"))); + if(groupList == null) + { + groupList = new ArrayList<>(); + } + groupList.add(groupId); + this.playerGroups.put(UUID.fromString(userRs.getString("playerUUID")), groupList); + } + } + + } + } catch (SQLException ex) { + System.err.println("Was not able to load permissions. Sorry. ("+ex.getLocalizedMessage()+")"); + } + return ChatColor.GREEN + "Permissions reloaded!"; + } + + +} diff --git a/src/de/anura/core/PlayerChat.java b/src/de/anura/core/PlayerChat.java new file mode 100644 index 0000000..f3c1e94 --- /dev/null +++ b/src/de/anura/core/PlayerChat.java @@ -0,0 +1,25 @@ +package de.anura.core; + +import org.bukkit.ChatColor; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.AsyncPlayerChatEvent; + +public class PlayerChat implements Listener +{ + public PlayerChat(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onPlayerChat(AsyncPlayerChatEvent event) + { + if(event.isAsynchronous()) + { + event.setFormat(event.getPlayer().getDisplayName() + ChatColor.GRAY + ":" + ChatColor.WHITE + " " + event.getMessage()); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/PlayerInteract.java b/src/de/anura/core/PlayerInteract.java new file mode 100644 index 0000000..c39eba3 --- /dev/null +++ b/src/de/anura/core/PlayerInteract.java @@ -0,0 +1,261 @@ +package de.anura.core; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.sql.ResultSet; +import java.sql.SQLException; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.Sign; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.material.Stairs; +import org.bukkit.util.Vector; + +public class PlayerInteract implements Listener +{ + public PlayerInteract(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onPlayerInteract(PlayerInteractEvent event) + { + final Block block = event.getClickedBlock(); + if(plugin.selectableJumper.containsKey(event.getPlayer())) + { + if(event.getPlayer().hasPermission("core.commands.setjumper")) + { + if(event.getAction().equals(Action.RIGHT_CLICK_BLOCK) || event.getAction().equals(Action.LEFT_CLICK_BLOCK)) + { + String type; + if(event.getClickedBlock().getType().equals(Material.ENDER_CHEST)) + { + type = "high"; + } + else if(event.getClickedBlock().getType().equals(Material.RAILS)) + { + type = "far"; + } + else + { + API.statusMsg(event.getPlayer(), "setjumper_block_not_supported", false); + plugin.selectableJumper.remove(event.getPlayer()); + return; + } + Double X = event.getClickedBlock().getLocation().getX(); + Double Y = event.getClickedBlock().getLocation().getY(); + Double Z = event.getClickedBlock().getLocation().getZ(); + String world = event.getClickedBlock().getLocation().getWorld().getName(); + String sql = "INSERT INTO coreJumpers(X,Y,Z,world,height,type) VALUES('"+X+"','"+Y+"','"+Z+"','"+world+"','"+plugin.selectableJumper.get(event.getPlayer())+"','"+type+"')"; + AnuraCore.getSql().queryUpdate(sql); + plugin.selectableJumper.remove(event.getPlayer()); + API.statusMsg(event.getPlayer(), "setjumper_done", true); + event.setCancelled(true); + } + } + } + else if(block != null) + { + if(block.getState() instanceof Sign && event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) + { + Sign sign = (Sign)block.getState(); + Location loc = sign.getLocation(); + Player P = event.getPlayer(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = plugin.getConfig().getString("server-name"); + ResultSet rs = AnuraCore.sql.querySelect("SELECT type, value FROM coreWarpSigns WHERE X = '"+X+"' AND Y = '"+Y+"' AND Z = '"+Z+"' AND world = '"+world+"' AND server = '"+server+"'"); + try { + rs.last(); + if(rs.getRow() != 0) + { + rs.first(); + if(rs.getString("type").equalsIgnoreCase("warp")) + { + String warp = rs.getString("value"); + ResultSet rs2 = AnuraCore.sql.querySelect("SELECT world, X, Y, Z FROM coreWarps WHERE name = '"+warp+"' AND server = '"+plugin.getConfig().getString("server-name")+"'"); + rs2.last(); + if(rs2.getRow() == 0) + { + API.statusMsg(P, "warpsign_warp_not_exist", false); + } + else + { + if(plugin.getServer().getWorld(rs2.getString("world")) != null) + { + Location target = new Location(plugin.getServer().getWorld(rs2.getString("world")), rs2.getInt("X"), rs2.getInt("Y"), rs2.getInt("Z")); + P.teleport(target); + } + } + } + else if(rs.getString("type").equalsIgnoreCase("spawn")) + { + P.teleport(loc.getWorld().getSpawnLocation()); + } + else if(rs.getString("type").equalsIgnoreCase("server")) + { + String targetServer = rs.getString("value"); + ByteArrayOutputStream b = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(b); + out.writeUTF("Connect"); + out.writeUTF(targetServer); + P.sendPluginMessage(plugin, "BungeeCord", b.toByteArray()); + } + } + } catch (SQLException ex) { + System.out.println("SQLException in playerInteract: "+ex.getLocalizedMessage()); + } catch (IOException ex) { + System.out.println("IOException in playerInteract: "+ex.getLocalizedMessage()); + } + + event.setCancelled(true); + } + else if(block.getState().getData() instanceof Stairs) + { + if(plugin.stairMode.contains(event.getPlayer()) && event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) + { + event.setCancelled(true); + if(plugin.sittableBlocks.contains(block)) + { + plugin.sittableBlocks.remove(block); + API.getTools().sendStatusMsg(event.getPlayer(), "Removed!", false); + int X = block.getLocation().getBlockX(); + int Y = block.getLocation().getBlockY(); + int Z = block.getLocation().getBlockZ(); + API.getMySql().queryUpdate("DELETE FROM coreStairs WHERE server = '"+plugin.getConfig().getString("server-name")+"' AND world = '"+block.getWorld().getName()+"' AND X = '"+X+"' AND Y = '"+Y+"' AND Z = '"+Z+"'"); + } + else + { + plugin.sittableBlocks.add(block); + API.getTools().sendStatusMsg(event.getPlayer(), "Added!", true); + int X = block.getLocation().getBlockX(); + int Y = block.getLocation().getBlockY(); + int Z = block.getLocation().getBlockZ(); + API.getMySql().queryUpdate("INSERT INTO coreStairs(server,world,X,Y,Z) VALUES('"+plugin.getConfig().getString("server-name")+"','"+block.getWorld().getName()+"','"+X+"','"+Y+"','"+Z+"')"); + } + } + else if(plugin.getConfig().getBoolean("allow-stairs-sit") && event.getAction().equals(Action.RIGHT_CLICK_BLOCK) && plugin.sittableBlocks.contains(block)) + { + if(plugin.sittingPlayer.containsKey(event.getPlayer())) + { + API.statusMsg(event.getPlayer(), "sitting_already", false); + event.setCancelled(true); + } + else if(plugin.sittingBlocks.containsValue(block)) + { + API.statusMsg(event.getPlayer(), "sitting_occupied", false); + event.setCancelled(true); + } + else + { + Stairs s = (Stairs)block.getState().getData(); + if(!s.isInverted()) + { + Location loc = block.getLocation(); + loc = loc.add(0.5, 0.05, 0.5); + loc.add(s.getFacing().getModX()*0.2, 0, s.getFacing().getModZ()*0.2); + Arrow a = loc.getWorld().spawnArrow(loc, new Vector(0,0,0), 0, 0); + a.setPassenger(event.getPlayer()); + plugin.sittingPlayer.put(event.getPlayer(), a); + plugin.sittingBlocks.put(event.getPlayer(), block); + event.setCancelled(true); + } + } + } + } + else if(plugin.flowerPots.containsValue(block.getLocation())) + { + event.setCancelled(true); + final Player p = event.getPlayer(); + plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + + @Override + public void run() { + p.sendBlockChange(block.getLocation(), Material.AIR, (byte)0); + } + + }, 3); + plugin.pots.playerFoundPot(event.getPlayer(), API.getKeyByValue(plugin.flowerPots, block.getLocation())); + } + } + + if(event.hasItem()) + { + if(event.getAction().equals(Action.RIGHT_CLICK_AIR) || event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) + { + if(event.getItem().equals(plugin.warpCompasses.get(API.getPlayerLang(event.getPlayer())))) + { + plugin.openGameSelectWindow(event.getPlayer()); + event.setCancelled(true); + final Player p = event.getPlayer(); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.updateInventory(); + } + }, 1); + } + else if(event.getItem().equals(plugin.doors.get(API.getPlayerLang(event.getPlayer())))) + { + event.setCancelled(true); + Player player = event.getPlayer(); + player.teleport(player.getLocation().getWorld().getSpawnLocation()); + final Player p = event.getPlayer(); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.updateInventory(); + } + }, 1); + } + else if(event.getItem().equals(plugin.selLang)) + { + event.getPlayer().openInventory(plugin.selectLang); + event.setCancelled(true); + final Player p = event.getPlayer(); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { + @Override + public void run() + { + p.updateInventory(); + } + }, 1); + } + } + } + if(plugin.getConfig().getBoolean("no-change-blocks")) + { + if(!event.getPlayer().hasPermission("core.rules.blocks.interact")) + { + Boolean cancelled = true; + if(event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) + { + if(event.getClickedBlock().getType().equals(Material.STONE_BUTTON)) cancelled = false; + else if(event.getClickedBlock().getType().equals(Material.WOOD_BUTTON)) cancelled = false; + } + else if(event.getAction().equals(Action.PHYSICAL)) cancelled = false; + else if(event.getAction().equals(Action.RIGHT_CLICK_AIR)) + { + if(event.getPlayer().getItemInHand().getType().equals(Material.BOW)) cancelled = false; + else if(event.getPlayer().getItemInHand().getType().equals(Material.EXP_BOTTLE)) cancelled = false; + } + event.setCancelled(cancelled); + } + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/PlayerInteractE.java b/src/de/anura/core/PlayerInteractE.java new file mode 100644 index 0000000..723be8e --- /dev/null +++ b/src/de/anura/core/PlayerInteractE.java @@ -0,0 +1,60 @@ +package de.anura.core; + +import org.bukkit.Material; +import org.bukkit.entity.Chicken; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerInteractEntityEvent; + +public class PlayerInteractE implements Listener +{ + public PlayerInteractE(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onPlayerInteractE(PlayerInteractEntityEvent event) + { + if(event.getRightClicked().getType().equals(EntityType.ITEM_FRAME) && plugin.getConfig().getBoolean("no-change-blocks")) + { + if(!event.getPlayer().hasPermission("core.rules.blocks.interact")) + { + event.setCancelled(true); + } + } + else if(event.getRightClicked().getType().equals(EntityType.CHICKEN) && plugin.getConfig().getBoolean("golf")) + { + Player P = event.getPlayer(); + // Item i = (Item)event.getRightClicked(); + Chicken b = (Chicken)event.getRightClicked(); + if(P.getItemInHand().getType().equals(Material.STICK)) + { + int power; + + if(!plugin.golfPower.containsKey(P)) + { + power = 1; + } + else + { + power = plugin.golfPower.get(P); + power++; + } + if(power > 40) + { + power = 40; + } + System.out.println(power); + plugin.golfPower.put(P, power); + plugin.releaseGolf.put(P, false); + plugin.golfBall.put(P, b); + + } + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/PlayerJoin.java b/src/de/anura/core/PlayerJoin.java new file mode 100644 index 0000000..e924902 --- /dev/null +++ b/src/de/anura/core/PlayerJoin.java @@ -0,0 +1,65 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.UUID; + + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.inventory.PlayerInventory; + + +public class PlayerJoin implements Listener +{ + public PlayerJoin(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onPlayerJoin(PlayerJoinEvent event) + { + UUID uuid = event.getPlayer().getUniqueId(); + ResultSet rs; + try { + rs = AnuraCore.getSql().querySelect("SELECT name FROM players WHERE uuid LIKE '"+uuid.toString()+"'"); + if(rs==null) { + event.getPlayer().kickPlayer("Please try again"); + event.setJoinMessage(null); + return; + } + rs.last(); + if(rs.getRow() != 1) + { + AnuraCore.getSql().queryUpdate("INSERT INTO players(`uuid`,`game`,`waiting`,`gameName`) VALUES('"+uuid.toString()+"','none','none','')"); + } + } + catch(SQLException e) { + } + event.setJoinMessage(null); + if(plugin.getConfig().getBoolean("is-main-lobby")) + { + PlayerInventory pi = event.getPlayer().getInventory(); + pi.clear(); + pi.setHeldItemSlot(0); + pi.setItemInHand(plugin.warpCompasses.get(API.getPlayerLang(event.getPlayer()))); + pi.setHeldItemSlot(8); + pi.setItemInHand(plugin.doors.get(API.getPlayerLang(event.getPlayer()))); + pi.setHeldItemSlot(1); + pi.setItemInHand(plugin.selLang); + pi.setHeldItemSlot(0); + } + plugin.pots.refreshCache(event.getPlayer()); + plugin.pots.refreshPlayer(event.getPlayer()); + plugin.getFeatures().updateFeatures(event.getPlayer()); + plugin.disableCommandsAdventure.put(event.getPlayer(), false); + if(plugin.getConfig().getBoolean("on-join-to-spawn")) + { + event.getPlayer().teleport(event.getPlayer().getWorld().getSpawnLocation()); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/PlayerKick.java b/src/de/anura/core/PlayerKick.java new file mode 100644 index 0000000..2b17910 --- /dev/null +++ b/src/de/anura/core/PlayerKick.java @@ -0,0 +1,38 @@ +package de.anura.core; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerKickEvent; + +public class PlayerKick implements Listener +{ + public PlayerKick(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onPlayerKick(PlayerKickEvent event) + { + AnuraCore.getInstance().disableCommandsAdventure.remove(event.getPlayer()); + if(!plugin.getConfig().getBoolean("is-main-lobby")) + { + try { + plugin.endSitting(event.getPlayer()); + event.setCancelled(true); + ByteArrayOutputStream b = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(b); + out.writeUTF("Connect"); + out.writeUTF("lobby"); + event.getPlayer().sendPluginMessage(plugin, "BungeeCord", b.toByteArray()); + + } catch (IOException ex) { + } + } + event.setLeaveMessage(null); + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/PlayerMove.java b/src/de/anura/core/PlayerMove.java new file mode 100644 index 0000000..1e00734 --- /dev/null +++ b/src/de/anura/core/PlayerMove.java @@ -0,0 +1,143 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.entity.Entity; +import org.bukkit.material.Sign; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; +import org.bukkit.util.Vector; + +public class PlayerMove implements Listener +{ + private final AnuraCore plugin; + public PlayerMove(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onPlayerMove(PlayerMoveEvent event) + { + Player p = event.getPlayer(); + Block block = event.getTo().clone().getBlock(); + Block under = block.getLocation().subtract(0,1,0).getBlock(); + + Location jumpIslandCenter = new Location(Bukkit.getWorld("lobby"), -289, 60, -1438); + if(p.getWorld().getName().equals("lobby") && jumpIslandCenter.distance(event.getTo()) < 80 && (under.getType().equals(Material.GRASS)) && ((Entity)p).isOnGround() && !p.hasPermission("core.jump.grassStep")) + { + ResultSet rs = AnuraCore.getSql().querySelect("SELECT x,y,z FROM jumpLocs WHERE stage = (SELECT stage FROM jumpUsers WHERE userId = (SELECT id FROM players WHERE uuid = '"+p.getUniqueId().toString()+"') ORDER BY stage DESC LIMIT 1)"); + try { + if(!rs.first()) + { + Location loc = new Location(Bukkit.getWorld("lobby"), -262, 19, -1473); + p.teleport(loc); + return; + } + + double x = rs.getInt("x"); + double y = rs.getInt("y"); + double z = rs.getInt("z"); + if(x<0) x -= 0.5; + else x += 0.5; + if(z<0) z -= 0.5; + else z += 0.5; + Location loc = new Location(Bukkit.getWorld("lobby"), x, y, z); + p.teleport(loc); + API.statusMsg(p, "jump_tp_last_grass", true); + } + catch(SQLException e) + { + System.out.println(e.getLocalizedMessage()); + } + } + + if(event.getTo().getY() <= -40 && plugin.getConfig().getBoolean("no-void-death")) + { + p.performCommand("spawn"); + } + if(block.getType().equals(Material.CARPET) && under.getType().equals(Material.SIGN_POST)) + { + p.setWalkSpeed(0.6F); + } + else if(block.getType().equals(Material.CARPET) && under.getType().equals(Material.ENDER_CHEST)) + { + try { + double X = under.getLocation().getX(); + double Y = under.getLocation().getY(); + double Z = under.getLocation().getZ(); + String world = under.getLocation().getWorld().getName(); + String sql = "SELECT * FROM coreJumpers WHERE X = '"+(int)X+"' AND Y = '"+(int)Y+"' AND Z = '"+(int)Z+"' AND world = '"+world+"' AND type = 'high'"; + ResultSet rs = AnuraCore.getSql().querySelect(sql); + rs.last(); + if(rs.getRow() > 0) + { + p.setVelocity(new Vector(0,rs.getDouble("height"),0)); + ParticleEffect.FIREWORKS_SPARK.display(p.getLocation(), (float)0.1, (float)0.1, (float)0.1, (float)0.3, 10); + } + p.setWalkSpeed(0.2F); + } catch (SQLException ex) { + System.err.println(ex.getLocalizedMessage()); + } + + } + else if(block.getType().equals(Material.CARPET) && under.getType().equals(Material.RAILS)) + { + try { + double X = under.getLocation().getX(); + double Y = under.getLocation().getY(); + double Z = under.getLocation().getZ(); + String world = under.getLocation().getWorld().getName(); + String sql = "SELECT * FROM coreJumpers WHERE X = '"+(int)X+"' AND Y = '"+(int)Y+"' AND Z = '"+(int)Z+"' AND world = '"+world+"' AND type = 'far'"; + ResultSet rs = AnuraCore.getSql().querySelect(sql); + rs.last(); + if(rs.getRow() > 0) + { + p.setVelocity(p.getLocation().getDirection().multiply(new Vector(rs.getDouble("height"),1,rs.getDouble("height")))); + p.setVelocity(p.getVelocity().setY(1.3)); + ParticleEffect.LAVA.display(p.getLocation(), (float)0.1, (float)0.1, (float)0.1, (float)0.3, 10); + p.playSound(p.getLocation(), Sound.EXPLODE, 1, 1); + } + p.setWalkSpeed(0.2F); + } catch (SQLException ex) { + System.err.println(ex.getLocalizedMessage()); + } + } + else + { + p.setWalkSpeed(0.2F); + } + Block sign = null; + Block isSign = block.getLocation().getWorld().getBlockAt(block.getLocation().add(0, 1, 0)); + if(isSign.getType().equals(Material.WALL_SIGN)) + { + sign = isSign; + } + else if(block.getType().equals(Material.WALL_SIGN)) + { + sign = block; + } + if(sign != null && !event.getPlayer().hasPermission("core.rules.hideSign")) + { + Sign s = (Sign)sign.getState().getData(); + BlockFace bf = s.getFacing(); + if(bf.equals(BlockFace.EAST)) event.getPlayer().setVelocity(new Vector(0.3,0,0)); + if(bf.equals(BlockFace.WEST)) event.getPlayer().setVelocity(new Vector(-0.3,0,0)); + if(bf.equals(BlockFace.SOUTH)) event.getPlayer().setVelocity(new Vector(0,0,0.3)); + if(bf.equals(BlockFace.NORTH)) event.getPlayer().setVelocity(new Vector(0,0,-0.3)); + } + if(!plugin.lastLoc.containsKey(p) || !plugin.lastLoc.get(p).getWorld().equals(p.getLocation().getWorld()) || plugin.lastLoc.get(p).distance(p.getLocation()) > 1) + { + plugin.pots.refreshPlayer(p); + } + + } +} diff --git a/src/de/anura/core/PlayerQuit.java b/src/de/anura/core/PlayerQuit.java new file mode 100644 index 0000000..69fb4c1 --- /dev/null +++ b/src/de/anura/core/PlayerQuit.java @@ -0,0 +1,21 @@ +package de.anura.core; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerQuitEvent; + +public class PlayerQuit implements Listener +{ + public PlayerQuit(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent event) + { + event.setQuitMessage(null); + AnuraCore.getInstance().endSitting(event.getPlayer()); + AnuraCore.getInstance().disableCommandsAdventure.remove(event.getPlayer()); + } +} diff --git a/src/de/anura/core/PlayerTeleport.java b/src/de/anura/core/PlayerTeleport.java new file mode 100644 index 0000000..bfdede2 --- /dev/null +++ b/src/de/anura/core/PlayerTeleport.java @@ -0,0 +1,49 @@ +package de.anura.core; + +import org.bukkit.Location; +import org.bukkit.block.Block; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerTeleportEvent; +import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; +import org.bukkit.material.MaterialData; +import org.bukkit.material.Stairs; + +public class PlayerTeleport implements Listener +{ + public PlayerTeleport(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler(priority=EventPriority.LOWEST) + public void onPlayerTeleport(PlayerTeleportEvent event) + { + if(plugin.sittingPlayer.containsKey(event.getPlayer()) && !event.getCause().equals(TeleportCause.PLUGIN)) + { + if(event.getPlayer().isSneaking()) + { + Player P = event.getPlayer(); + Block b = plugin.sittingBlocks.get(P); + MaterialData md = b.getState().getData(); + if(md instanceof Stairs) + { + Stairs s = (Stairs)md; + Location loc = b.getRelative(s.getFacing()).getLocation(); + Arrow a = plugin.sittingPlayer.get(P); + event.setTo(loc); + P.setSneaking(false); + a.remove(); + plugin.sittingPlayer.remove(P); + plugin.sittingBlocks.remove(P); + return; + } + } + event.setCancelled(true); + } + } + private final AnuraCore plugin; +} diff --git a/src/de/anura/core/ReflectionUtil.java b/src/de/anura/core/ReflectionUtil.java new file mode 100644 index 0000000..7d174e6 --- /dev/null +++ b/src/de/anura/core/ReflectionUtil.java @@ -0,0 +1,158 @@ +package de.anura.core; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +import org.bukkit.Bukkit; + +/** + * ReflectionUtil v1.1 + * + * You are welcome to use it, modify it and redistribute it under the condition to not claim this class as your own + * + * @author DarkBlade12 + */ +public abstract class ReflectionUtil { + private static final Map, Class> CORRESPONDING_TYPES = new HashMap<>(); + + static { + CORRESPONDING_TYPES.put(Byte.class, byte.class); + CORRESPONDING_TYPES.put(Short.class, short.class); + CORRESPONDING_TYPES.put(Integer.class, int.class); + CORRESPONDING_TYPES.put(Long.class, long.class); + CORRESPONDING_TYPES.put(Character.class, char.class); + CORRESPONDING_TYPES.put(Float.class, float.class); + CORRESPONDING_TYPES.put(Double.class, double.class); + CORRESPONDING_TYPES.put(Boolean.class, boolean.class); + } + + public enum DynamicPackage { + MINECRAFT_SERVER { + @Override + public String toString() { + return "net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().substring(23, 30); + } + }, + CRAFTBUKKIT { + @Override + public String toString() { + return Bukkit.getServer().getClass().getPackage().getName(); + } + }; + } + + public static class FieldEntry { + String key; + Object value; + + public FieldEntry(String key, Object value) { + this.key = key; + this.value = value; + } + + public String getKey() { + return this.key; + } + + public Object getValue() { + return this.value; + } + } + + private static Class getPrimitiveType(Class clazz) { + return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz; + } + + private static Class[] toPrimitiveTypeArray(Object[] objects) { + int a = objects != null ? objects.length : 0; + Class[] types = new Class[a]; + for (int i = 0; i < a; i++) + types[i] = getPrimitiveType(objects[i].getClass()); + return types; + } + + private static Class[] toPrimitiveTypeArray(Class[] classes) { + int a = classes != null ? classes.length : 0; + Class[] types = new Class[a]; + for (int i = 0; i < a; i++) + types[i] = getPrimitiveType(classes[i]); + return types; + } + + private static boolean equalsTypeArray(Class[] a, Class[] o) { + if (a.length != o.length) + return false; + for (int i = 0; i < a.length; i++) + if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i])) + return false; + return true; + } + + public static Class getClass(String name, DynamicPackage pack, String subPackage) throws Exception { + return Class.forName(pack + (subPackage != null && subPackage.length() > 0 ? "." + subPackage : "") + "." + name); + } + + public static Class getClass(String name, DynamicPackage pack) throws Exception { + return getClass(name, pack, null); + } + + public static Constructor getConstructor(Class clazz, Class... paramTypes) { + Class[] t = toPrimitiveTypeArray(paramTypes); + for (Constructor c : clazz.getConstructors()) { + Class[] types = toPrimitiveTypeArray(c.getParameterTypes()); + if (equalsTypeArray(types, t)) + return c; + } + return null; + } + + public static Object newInstance(Class clazz, Object... args) throws Exception { + return getConstructor(clazz, toPrimitiveTypeArray(args)).newInstance(args); + } + + public static Object newInstance(String name, DynamicPackage pack, String subPackage, Object... args) throws Exception { + return newInstance(getClass(name, pack, subPackage), args); + } + + public static Object newInstance(String name, DynamicPackage pack, Object... args) throws Exception { + return newInstance(getClass(name, pack, null), args); + } + + public static Method getMethod(String name, Class clazz, Class... paramTypes) { + Class[] t = toPrimitiveTypeArray(paramTypes); + for (Method m : clazz.getMethods()) { + Class[] types = toPrimitiveTypeArray(m.getParameterTypes()); + if (m.getName().equals(name) && equalsTypeArray(types, t)) + return m; + } + return null; + } + + public static Object invokeMethod(String name, Class clazz, Object obj, Object... args) throws Exception { + return getMethod(name, clazz, toPrimitiveTypeArray(args)).invoke(obj, args); + } + + public static Field getField(String name, Class clazz) throws Exception { + return clazz.getDeclaredField(name); + } + + public static Object getValue(String name, Object obj) throws Exception { + Field f = getField(name, obj.getClass()); + f.setAccessible(true); + return f.get(obj); + } + + public static void setValue(Object obj, FieldEntry entry) throws Exception { + Field f = getField(entry.getKey(), obj.getClass()); + f.setAccessible(true); + f.set(obj, entry.getValue()); + } + + public static void setValues(Object obj, FieldEntry... entrys) throws Exception { + for (FieldEntry f : entrys) + setValue(obj, f); + } +} \ No newline at end of file diff --git a/src/de/anura/core/SignChange.java b/src/de/anura/core/SignChange.java new file mode 100644 index 0000000..92d46b7 --- /dev/null +++ b/src/de/anura/core/SignChange.java @@ -0,0 +1,137 @@ +package de.anura.core; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.AbstractMap.SimpleEntry; +import java.util.ArrayList; +import java.util.Map.Entry; +import org.bukkit.ChatColor; +import org.bukkit.Location; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.SignChangeEvent; + + +public class SignChange implements Listener +{ + public SignChange(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + @EventHandler + public void onSignChange(SignChangeEvent event) + { + + if(event.getLine(0).equalsIgnoreCase("[Warp]")) + { + if(!event.getPlayer().hasPermission("core.signs.warp")) + { + event.setLine(0, ChatColor.STRIKETHROUGH + "[Warp]"); + event.setLine(1, ChatColor.RED + "You don't"); + event.setLine(2, ChatColor.RED + "have"); + event.setLine(3, ChatColor.RED + "Permission!"); + return; + } + if(event.getLine(1).equalsIgnoreCase("warp")) + { + ResultSet rs = AnuraCore.sql.querySelect("SELECT name FROM coreWarps WHERE name = '"+event.getLine(2)+"'"); + try { + rs.last(); + if(rs.getRow() == 0) + { + event.setLine(0, ChatColor.STRIKETHROUGH+ "[Warp]"); + event.setLine(1, ChatColor.RED + "Der Warp"); + event.setLine(2, ChatColor.YELLOW + event.getLine(2) + ChatColor.RED + "exis-"); + event.setLine(3, ChatColor.RED + "tiert nicht!"); + } + else + { + Location loc = event.getBlock().getLocation(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = plugin.getConfig().getString("server-name"); + AnuraCore.sql.queryUpdate("INSERT INTO coreWarpSigns(X,Y,Z,world,server,type,value,info) VALUES('"+X+"','"+Y+"','"+Z+"','"+world+"','"+server+"','warp','"+event.getLine(2)+"','"+event.getLine(3)+"')"); + event.setLine(0, "["+ChatColor.GREEN+"Warp"+ChatColor.BLACK+"]"); + event.setLine(1, ChatColor.DARK_GRAY+"--------"); + event.setLine(2, ChatColor.AQUA + event.getLine(2)); + event.setLine(3, ChatColor.BLUE + event.getLine(3)); + API.statusMsg(event.getPlayer(), "warpsign_created", true); + } + } catch (SQLException ex) { + System.out.println("Error: "+ex.getLocalizedMessage()); + } + } + else if(event.getLine(1).equalsIgnoreCase("spawn")) + { + Location loc = event.getBlock().getLocation(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = plugin.getConfig().getString("server-name"); + AnuraCore.sql.queryUpdate("INSERT INTO coreWarpSigns(X,Y,Z,world,server,type,value,info) VALUES('"+X+"','"+Y+"','"+Z+"','"+world+"','"+server+"','spawn','none','"+event.getLine(3)+"')"); + event.setLine(0, ChatColor.DARK_GRAY + "---------"); + event.setLine(1, ChatColor.BLACK + "["+ChatColor.GREEN + "Spawn"+ ChatColor.BLACK + "]"); + event.setLine(2, ChatColor.DARK_GRAY + "---------"); + event.setLine(3, ChatColor.BLUE + event.getLine(3)); + API.statusMsg(event.getPlayer(), "spawnsign_created", true); + } + else if(event.getLine(1).equalsIgnoreCase("server")) + { + Location loc = event.getBlock().getLocation(); + int X = loc.getBlockX(); + int Y = loc.getBlockY(); + int Z = loc.getBlockZ(); + String world = loc.getWorld().getName(); + String server = event.getLine(2); + String curServer = plugin.getConfig().getString("server-name"); + AnuraCore.sql.queryUpdate("INSERT INTO coreWarpSigns(X,Y,Z,world,server,type,value,info) VALUES('"+X+"','"+Y+"','"+Z+"','"+world+"','"+curServer+"','server','"+server+"','"+event.getLine(3)+"')"); + event.setLine(0, ChatColor.BLACK + "["+ChatColor.GREEN + "Server"+ ChatColor.BLACK + "]"); + event.setLine(1, ChatColor.GREEN + "--"+ChatColor.DARK_GRAY+"/"+ChatColor.GREEN+"--"); + event.setLine(2, ChatColor.AQUA + event.getLine(2)); + event.setLine(3, ChatColor.BLUE + event.getLine(3)); + API.statusMsg(event.getPlayer(), "serversign_created", true); + } + } + else + { + if(event.getPlayer().hasPermission("core.signs.chars")) + { + for(int i = 0; i < 4; i++) + { + String l = event.getLine(i); + l = ChatColor.translateAlternateColorCodes('&', l); + if(l.contains("%")) + { + String[] parts = l.split("%"); + ArrayList> toReplace = new ArrayList<>(); + Boolean first = true; + for(String s : parts) + { + if(!first) + { + String num = s.split(" ")[0]; + if(plugin.isInteger(num)) + { + int number = Integer.valueOf(num); + Entry e = new SimpleEntry<>("%"+number, Character.toString((char)number)); + toReplace.add(e); + } + } + first = false; + } + for(Entry entry : toReplace) + { + l = l.replace(entry.getKey(), entry.getValue()); + } + } + event.setLine(i, l); + } + } + } + } + private final AnuraCore plugin; +} \ No newline at end of file diff --git a/src/de/anura/core/Tools.java b/src/de/anura/core/Tools.java new file mode 100644 index 0000000..3239495 --- /dev/null +++ b/src/de/anura/core/Tools.java @@ -0,0 +1,27 @@ +package de.anura.core; + +import org.bukkit.ChatColor; +import org.bukkit.command.CommandSender; + +public class Tools { + + /** + * Sends a given message to a given player with the given status + * @param p The player to send the message to + * @param msg The message to send + * @param positive If the message should be green(true) or red(false) + */ + public void sendStatusMsg(CommandSender p, String msg, Boolean positive) + { + ChatColor chatColor; + if(positive) + { + chatColor = ChatColor.GREEN; + } + else + { + chatColor = ChatColor.RED; + } + p.sendMessage(ChatColor.GRAY + "[Anura] "+chatColor+msg); + } +} diff --git a/src/de/anura/core/WeatherChange.java b/src/de/anura/core/WeatherChange.java new file mode 100644 index 0000000..d536de7 --- /dev/null +++ b/src/de/anura/core/WeatherChange.java @@ -0,0 +1,25 @@ +package de.anura.core; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.weather.WeatherChangeEvent; + +public class WeatherChange implements Listener +{ + public WeatherChange(AnuraCore plugin) + { + plugin.getServer().getPluginManager().registerEvents(this, plugin); + this.plugin = plugin; + } + + @EventHandler + public void onWeatherChange(WeatherChangeEvent event) + { + if(event.toWeatherState() && plugin.getConfig().getBoolean("no-rain")) + { + event.setCancelled(true); + System.out.println("Stopped rain!"); + } + } + private final AnuraCore plugin; +} \ No newline at end of file diff --git a/src/plugin.yml b/src/plugin.yml new file mode 100644 index 0000000..2797fbc --- /dev/null +++ b/src/plugin.yml @@ -0,0 +1,72 @@ +name: Core +main: de.anura.core.AnuraCore +version: 0.9 +author: kaenganxt +softdepend: [Multiverse-Core] +commands: + setjumper: + description: Admin Command + usage: / + setspawn: + description: Sets the worlds spawn + usage: / + spawn: + description: Teleports you to spawn + usage: / + money: + description: Money stuff + usage: / [pay ] + gm: + description: GameMode! + usage: / + sun: + description: I love sun! + usage: / + core: + description: Save/Reload the config + usage: / save|reload|debugclosemysql + hilfe: + description: Shows the help + usage: / [seite] + none: + description: This is a dummy command + usage: / + flyspeed: + description: Set the fly-speed + usage: / + setwarp: + description: Set a warp + usage: / [allowUsers] + warp: + description: It's a warp + usage: / [player] + remwarp: + description: Remove warp + usage: / + flowerpot: + description: Set a flowerpot + usage: / + addmap: + description: Adds an image-map + usage: / + rendermap: + description: Renders an image for a map + usage: / + cleararrows: + description: Clears all arrows in the current world + usage: / + stairmode: + description: Toggles the stairmode + usage: / + addcmd: + description: Adds some text to a cmd block + usage: / + setcmd: + description: Sets the command of a cmd block + usage: / + togglecommands: + description: Only cmd block command! + usage: / + updatecommandblocks: + description: Updates command blocks at the given positions + usage: / {, , }... \ No newline at end of file