From 25234f0b154d7fb84bee89efd2bb15c24d33f61e Mon Sep 17 00:00:00 2001 From: Xanadu13 <104714710+iXanadu13@users.noreply.github.com> Date: Thu, 9 Feb 2023 23:56:17 +0800 Subject: [PATCH] update to 2.0.0 --- .../java/xanadu/enderdragon/EnderDragon.java | 246 ++++++----- .../enderdragon/commands/MainCommand.java | 236 +++++----- .../enderdragon/commands/TabCompleter.java | 29 +- .../xanadu/enderdragon/config/Config.java | 76 ++++ .../java/xanadu/enderdragon/config/Lang.java | 176 ++++++++ .../events/DragonDamageByPlayerEvent.java | 56 +++ src/main/java/xanadu/enderdragon/gui/GUI.java | 196 +++++++++ .../xanadu/enderdragon/gui/GUIHolder.java | 20 + .../java/xanadu/enderdragon/gui/GUISlot.java | 36 ++ .../xanadu/enderdragon/gui/GUISlotType.java | 29 ++ .../xanadu/enderdragon/gui/GUIWrapper.java | 82 ++++ .../java/xanadu/enderdragon/gui/Reward.java | 71 +++ .../enderdragon/gui/slots/DragonSlot.java | 37 ++ .../enderdragon/gui/slots/EmptySlot.java | 20 + .../enderdragon/gui/slots/ItemSlot.java | 64 +++ .../enderdragon/gui/slots/PageJumpSlot.java | 26 ++ .../xanadu/enderdragon/gui/slots/TipSlot.java | 44 ++ .../listeners/CreatureSpawnListener.java | 127 ++++++ .../listeners/DragonBaseHurtListener.java | 29 ++ .../DragonDamageByPlayerListener.java | 38 ++ .../listeners/DragonDeathListener.java | 105 +++++ .../listeners/DragonHealListener.java | 24 ++ .../EntityDamageByEntityListener.java | 55 +++ .../listeners/InventoryListener.java | 86 ++++ .../listeners/PluginDisableListener.java | 16 + .../mmoitems/MMOPlayerAttackListener.java | 38 ++ .../mythiclib/PlayerAttackListener.java | 33 ++ .../enderdragon/manager/DragonManager.java | 406 ++++++++++++++++++ .../enderdragon/manager/GuiManager.java | 61 +++ .../enderdragon/manager/ItemManager.java | 99 +++++ .../enderdragon/manager/RewardManager.java | 70 +++ .../enderdragon/manager/TaskManager.java | 93 ++++ .../task/RespawnDragonRunnable.java | 43 ++ .../java/xanadu/enderdragon/task/Task.java | 50 +++ .../xanadu/enderdragon/task/TaskType.java | 26 ++ .../xanadu/enderdragon/task/types/Day.java | 24 ++ .../xanadu/enderdragon/task/types/Hour.java | 23 + .../xanadu/enderdragon/task/types/Minute.java | 26 ++ .../xanadu/enderdragon/task/types/Month.java | 24 ++ .../xanadu/enderdragon/task/types/Week.java | 25 ++ .../xanadu/enderdragon/task/types/Year.java | 23 + .../java/xanadu/enderdragon/utils/Chance.java | 22 + .../java/xanadu/enderdragon/utils/Events.java | 84 ++++ .../xanadu/enderdragon/utils/FileUpdater.java | 122 ++++++ .../xanadu/enderdragon/utils/MathUtils.java | 42 ++ .../xanadu/enderdragon/utils/MyDragon.java | 58 +++ .../java/xanadu/enderdragon/utils/Papi.java | 52 +++ .../enderdragon/utils/SpecialColor.java | 64 +++ .../xanadu/enderdragon/utils/Updater.java | 42 ++ .../xanadu/enderdragon/utils/Version.java | 22 + 50 files changed, 3262 insertions(+), 234 deletions(-) create mode 100644 src/main/java/xanadu/enderdragon/config/Config.java create mode 100644 src/main/java/xanadu/enderdragon/config/Lang.java create mode 100644 src/main/java/xanadu/enderdragon/events/DragonDamageByPlayerEvent.java create mode 100644 src/main/java/xanadu/enderdragon/gui/GUI.java create mode 100644 src/main/java/xanadu/enderdragon/gui/GUIHolder.java create mode 100644 src/main/java/xanadu/enderdragon/gui/GUISlot.java create mode 100644 src/main/java/xanadu/enderdragon/gui/GUISlotType.java create mode 100644 src/main/java/xanadu/enderdragon/gui/GUIWrapper.java create mode 100644 src/main/java/xanadu/enderdragon/gui/Reward.java create mode 100644 src/main/java/xanadu/enderdragon/gui/slots/DragonSlot.java create mode 100644 src/main/java/xanadu/enderdragon/gui/slots/EmptySlot.java create mode 100644 src/main/java/xanadu/enderdragon/gui/slots/ItemSlot.java create mode 100644 src/main/java/xanadu/enderdragon/gui/slots/PageJumpSlot.java create mode 100644 src/main/java/xanadu/enderdragon/gui/slots/TipSlot.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/CreatureSpawnListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/DragonBaseHurtListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/DragonDamageByPlayerListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/DragonDeathListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/DragonHealListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/EntityDamageByEntityListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/InventoryListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/PluginDisableListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/mmoitems/MMOPlayerAttackListener.java create mode 100644 src/main/java/xanadu/enderdragon/listeners/mythiclib/PlayerAttackListener.java create mode 100644 src/main/java/xanadu/enderdragon/manager/DragonManager.java create mode 100644 src/main/java/xanadu/enderdragon/manager/GuiManager.java create mode 100644 src/main/java/xanadu/enderdragon/manager/ItemManager.java create mode 100644 src/main/java/xanadu/enderdragon/manager/RewardManager.java create mode 100644 src/main/java/xanadu/enderdragon/manager/TaskManager.java create mode 100644 src/main/java/xanadu/enderdragon/task/RespawnDragonRunnable.java create mode 100644 src/main/java/xanadu/enderdragon/task/Task.java create mode 100644 src/main/java/xanadu/enderdragon/task/TaskType.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Day.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Hour.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Minute.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Month.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Week.java create mode 100644 src/main/java/xanadu/enderdragon/task/types/Year.java create mode 100644 src/main/java/xanadu/enderdragon/utils/Chance.java create mode 100644 src/main/java/xanadu/enderdragon/utils/Events.java create mode 100644 src/main/java/xanadu/enderdragon/utils/FileUpdater.java create mode 100644 src/main/java/xanadu/enderdragon/utils/MathUtils.java create mode 100644 src/main/java/xanadu/enderdragon/utils/MyDragon.java create mode 100644 src/main/java/xanadu/enderdragon/utils/Papi.java create mode 100644 src/main/java/xanadu/enderdragon/utils/SpecialColor.java create mode 100644 src/main/java/xanadu/enderdragon/utils/Updater.java create mode 100644 src/main/java/xanadu/enderdragon/utils/Version.java diff --git a/src/main/java/xanadu/enderdragon/EnderDragon.java b/src/main/java/xanadu/enderdragon/EnderDragon.java index d459d35..e2080f9 100644 --- a/src/main/java/xanadu/enderdragon/EnderDragon.java +++ b/src/main/java/xanadu/enderdragon/EnderDragon.java @@ -1,32 +1,40 @@ package xanadu.enderdragon; -import org.bukkit.Bukkit; -import org.bukkit.Material; -import org.bukkit.Server; -import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.*; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; -import org.bukkit.entity.Entity; -import org.bukkit.inventory.ItemStack; +import org.bukkit.entity.Player; +import org.bukkit.event.HandlerList; +import org.bukkit.inventory.Inventory; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.PluginManager; import org.bukkit.plugin.java.JavaPlugin; +import org.bukkit.scheduler.BukkitRunnable; import xanadu.enderdragon.commands.MainCommand; import xanadu.enderdragon.commands.TabCompleter; -import xanadu.enderdragon.events.*; -import xanadu.enderdragon.lang.Message; -import xanadu.enderdragon.listeners.InventoryClick; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.gui.GUIHolder; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.listeners.*; +import xanadu.enderdragon.listeners.mmoitems.MMOPlayerAttackListener; +import xanadu.enderdragon.listeners.mythiclib.PlayerAttackListener; +import xanadu.enderdragon.manager.DragonManager; +import xanadu.enderdragon.manager.GuiManager; +import xanadu.enderdragon.manager.TaskManager; import xanadu.enderdragon.metrics.Metrics; +import xanadu.enderdragon.task.RespawnDragonRunnable; +import xanadu.enderdragon.utils.Version; import java.io.*; -import java.net.URL; -import java.net.URLConnection; +import java.util.Objects; + +import static xanadu.enderdragon.config.Lang.*; +import static xanadu.enderdragon.manager.GuiManager.loadGui; +import static xanadu.enderdragon.utils.Updater.checkUpdate; public final class EnderDragon extends JavaPlugin { - public static String prefix = ""; - public static String language = ""; - public static String langPath = ""; + private static EnderDragon instance; public static Plugin plugin; public static Server server; public static PluginManager pm; @@ -36,127 +44,149 @@ public final class EnderDragon extends JavaPlugin { public static FileConfiguration lang; public static int mcMainVersion; public static int mcPatchVersion; - + private DragonManager dragonManager; + private static boolean finish; @Override public void onEnable() { + finish = false; + info("Enabling plugin..."); + info("Author: Xanadu13"); plugin = this; + instance = this; + dragonManager = new DragonManager(); server = plugin.getServer(); pm = Bukkit.getPluginManager(); mcMainVersion = getMinecraftVersion(); - boolean configNotFound = false; - boolean dataNotFound = false; - if (!new File(getDataFolder(), "config.yml").exists()) { - saveDefaultConfig(); - configNotFound = true; + registerEvents(); + registerCommands(); + Metrics metrics = new Metrics(this,14850); + reloadAll(); + Version.init(); + checkUpdate(); + if(!Lang.version.equals("2.0.0")){ + warn(Lang.plugin_wrong_file_version.replace("{file_name}",Config.lang + ".yml")); } + if(!Config.version.equals("2.0.0")){ + warn(Lang.plugin_wrong_file_version.replace("{file_name}","config.yml")); + } + if(!"2.0.0".equals(data.getString("version"))){ + warn(Lang.plugin_wrong_file_version.replace("{file_name}","data.yml")); + } + finish = true; + } + public static void reloadAll(){ + EnderDragon.getInstance().loadFiles(); + BukkitRunnable runnable = new BukkitRunnable() { + @Override + public void run() { + if(!TaskManager.getCurrentTimeWithSpecialFormat().endsWith("0")) return; + this.cancel(); + RespawnDragonRunnable.reload(); + } + }; + new BukkitRunnable() { + @Override + public void run() { + if (!finish) return; + this.cancel(); + DragonManager.reload(); + loadGui(); + if(Config.auto_respawn_enable){ + TaskManager.reload(); + runnable.runTaskTimer(plugin,0,1); + } + } + }.runTaskTimer(plugin, 1, 5); + } + public static void disableAll(){ + closeAllInventory(); + Bukkit.getScheduler().cancelTasks(plugin); + DragonManager.disable(); + GuiManager.disable(); + instance.unregisterCommands(); + HandlerList.unregisterAll(plugin); + server.getScheduler().cancelTasks(plugin); + server.getServicesManager().unregisterAll(plugin); + warn(Lang.plugin_disable); + System.gc(); + } + private void registerEvents(){ + pm.registerEvents(new CreatureSpawnListener(),this); + pm.registerEvents(new DragonDamageByPlayerListener(),this); + pm.registerEvents(new DragonDeathListener(),this); + pm.registerEvents(new DragonHealListener(),this); + pm.registerEvents(new EntityDamageByEntityListener(),this); + pm.registerEvents(new InventoryListener(),this); + pm.registerEvents(new PluginDisableListener(),this); + if(pm.getPlugin("MythicLib") != null){ + info("Hooking to MythicLib..."); + pm.registerEvents(new PlayerAttackListener(),this); + } + else{ + pm.registerEvents(new DragonBaseHurtListener(),this); + } + if(pm.getPlugin("MMOItems") != null){ + info("Hooking to MMOItems..."); + pm.registerEvents(new MMOPlayerAttackListener(),this); + } + } + private void registerCommands(){ + Objects.requireNonNull(getCommand("enderdragon")).setExecutor(new MainCommand()); + Objects.requireNonNull(getCommand("enderdragon")).setTabCompleter(new TabCompleter()); + } + private void unregisterCommands(){ + Objects.requireNonNull(getCommand("enderdragon")).setExecutor(null); + Objects.requireNonNull(getCommand("enderdragon")).setTabCompleter(null); + } + private void loadFiles(){ + saveDefaultConfig(); + reloadConfig(); + Config.reload(getConfig()); if (!new File(getDataFolder(), "data.yml").exists()) { this.saveResource("data.yml",false); - dataNotFound = true; } - language = plugin.getConfig().getString("lang","English"); - langPath = "lang/" + language + ".yml"; + dataF = new File(getDataFolder(),"data.yml"); + data = YamlConfiguration.loadConfiguration(dataF); + if(Config.lang.equals("")) { + error("Key \"lang\" in config is missing, please check your config.yml."); + Config.lang = "English"; + } + String langPath = "lang/" + Config.lang + ".yml"; if (!new File(getDataFolder(), langPath).exists()) { this.saveResource(langPath, false); } - sendMessage("§a[EnderDragon] Language: §6" + language); - dataF = new File(plugin.getDataFolder(),"data.yml"); langF = new File(getDataFolder(), langPath); lang = YamlConfiguration.loadConfiguration(langF); - data = YamlConfiguration.loadConfiguration(dataF); - Message.loadLanguage(); - prefix = lang.getString("prefix","§7[§eEnderDragon§7]§r "); - if(configNotFound){sendMessage(Message.configNotFound);} - if(dataNotFound){sendMessage(Message.dataNotFound);} - if(!getConfig().getString("version").equals("1.8.3") ){ - sendMessage(Message.configWrongVersion); - } - if(!data.getString("version").equals("1.8.4") ){ - sendMessage(Message.dataWrongVersion); - } - if(!lang.getString("version").equals("1.8.3") ){ - sendMessage(Message.langWrongVersion); - } - sendMessage(Message.loaded); - sendMessage("§a[EnderDragon] Author: Xanadu13"); - pm.registerEvents(new CreatureHurt(),this); - pm.registerEvents(new DragonAttack(),this); - pm.registerEvents(new DragonDeath(),this); - pm.registerEvents(new DragonHeal(),this); - pm.registerEvents(new DragonSpawn(),this); - pm.registerEvents(new InventoryClick(),this); - getCommand("enderdragon").setExecutor(new MainCommand()); - getCommand("enderdragon").setTabCompleter(new TabCompleter()); - Metrics metrics = new Metrics(this,14850); - sendMessage(Message.checkingUpdate); - try { - URLConnection conn = new URL("https://api.github.com/repos/iXanadu13/EnderDragon/releases/latest").openConnection(); - conn.setConnectTimeout(20000); - conn.setReadTimeout(60000); - InputStream is = conn.getInputStream(); - String line = new BufferedReader(new InputStreamReader(is)).readLine(); - is.close(); - String newVer = line.substring(line.indexOf("\"tag_name\"") + 13, line.indexOf("\"target_commitish\"") - 2); - String localVer = plugin.getDescription().getVersion(); - if (!localVer.equals(newVer)) { - sendMessage(Message.OutOfDate1.replace("{0}",localVer)); - sendMessage(Message.OutOfDate2.replace("{1}",newVer)); - sendMessage(Message.OutOfDate3); - } - else{ - sendMessage(Message.UpToDate.replace("{1}",newVer)); - } - } catch (Exception e) { - e.printStackTrace(); + info("Language: §6" + Config.lang); + Lang.reload(lang); + if (!new File(plugin.getDataFolder(), "gui/view.yml").exists()) { + plugin.saveResource("gui/view.yml",false); } } - - @Override - public void onDisable() - { - sendMessage(Message.onDisable); - } - - - public void sendMessage(String msg) { - Bukkit.getConsoleSender().sendMessage(msg); - } - - - public static String itemStackToString(ItemStack itemStack) { - YamlConfiguration yml = new YamlConfiguration(); - yml.set("item", itemStack); - return yml.saveToString(); - } - public static ItemStack StringToItemStack(String str) { - YamlConfiguration yml = new YamlConfiguration(); - ItemStack item; - try { - yml.loadFromString(str); - item = yml.getItemStack("item"); - } catch (InvalidConfigurationException ex) { - item = new ItemStack(Material.AIR, 1); - } - return item; - } + public static EnderDragon getInstance() {return instance;} private int getMinecraftVersion() { String[] version = getServer().getBukkitVersion().replace('-', '.').split("\\."); try { mcPatchVersion = Integer.parseInt(version[2]); - } catch (NumberFormatException ignored) { - } + } catch (NumberFormatException ignored) {} return Integer.parseInt(version[1]); } - public static boolean isSpecial(Entity e){ - if(mcMainVersion >= 11){ - return e.getScoreboardTags().contains("special"); - } - else{ - String uuid = e.getUniqueId().toString(); - return data.getStringList("special").contains(uuid); + public static void closeAllInventory() { + for (Player player : Bukkit.getOnlinePlayers()) { + try { + Inventory inventory = player.getOpenInventory().getTopInventory(); + if (!(inventory.getHolder() instanceof GUIHolder)) continue; + player.closeInventory(); + } + catch (Exception ignored) {} } } + public DragonManager getDragonManager(){ + return dragonManager; + } + } diff --git a/src/main/java/xanadu/enderdragon/commands/MainCommand.java b/src/main/java/xanadu/enderdragon/commands/MainCommand.java index 41ff121..4dda279 100644 --- a/src/main/java/xanadu/enderdragon/commands/MainCommand.java +++ b/src/main/java/xanadu/enderdragon/commands/MainCommand.java @@ -1,152 +1,158 @@ package xanadu.enderdragon.commands; -import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; -import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; -import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; -import xanadu.enderdragon.lang.Message; +import xanadu.enderdragon.EnderDragon; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.utils.Chance; +import xanadu.enderdragon.utils.FileUpdater; +import xanadu.enderdragon.utils.MyDragon; -import java.io.File; import java.io.IOException; -import java.util.Collections; -import java.util.List; import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.config.Lang.*; +import static xanadu.enderdragon.manager.DragonManager.*; +import static xanadu.enderdragon.manager.GuiManager.openGui; +import static xanadu.enderdragon.manager.RewardManager.addItem; +import static xanadu.enderdragon.manager.RewardManager.clearItem; public class MainCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { - if (args.length == 1) { - if (args[0].equalsIgnoreCase("reload")) { - if(!sender.hasPermission("ed.reload")){ - sender.sendMessage(Message.NoCommandPermission); - return false; - } - if (!new File(plugin.getDataFolder(), "config.yml").exists()) { - plugin.saveDefaultConfig(); - } - if (!new File(plugin.getDataFolder(), "data.yml").exists()) { - plugin.saveResource("data.yml", false); - } - plugin.reloadConfig(); - data = YamlConfiguration.loadConfiguration(dataF); - language = plugin.getConfig().getString("lang","Chinese"); - langPath = "lang/" + language + ".yml"; - if (!new File(plugin.getDataFolder(), langPath).exists()) { - plugin.saveResource(langPath, false); - } - langF = new File(plugin.getDataFolder(), langPath); - lang = YamlConfiguration.loadConfiguration(langF); - Message.loadLanguage(); - sender.sendMessage(prefix + Message.configReloaded); - } + if (args.length == 0) { + sendCommandTips(sender); + return false; } - else if (args.length > 1 && args[0].equalsIgnoreCase("drop") ) { - if (!(sender instanceof Player || args[1].equalsIgnoreCase("clear"))) { - sender.sendMessage(prefix + Message.PlayerCommand); - return false; - } - if (args[1].equalsIgnoreCase("add")) { - if(!sender.hasPermission("ed.drop.edit")){ - sender.sendMessage(Message.NoCommandPermission); - return false; - } - if(args.length == 3 ) { - Player p = (Player) sender; - if(p.getItemInHand().getType() == Material.AIR){ - p.sendMessage(prefix + Message.DropItemAddFail); + if (args.length == 1) { + switch (args[0].toLowerCase()){ + case "reload" -> { + if(!sender.hasPermission("ed.reload")){ + sendFeedback(sender,Lang.command_no_permission); return false; } - String ChanceStr = args[2]; - double chance = 0; - try { - chance = Double.parseDouble(ChanceStr); - } catch (NumberFormatException ex){ - p.sendMessage(prefix + Message.MustNumber + ChanceStr); - throw new NumberFormatException("\n\n" - + "\33[31;1m" + "Error: /ed drop add " + ChanceStr + "\n" - + "\33[33;1m" + "Valid: /ed drop add " +Message.Number+ "\n" - + "\33[0m"); + closeAllInventory(); + reloadAll(); + sendFeedback(sender,Lang.command_reload_config); + return true; + } + case "respawn" -> { + if(!sender.hasPermission("ed.respawn")){ + sendFeedback(sender,Lang.command_no_permission); + return false; + } + if(!(sender instanceof Player player)){ + sendFeedback(sender,Lang.command_only_player); + return false; + } + EnderDragon.getInstance().getDragonManager().initiateRespawn(player); + return true; + } + case "update" -> { + if(!sender.hasPermission("ed.update")){ + sendFeedback(sender,Lang.command_no_permission); + return false; } - List datum = data.getStringList("items"); - ItemStack item = p.getItemInHand(); - datum.add(itemStackToString(item)); - datum.add(ChanceStr); - data.set("items", datum); try { - data.save(dataF); + FileUpdater.update(); } catch (IOException e) { throw new RuntimeException(e); } - data = YamlConfiguration.loadConfiguration(dataF); - p.sendMessage(prefix + Message.DropItemAddSucceed.replace("{chance}",ChanceStr)); - + return true; } - } - if (args[1].equalsIgnoreCase("clear")) { - if(!sender.hasPermission("ed.drop.edit")){ - sender.sendMessage(Message.NoCommandPermission); + default -> { + sendCommandTips(sender); return false; } - if(args.length == 2 ) { - data.set("items",""); - try { - data.save(dataF); - } catch (IOException e) { - throw new RuntimeException(e); + } + } + if (args[0].equalsIgnoreCase("drop")) { + if(!(sender instanceof Player p)) { + sendFeedback(sender,Lang.command_only_player); + return false; + } + switch (args[1].toLowerCase()){ + case "gui" -> { + if(!sender.hasPermission("ed.drop.gui")){ + sendFeedback(sender,Lang.command_no_permission); + return false; } - data = YamlConfiguration.loadConfiguration(dataF); - sender.sendMessage(prefix + Message.ClearDropItemConfig); - } - } - if (args[1].equalsIgnoreCase("gui")) { - if(!sender.hasPermission("ed.drop.gui")){ - sender.sendMessage(Message.NoCommandPermission); - return false; - } - if(args.length == 2 ) { - Player p = (Player) sender; - String title = plugin.getConfig().getString("special-dragon.drop-gui-title"); - if(title == null){title = "";} - Inventory inv = Bukkit.createInventory(null,54,title); - List datum = data.getStringList("items"); - int max = datum.size() / 2 ; - for(int i=0 ; i lore = meta.getLore(); - if(lore != null) { - lore.add("§6("+Message.DropChance+": " + datum.get(i*2-1) + "%)§r"); - meta.setLore(lore); - } - else{ - meta.setLore(Collections.singletonList("§6("+Message.DropChance+": " + datum.get(i*2-1) + "%)§r")); - } - item.setItemMeta(meta); + if(args.length == 2){ + openGui(p, Config.main_gui); + return true; + } + if(args.length == 3){ + String key = args[2]; + MyDragon dragon = mp.get(key); + if(dragon == null){ + sendFeedback(sender,dragon_not_found); + return false; } - inv.setItem(i-1,item); - if(i == 54){break;} + openGui(p,dragon.drop_gui,key); + return true; } - p.openInventory(inv); - + } + case "clear" -> { + if(!sender.hasPermission("ed.drop.edit")){ + sendFeedback(sender,Lang.command_no_permission); + return false; + } + if(args.length == 3) { + String key = args[2]; + clearItem(key); + sendFeedback(sender,Lang.command_drop_item_clear); + return true; + } + } + case "add" -> { + if(!sender.hasPermission("ed.drop.edit")){ + sendFeedback(sender,Lang.command_no_permission); + return false; + } + if(args.length == 4) { + if(p.getInventory().getItemInMainHand().getType() == Material.AIR){ + sendFeedback(p, command_drop_item_add_empty); + return false; + } + String ChanceStr = args[3]; + String key = args[2]; + double chance = -1; + try { + chance = Double.parseDouble(ChanceStr); + } catch (NumberFormatException ex){ + sendFeedback(p,Lang.command_drop_item_add_invalid_chance + ChanceStr); + return false; + } + if(chance <= 0) { + sendFeedback(p,Lang.command_drop_item_add_invalid_chance + ChanceStr); + return false; + } + if(chance > 100) chance = 100; + ItemStack item = p.getItemInHand(); + addItem(key,item,new Chance(chance,ChanceStr)); + sendFeedback(p,Lang.command_drop_item_add_succeed.replaceAll("\\{chance}",ChanceStr)); + return true; + } + } + default -> { + sendCommandTips(sender); + return false; } } - - } - else { - sender.sendMessage(Message.CommandTips1); - sender.sendMessage(Message.CommandTips2); } + sendCommandTips(sender); return false; } + private static void sendCommandTips(CommandSender sender){ + sender.sendMessage(CommandTips1); + sender.sendMessage(CommandTips2); + sender.sendMessage(CommandTips3); + sender.sendMessage(CommandTips4); + } } diff --git a/src/main/java/xanadu/enderdragon/commands/TabCompleter.java b/src/main/java/xanadu/enderdragon/commands/TabCompleter.java index b844723..00f96dd 100644 --- a/src/main/java/xanadu/enderdragon/commands/TabCompleter.java +++ b/src/main/java/xanadu/enderdragon/commands/TabCompleter.java @@ -1,24 +1,24 @@ package xanadu.enderdragon.commands; +import org.bukkit.Bukkit; import org.bukkit.command.Command; import org.bukkit.command.CommandSender; import java.util.ArrayList; import java.util.List; +import static xanadu.enderdragon.manager.DragonManager.dragon_names; + public class TabCompleter implements org.bukkit.command.TabCompleter { - List arguments = new ArrayList<>(); - + private static final List arguments_1 = List.of(new String[]{"drop", "reload", "respawn", "update"}); + private static final List arguments_2 = List.of(new String[]{"add", "clear", "gui"}); @Override public List onTabComplete(CommandSender sender, Command command, String label, String[] args) { List result = new ArrayList<>(); if (args.length == 1) { - arguments.clear(); - arguments.add("reload"); - arguments.add("drop"); - for (String s : arguments) { + for (String s : arguments_1) { if (s.toLowerCase().startsWith(args[0].toLowerCase())) { result.add(s); } @@ -26,12 +26,8 @@ public class TabCompleter implements org.bukkit.command.TabCompleter { return result; } else if (args.length == 2){ - arguments.clear(); - arguments.add("add"); - arguments.add("clear"); - arguments.add("gui"); if(args[0].equalsIgnoreCase("drop")) { - for (String s : arguments) { + for (String s : arguments_2) { if (s.toLowerCase().startsWith(args[1].toLowerCase())) { result.add(s); } @@ -39,6 +35,17 @@ public class TabCompleter implements org.bukkit.command.TabCompleter { } return result; } + else if(args.length == 3){ + String str = args[1].toLowerCase(); + if("add".equals(str) || "clear".equals(str) || "gui".equals(str)){ + for (String s : dragon_names) { + if (s.toLowerCase().startsWith(args[2].toLowerCase())) { + result.add(s); + } + } + } + return result; + } return null; } diff --git a/src/main/java/xanadu/enderdragon/config/Config.java b/src/main/java/xanadu/enderdragon/config/Config.java new file mode 100644 index 0000000..901cee7 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/config/Config.java @@ -0,0 +1,76 @@ +package xanadu.enderdragon.config; + +import org.bukkit.configuration.file.FileConfiguration; + +import java.io.*; +import java.lang.reflect.Field; +import java.lang.reflect.Type; +import java.net.URL; +import java.net.URLConnection; +import java.util.Iterator; +import java.util.List; +import java.util.logging.Level; + +import static xanadu.enderdragon.EnderDragon.plugin; +import static xanadu.enderdragon.config.Lang.error; + +public class Config { + public static String version; + public static String lang; + public static String damage_visible_mode; + public static String special_dragon_jude_mode; + public static boolean auto_respawn_enable; + public static String auto_respawn_world_the_end_name; + public static String auto_respawn_respawn_time; + public static boolean auto_respawn_invulnerable; + public static boolean resist_player_respawn; + public static boolean resist_dragon_breath_gather; + public static String main_gui; + public static List dragon_setting_file; + public static void reload(FileConfiguration file){ + Field[] fields = Config.class.getFields(); + for(Field field : fields){ + Type type = field.getType(); + if(type.equals(java.util.List.class) || type.equals(java.lang.String.class)){ + try{ + field.set(null,""); + }catch (Exception ignored){} + } + } + Iterator it = file.getKeys(true).iterator(); + while (it.hasNext()){ + String str = it.next(); + try{ + if(file.isConfigurationSection(str)) continue; + Config.class.getField(str.replace(".","_")).set(null, file.get(str)); + }catch (Exception e){ + error("Config loading error! Key: "+str); + } + } + } + public static void saveResource(String source,String to,boolean replace){ + if (source == null || source.equals("")) return; + source = source.replace('\\', '/'); + InputStream in = plugin.getResource(source); + if (in == null) return; + File outFile = new File("plugins/EnderDragon", to); + int lastIndex = to.lastIndexOf('/'); + File outDir = new File("plugins/EnderDragon", to.substring(0, Math.max(lastIndex, 0))); + if (!outDir.exists()) { + outDir.mkdirs(); + } + try { + if (!outFile.exists() || replace) { + OutputStream out = new FileOutputStream(outFile); + byte[] buf = new byte[1024]; + int len; + while ((len = in.read(buf)) > 0) { + out.write(buf, 0, len); + } + out.close(); + in.close(); + } + } catch (IOException ignored) {} + } + +} diff --git a/src/main/java/xanadu/enderdragon/config/Lang.java b/src/main/java/xanadu/enderdragon/config/Lang.java new file mode 100644 index 0000000..4fa11a5 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/config/Lang.java @@ -0,0 +1,176 @@ +package xanadu.enderdragon.config; + +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.entity.Player; +import xanadu.enderdragon.utils.SpecialColor; + +import java.lang.reflect.Field; +import java.util.Iterator; +import java.util.List; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.EnderDragon.server; + +public class Lang { + public static String version; + public static String plugin_prefix; + public static String plugin_wrong_file_version; + public static String plugin_read_file; + public static String plugin_item_read_error; + public static String plugin_checking_update; + public static String plugin_check_update_fail; + public static String plugin_out_of_date; + public static String plugin_up_to_date; + public static String plugin_disable; + public static String plugin_file_save_error; + public static String command_no_permission; + public static String command_reload_config; + public static String command_only_player; + public static String command_drop_item_add_empty; + public static String command_drop_item_add_invalid_chance; + public static String command_drop_item_add_succeed; + public static String command_drop_item_clear; + + + public static String gui_default_title; + public static String gui_not_found; + public static String gui_item_lore; + + public static String dragon_damage_display; + public static String dragon_player_inv_full; + public static String dragon_no_killer; + public static String dragon_auto_respawn; + public static String dragon_not_found; + + + public static String CommandTips1; + public static String CommandTips2; + public static String CommandTips3; + public static String CommandTips4; + public static void reload(FileConfiguration file){ + Field[] fields = Lang.class.getFields(); + for(Field field : fields){ + try{ + field.set(null,""); + }catch (Exception ignored){} + } + Iterator it = file.getKeys(true).iterator(); + while (it.hasNext()){ + String str = it.next(); + try{ + if(!file.isString(str)) continue; + Lang.class.getField(str.replace(".","_")).set(null,SpecialColor.transGradient(file.getString(str))); + }catch (Exception e){ + error("Language loading error! Key: "+str); + } + } + CommandTips1 = SpecialColor.transGradient(lang.getString("CommandTips1","§e/ed reload §a- reload the config")); + CommandTips2 = SpecialColor.transGradient(lang.getString("CommandTips2","§e/ed respawn §a- respawn a dragon")); + CommandTips3 = SpecialColor.transGradient(lang.getString("CommandTips3","§e/ed drop gui §a- view the drop_item")); + CommandTips4 = SpecialColor.transGradient(lang.getString("CommandTips4","§e/ed drop add §a- add drop_item to one dragon")); + } + public static void sendMessage(String str) { + if(str == null) { + Bukkit.getConsoleSender().sendMessage(Lang.plugin_prefix + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + sendMessage(s); + } + } + else Bukkit.getConsoleSender().sendMessage(Lang.plugin_prefix + str); + } + public static void info(String str){ + if(str == null) { + Bukkit.getConsoleSender().sendMessage("§a[EnderDragon] " + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + info(s); + } + } + else Bukkit.getConsoleSender().sendMessage("§a[EnderDragon] "+str); + } + public static void warn(String str){ + if(str == null) { + Bukkit.getConsoleSender().sendMessage("§e[EnderDragon] " + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + warn(s); + } + } + else Bukkit.getConsoleSender().sendMessage("§e[EnderDragon] "+str); + } + public static void error(String str){ + if(str == null) { + Bukkit.getConsoleSender().sendMessage("§c[EnderDragon] " + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + error(s); + } + } + else Bukkit.getConsoleSender().sendMessage("§c[EnderDragon] "+str); + } + public static void sendFeedback(CommandSender sender,String str){ + if(str == null) { + sender.sendMessage(Lang.plugin_prefix + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + sender.sendMessage(Lang.plugin_prefix + s); + } + } + else sender.sendMessage(Lang.plugin_prefix + str); + } + public static void broadcastMSG(String str){ + if(str == null) { + Bukkit.broadcastMessage(Lang.plugin_prefix + "null"); + return; + } + if(str.contains("\\n")){ + String[] strings = str.split("\\\\n"); + for(String s : strings){ + broadcastMSG(s); + } + } + else Bukkit.broadcastMessage(Lang.plugin_prefix + str); + } + public static void broadcastMSG(List list){ + if(list == null) return; + for(String str : list){ + Bukkit.broadcastMessage(Lang.plugin_prefix + str); + } + } + public static void runCommands(List list, Player p){ + if(list == null) return; + for (String cmd : list) { + if(cmd.equals("")) continue; + if(!cmd.contains("%player%")) server.dispatchCommand(server.getConsoleSender(),cmd); + else{ + if(p != null) server.dispatchCommand(server.getConsoleSender(),cmd.replaceAll("%player%",p.getName())); + } + } + } + public static void runCommands(List list){ + if(list == null) return; + for(String cmd : list){ + if(cmd.equals("")) continue; + server.dispatchCommand(server.getConsoleSender(),cmd); + } + } + +} diff --git a/src/main/java/xanadu/enderdragon/events/DragonDamageByPlayerEvent.java b/src/main/java/xanadu/enderdragon/events/DragonDamageByPlayerEvent.java new file mode 100644 index 0000000..b3c7685 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/events/DragonDamageByPlayerEvent.java @@ -0,0 +1,56 @@ +package xanadu.enderdragon.events; + +import org.bukkit.entity.EnderDragon; +import org.bukkit.entity.Player; +import org.bukkit.event.HandlerList; +import org.bukkit.event.entity.EntityDamageByEntityEvent; + +public final class DragonDamageByPlayerEvent extends EntityDamageByEntityEvent { + private static final HandlerList handlers = new HandlerList(); + private boolean cancel = false; + private final Player damager; + private final EnderDragon dragon; + private final DamageCause cause; + private final double finalDamage; + + public DragonDamageByPlayerEvent(final Player damager, final EnderDragon dragon, final DamageCause cause, final double finalDamage) { + super(damager, dragon, cause, finalDamage); + this.damager = damager; + this.dragon = dragon; + this.cause = cause; + this.finalDamage = finalDamage; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } + + public void setCancelled(final boolean cancel) { + this.cancel = cancel; + } + + public boolean isCancelled() { + return cancel; + } + + public Player getDamager() { + return damager; + } + + public EnderDragon getDragon() { + return dragon; + } + + public DamageCause getDamagerCause() { + return cause; + } + @Override + public double getDamage() { + return finalDamage; + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/GUI.java b/src/main/java/xanadu/enderdragon/gui/GUI.java new file mode 100644 index 0000000..9843bf0 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/GUI.java @@ -0,0 +1,196 @@ +package xanadu.enderdragon.gui; + +import org.bukkit.Material; +import org.bukkit.entity.Item; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.gui.slots.DragonSlot; +import xanadu.enderdragon.gui.slots.EmptySlot; +import xanadu.enderdragon.gui.slots.ItemSlot; +import xanadu.enderdragon.manager.ItemManager; +import xanadu.enderdragon.utils.MyDragon; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; + +import static xanadu.enderdragon.manager.DragonManager.*; + +public class GUI { + protected String title; + protected int maxPage; + protected int page; + protected int size; + protected ArrayList pagedItems; + protected ArrayList pagedData; + protected List slots; + protected Inventory inv; + protected HashSet dynamics; + + protected GUI(String str,int size,int maxPage){ + this.slots = new ArrayList<>(); + this.pagedItems = new ArrayList<>(); + this.pagedData = new ArrayList<>(); + this.dynamics = new HashSet<>(); + this.title = str; + this.size = size; + this.maxPage = maxPage; + this.page = 0; + } + public GUISlot getSlot(int index){ + GUISlot slot = this.slots.get(index); + if(slot == null) return new EmptySlot(); + return slot; + } + public void setPage(int a) { + this.page = a; + for(int i=0;i= this.pagedItems.size()) { + this.pagedItems.add(new ItemStack[this.size]); + } + for(int j = 0 ; j < this.slots.size() ; j++){ + GUISlot slot = this.slots.get(j); + if (slot instanceof ItemSlot) { + ItemStack itemStack = this.pagedItems.get(i)[j]; + if (itemStack == null) { + this.pagedItems.get(i)[j] = item; + return; + } + } + } + } + } + protected void addDragon(ItemStack item,String unique_name) { + for(int i = 0 ; i < this.maxPage ; i++){ + if (i >= this.pagedItems.size()) { + this.pagedItems.add(new ItemStack[this.size]); + this.pagedData.add(new String[this.size]); + } + for(int j = 0 ; j < this.slots.size() ; j++){ + if (this.slots.get(j) instanceof DragonSlot) { + ItemStack itemStack = this.pagedItems.get(i)[j]; + if (itemStack == null) { + //itemStack = item;(可以吗？) + this.pagedItems.get(i)[j] = item; + this.pagedData.get(i)[j] = unique_name; + return; + } + } + } + } + } + public String getData(int page,int index){ + return this.pagedData.get(page)[index]; + } + public int getSize() { + return this.size; + } + public int getPage(){ + return this.page; + } + public void prev() { + if (this.page > 0) { + this.setPage(this.page - 1); + } + } + + public void addPage() { + if (this.pagedItems.size() >= this.maxPage) { + return; + } + this.pagedItems.add(new ItemStack[this.size]); + } + + public void next() { + if (this.page < this.pagedItems.size() - 1) { + this.setPage(this.page + 1); + } + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/GUIHolder.java b/src/main/java/xanadu/enderdragon/gui/GUIHolder.java new file mode 100644 index 0000000..cccfa89 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/GUIHolder.java @@ -0,0 +1,20 @@ +package xanadu.enderdragon.gui; + +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.InventoryHolder; + +public class GUIHolder implements InventoryHolder { + private final GUI gui; + + public Inventory getInventory() { + return this.gui.getInventory(); + } + + public GUI getGUI() { + return this.gui; + } + + public GUIHolder(GUI gui) { + this.gui = gui; + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/GUISlot.java b/src/main/java/xanadu/enderdragon/gui/GUISlot.java new file mode 100644 index 0000000..3bb3e0c --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/GUISlot.java @@ -0,0 +1,36 @@ +package xanadu.enderdragon.gui; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.slots.*; + +public abstract class GUISlot { + private final GUISlotType guiSlotType; + public abstract ItemStack getItem(); + public abstract ItemStack getItemOnDisable(); + protected GUISlot(GUISlotType type){ + this.guiSlotType = type; + } + public final GUISlotType getType(){ + return this.guiSlotType; + } + public static GUISlot parse(ConfigurationSection section){ + if(section == null) return new EmptySlot(); + GUISlotType guiSlotType = GUISlotType.getByName(section.getString("type")); + switch (guiSlotType) { + case ITEM_SLOT -> { + return new ItemSlot(section); + } + case DRAGON_SLOT -> { + return new DragonSlot(section); + } + case PAGE_PREV, PAGE_NEXT, PAGE_TIP, TIP -> { + return new TipSlot(guiSlotType, section); + } + case PAGE_JUMP -> { + return new PageJumpSlot(section); + } + } + return new EmptySlot(); + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/GUISlotType.java b/src/main/java/xanadu/enderdragon/gui/GUISlotType.java new file mode 100644 index 0000000..f7a5b0f --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/GUISlotType.java @@ -0,0 +1,29 @@ +package xanadu.enderdragon.gui; + +import java.util.Map; +import java.util.TreeMap; + +public enum GUISlotType { + TIP, + PAGE_TIP, + PAGE_PREV, + PAGE_NEXT, + PAGE_JUMP, + EMPTY, + ITEM_SLOT, + DRAGON_SLOT; + private static final Map mp = new TreeMap(String.CASE_INSENSITIVE_ORDER); + public static GUISlotType getByName(String str){ + if(str == null) return EMPTY; + return mp.getOrDefault(str.replaceAll("_",""),EMPTY); + } + static{ + GUISlotType[] values = values(); + for (GUISlotType guiSlotType : values) { + String name = guiSlotType.name(); + String target = "_"; + String replacement = ""; + mp.put(name.replaceAll(target, replacement), guiSlotType); + } + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/GUIWrapper.java b/src/main/java/xanadu/enderdragon/gui/GUIWrapper.java new file mode 100644 index 0000000..ffdaad6 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/GUIWrapper.java @@ -0,0 +1,82 @@ +package xanadu.enderdragon.gui; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.ConfigurationSection; +import xanadu.enderdragon.gui.slots.EmptySlot; +import xanadu.enderdragon.config.Lang; + +import java.util.HashMap; +import java.util.List; + +public class GUIWrapper extends GUI{ + private final String name; + private int type; + + public String getName() { + return this.name; + } + + public GUIWrapper(GUIWrapper a, String key) { + super(a.title, a.size, a.maxPage); + this.inv = Bukkit.createInventory(new GUIHolder(this), this.size, this.title); + this.slots.addAll(a.slots); + this.dynamics.addAll(a.dynamics); + this.name = a.name; + this.type = a.type; + this.init(); + this.resetPagedItem(type,key); + this.setPage(0); + } + public GUIWrapper(ConfigurationSection config) { + super(config.getString("Title", Lang.gui_default_title).replaceAll("&", "§"), calcline(config.getStringList("Slots").size()) * 9, config.getInt("Page", 1000)); + this.type = 0; + this.name = config.getName(); + this.inv = Bukkit.createInventory(new GUIHolder(this), this.size, this.title); + for(int i = 0 ; i < this.size ; i++){ + slots.add(new EmptySlot()); + } + ConfigurationSection section = config.getConfigurationSection("Items"); + HashMap hash = new HashMap(); + if (section == null) return; + for (String s : section.getKeys(false)) { + GUISlot slot = GUISlot.parse(section.getConfigurationSection(s)); + hash.put(s.charAt(0), slot); + } + int n2 = 0; + List stringList = config.getStringList("Slots"); + for (String line : stringList) { + int i; + for (i = 0; i < line.length() && i < 9; ++i) { + char value = line.charAt(i); + this.slots.set(n2++, (hash.getOrDefault(value, new EmptySlot()))); + } + while(i ++ < 9){ + this.slots.set(n2++, new EmptySlot()); + } + } + boolean b = false; + for(int i = 0 ; i < slots.size(); i++){ + GUISlotType type = this.slots.get(i).getType(); + if(type == GUISlotType.PAGE_PREV || type == GUISlotType.PAGE_NEXT || type == GUISlotType.PAGE_TIP){ + this.dynamics.add(i); + } + else if(type == GUISlotType.ITEM_SLOT){ + this.type = 1; + } + else if(type == GUISlotType.DRAGON_SLOT){ + this.type = 2; + } + else if (type == GUISlotType.PAGE_JUMP) { + b = true; + } + } + } + + + private static int calcline(final int a) { + if (a < 1) { + return 1; + } + return Math.min(a, 6); + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/Reward.java b/src/main/java/xanadu/enderdragon/gui/Reward.java new file mode 100644 index 0000000..1f71f6c --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/Reward.java @@ -0,0 +1,71 @@ +package xanadu.enderdragon.gui; + +import org.bukkit.Material; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import xanadu.enderdragon.utils.Chance; + +import static xanadu.enderdragon.manager.TaskManager.getCurrentTimeWithSpecialFormat; + + +public class Reward extends ItemStack { + protected String name; + protected Chance chance; + private ItemStack item; + + @Override + public String toString(){ + YamlConfiguration yaml = new YamlConfiguration(); + if(name == null){ + ItemMeta meta = item.getItemMeta(); + if(meta != null) { + String displayName = meta.getDisplayName(); + if("".equals(displayName) || displayName == null){ + name = item.getType().name().toLowerCase() + "(" + getCurrentTimeWithSpecialFormat() + ")"; + } + else name = meta.getDisplayName(); + } + else name = item.getType().name().toLowerCase() + "(" + getCurrentTimeWithSpecialFormat() + ")"; + } + + + yaml.set(name + ".data", item); + yaml.set(name + ".drop_chance.value",chance.getValue()); + yaml.set(name + ".drop_chance.format",chance.getStr()); + return yaml.saveToString(); + } + + public String getName() { + return this.name; + } +// +// @Override +// public int hashCode() { +// return this.name.hashCode(); +// } + + public ItemStack getItem() { + if(item == null) return new ItemStack(Material.AIR); + return item.clone(); + } + public Chance getChance(){ + return this.chance; + } + + + + protected Reward(ItemStack item,String chance) { + this.item = item; + + } + public Reward(ItemStack item, Chance chance){ + this.item = item; + this.chance = chance; + } + public Reward(ItemStack item){ + this.item = item; + this.chance = null; + } + +} diff --git a/src/main/java/xanadu/enderdragon/gui/slots/DragonSlot.java b/src/main/java/xanadu/enderdragon/gui/slots/DragonSlot.java new file mode 100644 index 0000000..97fe765 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/slots/DragonSlot.java @@ -0,0 +1,37 @@ +package xanadu.enderdragon.gui.slots; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.GUISlot; +import xanadu.enderdragon.gui.GUISlotType; + +public class DragonSlot extends GUISlot { + private String unique_name; + private ItemStack item; + + public DragonSlot(ConfigurationSection section) { + super(GUISlotType.DRAGON_SLOT); + } + + @Override + public ItemStack getItem() { + return new ItemStack(Material.AIR); + } + @Override + public ItemStack getItemOnDisable(){ + return this.item; + } + public void setUnique_name(String str){ + this.unique_name = str; + } + public String getUnique_name(){ + return this.unique_name; + } + + public DragonSlot(GUISlotType a, ItemStack item) { + super(a); + this.item = item; + } + +} diff --git a/src/main/java/xanadu/enderdragon/gui/slots/EmptySlot.java b/src/main/java/xanadu/enderdragon/gui/slots/EmptySlot.java new file mode 100644 index 0000000..a8c3db6 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/slots/EmptySlot.java @@ -0,0 +1,20 @@ +package xanadu.enderdragon.gui.slots; + +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.GUISlot; +import xanadu.enderdragon.gui.GUISlotType; + +public class EmptySlot extends GUISlot { + @Override + public ItemStack getItem(){ + return new ItemStack(Material.AIR); + } + @Override + public ItemStack getItemOnDisable(){ + return new ItemStack(Material.AIR); + } + public EmptySlot(){ + super(GUISlotType.EMPTY); + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/slots/ItemSlot.java b/src/main/java/xanadu/enderdragon/gui/slots/ItemSlot.java new file mode 100644 index 0000000..9076c9e --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/slots/ItemSlot.java @@ -0,0 +1,64 @@ +package xanadu.enderdragon.gui.slots; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.GUISlot; +import xanadu.enderdragon.gui.GUISlotType; + +public class ItemSlot extends GUISlot{ + private int i; +// private final LoreMap G; + private boolean XXXxxx; + private ItemStack item; + + @Override + public ItemStack getItem() { + return this.item; + } + @Override + public ItemStack getItemOnDisable(){ + return this.item; + } + + public int getMaxAmount() { + return this.i; + } + +// public boolean accept(String a) { +// if (!this.XXXxxx) { +// return true; +// } +// if (this.G.get(a) != null) { +// return true; +// } +// return false; +// } + + public ItemSlot(ConfigurationSection section) { + super(GUISlotType.ITEM_SLOT); + String str = section.getString("Item"); + if(str == null){ + this.item = new ItemStack(Material.AIR); + } + else{ +// this.item = EnderDragon.getInstance().getItemManager().stringToItemStack(str); + } + + } + +// public ItemSlot() { +// super(GUISlotType.ITEM_SLOT); +// this.G = new LoreMap(false, false, false, false); +// this.XXXxxx = false; +// this.i = 64; +// } + + public boolean acceptAll() { + if (!this.XXXxxx) { + return true; + } + return false; + } + +} diff --git a/src/main/java/xanadu/enderdragon/gui/slots/PageJumpSlot.java b/src/main/java/xanadu/enderdragon/gui/slots/PageJumpSlot.java new file mode 100644 index 0000000..a4da083 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/slots/PageJumpSlot.java @@ -0,0 +1,26 @@ +package xanadu.enderdragon.gui.slots; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.GUISlotType; + +import static xanadu.enderdragon.manager.ItemManager.readAsItem; + +public class PageJumpSlot extends TipSlot{ + private final String name; + private ItemStack item; + + public String getGuiName() { + return this.name; + } + + public PageJumpSlot(ConfigurationSection section) { + super(GUISlotType.PAGE_JUMP, section); + this.name = section.getString("gui"); + this.item = readAsItem(section,"data"); + } + @Override + public ItemStack getItem() { + return this.item; + } +} diff --git a/src/main/java/xanadu/enderdragon/gui/slots/TipSlot.java b/src/main/java/xanadu/enderdragon/gui/slots/TipSlot.java new file mode 100644 index 0000000..5694e13 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/gui/slots/TipSlot.java @@ -0,0 +1,44 @@ +package xanadu.enderdragon.gui.slots; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import xanadu.enderdragon.gui.GUISlot; +import xanadu.enderdragon.gui.GUISlotType; + +import static xanadu.enderdragon.manager.ItemManager.readAsItem; + +public class TipSlot extends GUISlot { + private ItemStack item; + private ItemStack itemOnDisable; + public TipSlot(GUISlotType slotType, Material material, String str) { + super(slotType); + this.item = new ItemStack(material); + ItemMeta meta = this.item.getItemMeta(); + meta.setDisplayName(str); + this.item.setItemMeta(meta); + } + + public TipSlot(GUISlotType slotType, ConfigurationSection section) { + super(slotType); + this.item = readAsItem(section,"data"); + if(slotType == GUISlotType.PAGE_PREV || slotType == GUISlotType.PAGE_NEXT){ + this.itemOnDisable = readAsItem(section,"data_disable"); + } + } + + @Override + public ItemStack getItem() { + return this.item; + } + @Override + public ItemStack getItemOnDisable(){ + return this.itemOnDisable; + } + + public TipSlot(GUISlotType a, ItemStack item) { + super(a); + this.item = item; + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/CreatureSpawnListener.java b/src/main/java/xanadu/enderdragon/listeners/CreatureSpawnListener.java new file mode 100644 index 0000000..139ec49 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/CreatureSpawnListener.java @@ -0,0 +1,127 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.*; +import org.bukkit.attribute.Attribute; +import org.bukkit.block.Block; +import org.bukkit.boss.BarColor; +import org.bukkit.boss.BarStyle; +import org.bukkit.boss.BossBar; +import org.bukkit.entity.*; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.entity.CreatureSpawnEvent; +import org.bukkit.event.entity.EntitySpawnEvent; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.potion.PotionEffect; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.utils.MyDragon; + +import java.util.Collection; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.manager.DragonManager.*; + +public class CreatureSpawnListener implements Listener { + @EventHandler(priority = EventPriority.LOW) + public void OnDragonSpawn(CreatureSpawnEvent e){ + if(!(e.getEntity() instanceof EnderDragon dragon)) return; + MyDragon myDragon = judge(); + if(myDragon == null) { + Lang.warn("special_dragon_jude_mode setting error!"); + return; + } + setSpecialKey(dragon, myDragon.unique_name); + int times = data.getInt("times"); + Lang.runCommands(myDragon.spawn_cmd); + for(String str : myDragon.spawn_broadcast_msg){ + Lang.broadcastMSG(str.replaceAll("%times%",String.valueOf(times))); + } + dragon.setCustomName(myDragon.display_name); + modifyAttribute(dragon, Attribute.GENERIC_MAX_HEALTH, myDragon.max_health - 200); + dragon.setHealth(myDragon.spawn_health); + modifyAttribute(dragon, Attribute.GENERIC_MOVEMENT_SPEED, myDragon.move_speed_modify); + modifyAttribute(dragon, Attribute.GENERIC_ARMOR, myDragon.armor_modify); + modifyAttribute(dragon, Attribute.GENERIC_ARMOR_TOUGHNESS, myDragon.armor_toughness_modify); + String color = myDragon.glow_color.toUpperCase(); + if(!color.equals("NONE")){ + ChatColor chatColor; + if(color.equals("RANDOM")) chatColor = randomColor(); + else chatColor = ChatColor.valueOf(color); + setGlowingColor(dragon,chatColor); + } + else dragon.setGlowing(false); + if(mcMainVersion >= 14 || mcMainVersion >= 13 && mcPatchVersion >= 2){ + BossBar bossBar = dragon.getBossBar(); + if(bossBar != null){ + bossBar.setColor(BarColor.valueOf(myDragon.bossbar_color.toUpperCase())); + bossBar.setStyle(BarStyle.valueOf(myDragon.bossbar_style.toUpperCase())); + } + } + } + @EventHandler(priority = EventPriority.HIGHEST) + public void OnCrystalPlaced(final PlayerInteractEvent e){ + if(!Config.resist_player_respawn) return; + if(e.getAction() != Action.RIGHT_CLICK_BLOCK) return; + if(e.getMaterial() != Material.END_CRYSTAL) return; + if(e.getClickedBlock() == null) return; + Material blockType = e.getClickedBlock().getType(); + if(blockType != Material.OBSIDIAN && blockType != Material.BEDROCK) return; + World world = e.getPlayer().getWorld(); + if(world.getEnvironment() != World.Environment.THE_END) return; + Block block = e.getClickedBlock(); + int d0 = block.getX(); + int d1 = block.getY() + 1; + int d2 = block.getZ(); + if(d0>=6 || d0<=-6 || d2>=6 || d2<=-6) return; + if(world.getBlockAt(d0, d1, d2).getType() != Material.AIR) return; + Location cen = block.getLocation().clone().add(0.5,1,0.5); + Collection list = world.getNearbyEntities(cen,0.5,1,0.5); + if(!list.isEmpty()) return; + e.setCancelled(true); + EnderCrystal crystal = (EnderCrystal) world.spawnEntity(cen,EntityType.ENDER_CRYSTAL); + crystal.setShowingBottom(false); + } + @EventHandler(priority = EventPriority.HIGH) + public void OnEffectCloudSpawn(final EntitySpawnEvent e){ + if(!(e.getEntity() instanceof AreaEffectCloud effectCloud)) return; + if(effectCloud.getSource() == null) return; + if(!(effectCloud.getSource() instanceof EnderDragon dragon)) return; + String unique_name = getSpecialKey(dragon); + if(unique_name == null) return; + MyDragon myDragon = mp.get(unique_name); + if(myDragon == null) return; + effectCloud.setRadius((float) myDragon.effect_cloud_original_radius); + effectCloud.setRadiusPerTick((float) myDragon.effect_cloud_expand_speed/20f); + effectCloud.setDuration(myDragon.effect_cloud_duration * 20); + if(myDragon.effect_cloud_color_R != -1){ + effectCloud.setParticle(Particle.SPELL_MOB); + effectCloud.setColor(Color.fromRGB(myDragon.effect_cloud_color_R,myDragon.effect_cloud_color_G,myDragon.effect_cloud_color_B)); + } + effectCloud.clearCustomEffects(); + for(PotionEffect effect : myDragon.effect_cloud_potion){ + effectCloud.addCustomEffect(effect,true); + } + } + @EventHandler(priority = EventPriority.LOW) + public void OnDragonBreathGather(final PlayerInteractEvent e){ + if(!Config.resist_dragon_breath_gather) return; + if(e.getMaterial() != Material.GLASS_BOTTLE) return; + if(e.getAction() != Action.RIGHT_CLICK_BLOCK && e.getAction() != Action.RIGHT_CLICK_AIR) return; + World world = e.getPlayer().getWorld(); + if(world.getEnvironment() != World.Environment.THE_END) return; + Player p = e.getPlayer(); + Location cen = p.getLocation().clone().add(0d,0.9d,0d); + Collection list = world.getNearbyEntities(cen,2.3d,2.9d,2.3d); + for(Entity entity : list){ + if(entity instanceof AreaEffectCloud effectCloud) { + if(effectCloud.getSource() instanceof EnderDragon){ + e.setCancelled(true); + break; + } + } + } + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/DragonBaseHurtListener.java b/src/main/java/xanadu/enderdragon/listeners/DragonBaseHurtListener.java new file mode 100644 index 0000000..f9b6b4d --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/DragonBaseHurtListener.java @@ -0,0 +1,29 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.entity.*; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import xanadu.enderdragon.events.DragonDamageByPlayerEvent; + +import static xanadu.enderdragon.EnderDragon.pm; + +public class DragonBaseHurtListener implements Listener { + @EventHandler(priority = EventPriority.HIGHEST) + public void BaseAttackToDragon(EntityDamageByEntityEvent e){ + if(e.isCancelled()) return; + if(e.getDamage() <= 0.0) return; + Entity victim = e.getEntity(); + Entity entity = e.getDamager(); + if(victim instanceof EnderDragon dragon){ + if(entity instanceof Player player){ + pm.callEvent(new DragonDamageByPlayerEvent(player,dragon,e.getCause(),e.getFinalDamage())); + } + else if(entity instanceof Projectile projectile){ + if(!(projectile.getShooter() instanceof Player damager)) return; + pm.callEvent(new DragonDamageByPlayerEvent(damager,dragon,e.getCause(),e.getFinalDamage())); + } + } + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/DragonDamageByPlayerListener.java b/src/main/java/xanadu/enderdragon/listeners/DragonDamageByPlayerListener.java new file mode 100644 index 0000000..ec0e473 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/DragonDamageByPlayerListener.java @@ -0,0 +1,38 @@ +package xanadu.enderdragon.listeners; + +import net.md_5.bungee.api.ChatMessageType; +import net.md_5.bungee.api.chat.TextComponent; +import org.bukkit.entity.EnderDragon; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.events.DragonDamageByPlayerEvent; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.utils.MathUtils; + +public class DragonDamageByPlayerListener implements Listener { + @EventHandler(priority = EventPriority.HIGHEST) + public void OnDragonDamageByPlayer(DragonDamageByPlayerEvent e){ + Player p = e.getDamager(); + double damage = e.getFinalDamage(); + EnderDragon dragon = e.getDragon(); + double max_health = dragon.getMaxHealth(); + double remain_health = Math.max(dragon.getHealth()-e.getFinalDamage(),0.0); + String str = Lang.dragon_damage_display.replaceAll("%damage%", format(damage)).replaceAll("%remain_health%",format(remain_health)).replaceAll("%max_health%",format(max_health)); + switch (Config.damage_visible_mode.toLowerCase()){ + case "actionbar" -> p.spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(str)); + case "chatbox" -> Lang.sendFeedback(p,str); + case "subtitle" -> p.sendTitle("",str,5,40,5); + default -> { + + } + + } + } + private String format(double d0){ + return String.valueOf(MathUtils.div(d0,1,2)); + } + +} diff --git a/src/main/java/xanadu/enderdragon/listeners/DragonDeathListener.java b/src/main/java/xanadu/enderdragon/listeners/DragonDeathListener.java new file mode 100644 index 0000000..a2a8348 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/DragonDeathListener.java @@ -0,0 +1,105 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.entity.EnderDragon; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDeathEvent; +import org.bukkit.inventory.ItemStack; +import org.bukkit.scheduler.BukkitRunnable; +import xanadu.enderdragon.gui.Reward; +import xanadu.enderdragon.utils.MyDragon; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.config.Lang.*; +import static xanadu.enderdragon.manager.DragonManager.getSpecialKey; +import static xanadu.enderdragon.manager.DragonManager.mp; + +public class DragonDeathListener implements Listener { + @EventHandler + public void OnDragonDeath(EntityDeathEvent e){ + if(!(e.getEntity() instanceof EnderDragon dragon)) return; + String unique_name = getSpecialKey(dragon); + if(unique_name == null) return; + MyDragon myDragon = mp.get(unique_name); + if(myDragon == null) return; + int times = data.getInt("times"); + data.set("times",times+1); + try{ + data.save(dataF); + }catch (IOException ex){ + error(plugin_file_save_error.replaceAll("\\{file_name}",dataF.getName())); + } + e.setDroppedExp(myDragon.exp_drop); + if(myDragon.dragon_egg_spawn_chance > ThreadLocalRandom.current().nextDouble(100)){ + BukkitRunnable runnable = new BukkitRunnable() { + @Override + public void run() { + Block block = e.getEntity().getWorld().getBlockAt(myDragon.dragon_egg_spawn_x, myDragon.dragon_egg_spawn_y, myDragon.dragon_egg_spawn_z); + block.setType(Material.DRAGON_EGG); + } + }; + runnable.runTaskLater(plugin, myDragon.dragon_egg_spawn_delay); + } + Player p = e.getEntity().getKiller(); + List list = new ArrayList<>(); + for(Reward reward : myDragon.datum){ + double chance = reward.getChance().getValue(); + if(chance > ThreadLocalRandom.current().nextDouble(100)){ + list.add(reward.getItem()); + } + } + if(!list.isEmpty()){ + boolean warn = false; + if(p == null){ + Location loc = dragon.getLocation(); + World world = dragon.getWorld(); + list.forEach(item -> world.dropItem(loc,item)); + } + else{ + for(ItemStack item : list){ + if(p.getInventory().firstEmpty() == -1){ + p.getWorld().dropItem(p.getLocation(),item); + warn = true; + } + else p.getInventory().addItem(item); + } + } + if(warn) sendFeedback(p, dragon_player_inv_full); + } + runCommands(myDragon.death_cmd,p); + if(p != null){ + for(String str : myDragon.msg_to_killer){ + sendFeedback(p,str); + } + for(String str : myDragon.death_broadcast_msg){ + broadcastMSG(str.replaceAll("%times%",String.valueOf(times)).replaceAll("%player%",p.getDisplayName())); + } + } + else{ + StringBuilder names = new StringBuilder(); + List entities = dragon.getNearbyEntities(5,5,5); + for (Entity entity : entities) { + if (entity instanceof Player) { + names.append(((Player) entity).getDisplayName()).append(","); + } + } + String name = names.toString(); + if(name.equals("")) name = dragon_no_killer; + if(name.endsWith(",")) name = name.substring(0,name.length()-1); + for(String str : myDragon.death_broadcast_msg){ + broadcastMSG(str.replaceAll("%times%",String.valueOf(times)).replaceAll("%player%", name)); + } + } + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/DragonHealListener.java b/src/main/java/xanadu/enderdragon/listeners/DragonHealListener.java new file mode 100644 index 0000000..66d1203 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/DragonHealListener.java @@ -0,0 +1,24 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.entity.EnderDragon; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityRegainHealthEvent; +import xanadu.enderdragon.utils.MyDragon; + +import static xanadu.enderdragon.manager.DragonManager.getSpecialKey; +import static xanadu.enderdragon.manager.DragonManager.mp; + +public class DragonHealListener implements Listener { + @EventHandler(priority = EventPriority.HIGH) + public void OnDragonHeal(EntityRegainHealthEvent e){ + if(!(e.getEntity() instanceof EnderDragon dragon)) return; + if(!e.getRegainReason().equals(EntityRegainHealthEvent.RegainReason.ENDER_CRYSTAL)) return; + String unique_name = getSpecialKey(dragon); + if(unique_name == null) return; + MyDragon myDragon = mp.get(unique_name); + if(myDragon == null) return; + e.setAmount(myDragon.crystal_heal_speed / 2d); + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/EntityDamageByEntityListener.java b/src/main/java/xanadu/enderdragon/listeners/EntityDamageByEntityListener.java new file mode 100644 index 0000000..cf701df --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/EntityDamageByEntityListener.java @@ -0,0 +1,55 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.entity.*; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.potion.PotionEffect; +import xanadu.enderdragon.events.DragonDamageByPlayerEvent; +import xanadu.enderdragon.utils.MyDragon; + +import static xanadu.enderdragon.EnderDragon.pm; +import static xanadu.enderdragon.manager.DragonManager.getSpecialKey; +import static xanadu.enderdragon.manager.DragonManager.mp; + +public class EntityDamageByEntityListener implements Listener { + @EventHandler(priority = EventPriority.LOW) + public void OnDragonAttack(EntityDamageByEntityEvent e){ + Entity victim = e.getEntity(); + Entity attack = e.getDamager(); + if(!(attack instanceof EnderDragon dragon)) return; + String unique_name = getSpecialKey(dragon); + if(unique_name == null) return; + MyDragon myDragon = mp.get(unique_name); + if(myDragon == null) return; + e.setDamage(Math.max(0.1, e.getDamage() + myDragon.attack_damage_modify)); + if(victim instanceof Player player){ + for(PotionEffect effect : myDragon.attack_potion_effect){ + player.addPotionEffect(effect); + } + if(!myDragon.suck_blood_enable) return; + double suck = e.getFinalDamage() * myDragon.suck_blood_rate + myDragon.suck_blood_base_amount; + dragon.setHealth(Math.min(dragon.getHealth()+suck,dragon.getMaxHealth())); + } + else{ + if(!myDragon.suck_blood_enable) return; + if(myDragon.suck_blood_only_player) return; + double suck = e.getFinalDamage() * myDragon.suck_blood_rate + myDragon.suck_blood_base_amount; + dragon.setHealth(Math.min(dragon.getHealth()+suck,dragon.getMaxHealth())); + } + } + @EventHandler(priority = EventPriority.HIGHEST) + public void ExtraAttackToDragon(EntityDamageByEntityEvent e){ + if(e.isCancelled()) return; + if(e.getDamage() <= 0.0) return; + Entity victim = e.getEntity(); + Entity entity = e.getDamager(); + if(victim instanceof EnderDragon dragon){ + if(entity instanceof TNTPrimed tnt){ + if(!(tnt.getSource() instanceof Player damager)) return; + pm.callEvent(new DragonDamageByPlayerEvent(damager,dragon,e.getCause(),e.getFinalDamage())); + } + } + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/InventoryListener.java b/src/main/java/xanadu/enderdragon/listeners/InventoryListener.java new file mode 100644 index 0000000..4853c62 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/InventoryListener.java @@ -0,0 +1,86 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryDragEvent; +import org.bukkit.inventory.InventoryHolder; +import org.bukkit.inventory.PlayerInventory; +import xanadu.enderdragon.gui.GUISlot; +import xanadu.enderdragon.gui.GUISlotType; +import xanadu.enderdragon.gui.GUIWrapper; +import xanadu.enderdragon.gui.GUIHolder; +import xanadu.enderdragon.gui.slots.PageJumpSlot; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.manager.GuiManager; +import xanadu.enderdragon.utils.MyDragon; + +import static xanadu.enderdragon.manager.DragonManager.mp; + +public class InventoryListener implements Listener { + @EventHandler(priority = EventPriority.LOWEST) + public void OnInventoryClick(InventoryClickEvent e){ + InventoryHolder holder = e.getInventory().getHolder(); + if(!(holder instanceof GUIHolder guiHolder)) return; + if(!(guiHolder.getGUI() instanceof GUIWrapper guiWrapper)) return; + if(e.getClickedInventory() instanceof PlayerInventory){ + e.setCancelled(true); + return; + } + if(e.getClick() != ClickType.LEFT && e.getClick() != ClickType.RIGHT){ + e.setCancelled(true); + return; + } + if(e.getRawSlot() >= 54 || e.getRawSlot() < 0){ //点击箱子以外界面会返回-999 + e.setCancelled(true); + return; + } + Player p = (Player) e.getWhoClicked(); + GUISlot slot = guiWrapper.getSlot(e.getRawSlot()); + GUISlotType type = slot.getType(); + if(type == GUISlotType.EMPTY || type == GUISlotType.TIP || type == GUISlotType.PAGE_TIP || type == GUISlotType.ITEM_SLOT){ + e.setCancelled(true); + return; + } + if(type == GUISlotType.PAGE_PREV){ + e.setCancelled(true); + guiWrapper.prev(); + p.updateInventory(); + return; + } + if(type == GUISlotType.PAGE_NEXT){ + e.setCancelled(true); + guiWrapper.next(); + p.updateInventory(); + return; + } + if(type == GUISlotType.PAGE_JUMP){ + e.setCancelled(true); + String name = ((PageJumpSlot)slot).getGuiName(); + GuiManager.openGui(p,name); + return; + } + if(type == GUISlotType.DRAGON_SLOT){ + e.setCancelled(true); + String unique_name = guiWrapper.getData(guiWrapper.getPage(),e.getRawSlot()); + MyDragon dragon = mp.get(unique_name); + if(dragon == null){ + Lang.sendFeedback(p,Lang.gui_not_found); + return; + } + GuiManager.openGui(p,dragon.drop_gui,dragon.unique_name); + return; + } + + } + @EventHandler(priority = EventPriority.LOWEST) + public void OnInventoryDrag(InventoryDragEvent e){ + InventoryHolder holder = e.getInventory().getHolder(); + if(!(holder instanceof GUIHolder guiHolder)) return; + if(!(guiHolder.getGUI() instanceof GUIWrapper guiWrapper)) return; + e.setCancelled(true); + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/PluginDisableListener.java b/src/main/java/xanadu/enderdragon/listeners/PluginDisableListener.java new file mode 100644 index 0000000..3a1b4db --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/PluginDisableListener.java @@ -0,0 +1,16 @@ +package xanadu.enderdragon.listeners; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.server.PluginDisableEvent; + +import static xanadu.enderdragon.EnderDragon.*; + +public class PluginDisableListener implements Listener { + @EventHandler + public void OnPluginDisable(PluginDisableEvent e){ + if(e.getPlugin().equals(plugin)){ + disableAll(); + } + } +} diff --git a/src/main/java/xanadu/enderdragon/listeners/mmoitems/MMOPlayerAttackListener.java b/src/main/java/xanadu/enderdragon/listeners/mmoitems/MMOPlayerAttackListener.java new file mode 100644 index 0000000..6294eba --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/mmoitems/MMOPlayerAttackListener.java @@ -0,0 +1,38 @@ +package xanadu.enderdragon.listeners.mmoitems; + +import io.lumine.mythic.lib.MythicLib; +import io.lumine.mythic.lib.api.event.PlayerAttackEvent; +import io.lumine.mythic.lib.api.item.NBTItem; +import io.lumine.mythic.lib.damage.MeleeAttackMetadata; +import net.Indyuce.mmoitems.api.Type; +import net.Indyuce.mmoitems.api.TypeSet; +import net.Indyuce.mmoitems.api.interaction.weapon.Weapon; +import net.Indyuce.mmoitems.api.player.PlayerData; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; + +public class MMOPlayerAttackListener implements Listener { + + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) + public void meleeAttacks(PlayerAttackEvent e) { + if (!(e.getAttack() instanceof MeleeAttackMetadata attackMetadata)) { + return; + } + Player player = e.getPlayer(); + PlayerData playerData = PlayerData.get(player); + NBTItem nBTItem = MythicLib.plugin.getVersion().getWrapper().getNBTItem(player.getInventory().getItem(attackMetadata.getHand().toBukkit())); + if (nBTItem.hasType() && Type.get(nBTItem.getType()) != Type.BLOCK) { + Weapon weapon = new Weapon(playerData, nBTItem); + if (weapon.getMMOItem().getType().getItemSet() == TypeSet.RANGE) { + e.setCancelled(true); + } else if (!weapon.checkItemRequirements()) { + e.setCancelled(true); + } else if (!weapon.handleTargetedAttack(e.getAttack(), e.getEntity())) { + e.setCancelled(true); + } + } + } + +} diff --git a/src/main/java/xanadu/enderdragon/listeners/mythiclib/PlayerAttackListener.java b/src/main/java/xanadu/enderdragon/listeners/mythiclib/PlayerAttackListener.java new file mode 100644 index 0000000..29af239 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/listeners/mythiclib/PlayerAttackListener.java @@ -0,0 +1,33 @@ +package xanadu.enderdragon.listeners.mythiclib; + +import io.lumine.mythic.lib.api.event.PlayerAttackEvent; +import io.lumine.mythic.lib.damage.DamageMetadata; +import io.lumine.mythic.lib.damage.DamageType; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import xanadu.enderdragon.events.DragonDamageByPlayerEvent; + +import static xanadu.enderdragon.EnderDragon.pm; + +public class PlayerAttackListener implements Listener { + @EventHandler(priority = EventPriority.HIGH) + public void onPlayerAttack(PlayerAttackEvent e){ + if(e.isCancelled()) return; + if(!(e.getEntity() instanceof org.bukkit.entity.EnderDragon dragon)) return; + DamageMetadata damage = e.getDamage(); + double weapon = damage.getDamage(DamageType.WEAPON) + damage.getDamage(DamageType.UNARMED); + if(weapon > 0.0d) { + DragonDamageByPlayerEvent event = new DragonDamageByPlayerEvent(e.getAttacker().getPlayer(),dragon, e.toBukkit().getCause(), weapon); + pm.callEvent(event); + return; + } + double skill = damage.getDamage(DamageType.SKILL); + if(skill >= 0.0d){ + DragonDamageByPlayerEvent event = new DragonDamageByPlayerEvent(e.getAttacker().getPlayer(),dragon, e.toBukkit().getCause(), skill); + pm.callEvent(event); + return; + } + } + +} diff --git a/src/main/java/xanadu/enderdragon/manager/DragonManager.java b/src/main/java/xanadu/enderdragon/manager/DragonManager.java new file mode 100644 index 0000000..36b61b9 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/manager/DragonManager.java @@ -0,0 +1,406 @@ +package xanadu.enderdragon.manager; + +import org.bukkit.*; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeInstance; +import org.bukkit.attribute.AttributeModifier; +import org.bukkit.boss.DragonBattle; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.*; +import org.bukkit.potion.PotionEffect; +import org.bukkit.potion.PotionEffectType; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scoreboard.Team; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.utils.MyDragon; +import xanadu.enderdragon.utils.Version; + +import java.io.File; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.*; +import java.util.concurrent.ThreadLocalRandom; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.config.Lang.*; +import static xanadu.enderdragon.manager.ItemManager.readAsItem; + +public class DragonManager { + public static ArrayList dragons = new ArrayList<>(); + public static HashMap mp = new HashMap<>(); + public static List dragon_names = new ArrayList<>(); + private static int sum = 0; + private static final int[][] nxt = {{3,0},{0,3},{-3,0},{0,-3}}; + private Method DragonBattle_e; + private Method getX; + private Method getY; + private Method getZ; + private Method getNMSWord; + private Class CraftWorldClass = null; + private Class WorldProviderTheEndClass = null; + + public static void reload(){ + new BukkitRunnable(){ + @Override + public void run(){ + dragons.clear(); + mp.clear(); + dragon_names.clear(); + sum = 0; + if(Config.dragon_setting_file == null){ + error("\"dragon_setting_file\" in config.yml is empty!"); + warn("Plugin will use the default config..."); + Config.dragon_setting_file = new ArrayList<>(); + Config.dragon_setting_file.add("default:5"); + Config.dragon_setting_file.add("special:5"); + } + for(String str : Config.dragon_setting_file){ + String[] s = str.split(":"); + if(s.length != 2){ + error("\"dragon_setting_file\" in config.yml error! Key: " + str); + continue; + } + String path = "setting/" + s[0] + ".yml"; + int edge = -1; + try { + edge = Integer.parseInt(s[1]); + } catch (NumberFormatException ignored){} + if(edge < 0) { + error("\"dragon_setting_file\" in config.yml error! Key: " + str); + continue; + } + File file = new File(plugin.getDataFolder(),path); + if(!file.exists()) { + try{ + plugin.saveResource("setting/"+file.getName(),false); + file = new File(plugin.getDataFolder(),path); + }catch (Exception ignored){ + error("Not Found setting/" + s[0] + ".yml ,skipped it."); + continue; + } + } + FileConfiguration fc = YamlConfiguration.loadConfiguration(file); + readSettingFile(fc,edge); + } + dragons.sort((o1, o2) -> o2.priority - o1.priority); + RewardManager.reload(); + } + }.runTaskAsynchronously(plugin); + + } + public static MyDragon judge(){ + if(Config.special_dragon_jude_mode.equalsIgnoreCase("edge")){ + int cnt = 0, random = ThreadLocalRandom.current().nextInt(0, sum); + for(MyDragon cur : dragons){ + if(cnt <= random && cnt + cur.edge > random){ + return cur; + } + cnt += cur.edge; + } + } + else if(Config.special_dragon_jude_mode.equalsIgnoreCase("pc")){ + Iterator it = dragons.iterator(); + MyDragon cur = null; + while (it.hasNext()){ + cur = it.next(); + boolean judge = cur.spawn_chance > ThreadLocalRandom.current().nextDouble(100); + if(judge) return cur; + } + return cur; + } + return null; + } + public static void setSpecialKey(Entity e, String key){ + e.addScoreboardTag(key); + } + public static String getSpecialKey(Entity e){ + for(MyDragon a : dragons){ + if(e.getScoreboardTags().contains(a.unique_name)) return a.unique_name; + } + return null; + } + public static void readSettingFile(FileConfiguration f,int edge){ + MyDragon myDragon = new MyDragon(); + myDragon.unique_name = f.getString("unique_name","default"); + if(mp.containsKey(myDragon.unique_name)){ + error("The unique_name conflict! Key: "+myDragon.unique_name); + return; + } + myDragon.icon = readAsItem(f,"icon"); + myDragon.display_name = f.getString("display_name","Special Dragon"); + myDragon.drop_gui = f.getString("drop_gui"); + myDragon.edge = edge; + myDragon.priority = f.getInt("priority",1); + myDragon.spawn_chance = f.getDouble("spawn_chance",0); + myDragon.max_health = f.getInt("max_health",200); + myDragon.spawn_health = f.getInt("spawn_health",200); + myDragon.exp_drop = f.getInt("exp_drop",500); + myDragon.dragon_egg_spawn_delay = f.getInt("dragon_egg_spawn.delay",410); + myDragon.dragon_egg_spawn_x = f.getInt("dragon_egg_spawn.x",0); + myDragon.dragon_egg_spawn_y = f.getInt("dragon_egg_spawn.y",70); + myDragon.dragon_egg_spawn_z = f.getInt("dragon_egg_spawn.z",0); + myDragon.dragon_egg_spawn_chance = f.getDouble("dragon_egg_spawn.chance",0); + myDragon.attack_damage_modify = f.getDouble("attack_damage_modify",0); + myDragon.move_speed_modify = f.getDouble("move_speed_modify",0); + myDragon.armor_modify = f.getDouble("armor_modify",0); + myDragon.armor_toughness_modify = f.getDouble("armor_toughness_modify",0); + myDragon.crystal_heal_speed = f.getDouble("crystal_heal_speed",2.0); + myDragon.suck_blood_enable = f.getBoolean("suck_blood.enable",true); + myDragon.suck_blood_rate = f.getDouble("suck_blood.rate",50) / 100d; + myDragon.suck_blood_base_amount = f.getDouble("suck_blood.base_amount",1); + myDragon.suck_blood_only_player = f.getBoolean("suck_blood.only_player",true); + List stringList = f.getStringList("attack_potion_effect"); + List potions = new ArrayList<>(); + for(String string : stringList){ + String[] s = string.split(" "); + if(s.length != 3) continue; + PotionEffectType type = PotionEffectType.getByName(s[0].toUpperCase()); + if(type == null){ + error("Unknown potion type: " + s[0]); + continue; + } + int duration = -1; + try { + duration = Integer.parseInt(s[1]); + } catch (NumberFormatException ex){ + error("Wrong number format: " + s[1]); + } + if(duration == -1) continue; + int level = -1; + try { + level = Integer.parseInt(s[2]); + } catch (NumberFormatException ex){ + error("Wrong number format: " + s[2]); + } + if(level == -1) continue; + PotionEffect potionEffect = new PotionEffect(type,duration*20,level-1); + potions.add(potionEffect); + } + myDragon.attack_potion_effect = potions; + myDragon.spawn_cmd = f.getStringList("spawn_cmd"); + myDragon.death_cmd = f.getStringList("death_cmd"); + myDragon.spawn_broadcast_msg = f.getStringList("spawn_broadcast_msg"); + myDragon.death_broadcast_msg = f.getStringList("death_broadcast_msg"); + myDragon.msg_to_killer = f.getStringList("msg_to_killer"); + myDragon.glow_color = f.getString("glow_color","random"); + myDragon.bossbar_color = f.getString("bossbar.color","WHITE"); + myDragon.bossbar_style = f.getString("bossbar.style","SOLID"); + myDragon.effect_cloud_original_radius = f.getDouble("effect_cloud.original_radius",3); + myDragon.effect_cloud_expand_speed = f.getDouble("effect_cloud.expand_speed",0.1333333); + myDragon.effect_cloud_duration = f.getInt("effect_cloud.duration",60); + String effect_cloud_color = f.getString("effect_cloud.color","none"); + String[] s0 = effect_cloud_color.split(":"); + if(s0.length != 3) myDragon.effect_cloud_color_R = -1; + else{ + try{ + myDragon.effect_cloud_color_R = Integer.parseInt(s0[0]); + myDragon.effect_cloud_color_G = Integer.parseInt(s0[1]); + myDragon.effect_cloud_color_B = Integer.parseInt(s0[2]); + } + catch (NumberFormatException e){ + error("Wrong effect_cloud_color format!"); + myDragon.effect_cloud_color_R = -1; + } + } + List stringList2 = f.getStringList("effect_cloud.potion"); + List effectCloudPotions = new ArrayList<>(); + for(String string : stringList2){ + String[] s = string.split(" "); + if(s.length != 3) continue; + PotionEffectType type = PotionEffectType.getByName(s[0].toUpperCase()); + if(type == null){ + error("Unknown potion type: " + s[0]); + continue; + } + int duration = -1; + try { + duration = Integer.parseInt(s[1]); + } catch (NumberFormatException ex){ + error("Wrong number format: " + s[1]); + } + if(duration == -1) continue; + int level = -1; + try { + level = Integer.parseInt(s[2]); + } catch (NumberFormatException ex){ + error("Wrong number format: " + s[2]); + } + if(level == -1) continue; + PotionEffect potionEffect = new PotionEffect(type,duration*20,level-1); + effectCloudPotions.add(potionEffect); + } + myDragon.effect_cloud_potion = effectCloudPotions; + dragons.add(myDragon); + mp.put(myDragon.unique_name,myDragon); + dragon_names.add(myDragon.unique_name); + sum += edge; + } + public static void disable(){ + dragons.clear(); + mp.clear(); + dragon_names.clear(); + } + public static void modifyAttribute(EnderDragon dragon, Attribute attribute, double amount){ + AttributeInstance instance = dragon.getAttribute(attribute); + assert instance != null; + instance.addModifier(new AttributeModifier("EnderDragon",amount,AttributeModifier.Operation.ADD_NUMBER)); + } + public static ChatColor randomColor(){ + return ChatColor.values()[ThreadLocalRandom.current().nextInt(16)]; + } + public static void setGlowingColor(Entity entity,ChatColor color){ + if(server.getScoreboardManager().getMainScoreboard().getTeam("enderdragon-glow") == null) { + server.getScoreboardManager().getMainScoreboard().registerNewTeam("enderdragon-glow"); + } + Team team = server.getScoreboardManager().getMainScoreboard().getTeam("enderdragon-glow"); + assert team != null; + if(mcMainVersion >= 13) team.setColor(color); + else team.setPrefix(color.toString()); + team.addEntry(entity.getUniqueId().toString()); + entity.setGlowing(true); + } + public void initiateRespawn(Player p){ + boolean f = initiateRespawn(p.getWorld()); + if(!f) sendFeedback(p,"§cThere is already a dragon here or respawning has started."); + else Lang.broadcastMSG(Lang.dragon_auto_respawn); + } + public boolean initiateRespawn(World world){ + if(world == null) return false; + if(world.getEnvironment() != World.Environment.THE_END) return false; + if(mcMainVersion >= 16){ + DragonBattle battle = world.getEnderDragonBattle(); + assert battle != null; + if(battle.getEnderDragon() != null){ + error("There is already a dragon here."); + return false; + } + if(battle.getRespawnPhase() == DragonBattle.RespawnPhase.NONE){ + Location cen = battle.getEndPortalLocation(); + if(cen == null) { + error("The world_the_end is unloaded."); + return false; + } + placeEndCrystals(world,cen); + battle.initiateRespawn(); + return true; + } + else{ + error("The respawning has already started."); + } + return false; + } + try { + Object battle = getEnderDragonBattle(world); + assert battle != null; + Field k = battle.getClass().getDeclaredField("k"); + k.setAccessible(true); + Object isAlive = k.get(battle); + if(!((boolean) isAlive)) { + error("There is already a dragon here."); + return false; + } + Field p = battle.getClass().getDeclaredField("p"); + p.setAccessible(true); + Object phase = p.get(battle); + if(phase != null) { + error("The respawning has already started."); + return false; + } + Field field = battle.getClass().getDeclaredField("o"); + field.setAccessible(true); + Object BlockPosition = field.get(battle); + if(BlockPosition == null){ + error("The world_the_end is unloaded."); + return false; + } + if(this.getX == null) this.getX = BlockPosition.getClass().getMethod("getX"); + if(this.getY == null) this.getY = BlockPosition.getClass().getMethod("getY"); + if(this.getZ == null) this.getZ = BlockPosition.getClass().getMethod("getZ"); + Location loc = new Location(world,(int)getX.invoke(BlockPosition),(int)this.getY.invoke(BlockPosition),(int)this.getZ.invoke(BlockPosition)); + placeEndCrystals(world, loc); + if (this.DragonBattle_e == null) this.DragonBattle_e = battle.getClass().getMethod("e"); + this.DragonBattle_e.invoke(battle); + } catch (ReflectiveOperationException e) { + warn("Your server version (" + Version.getVersion() + ") is not supported!"); + } + return true; + } + private void placeEndCrystals(World world, Location cen){ + cen.add(0.5,1,0.5); + for(int i = 0; i < 4; i++){ + EnderCrystal crystal = (EnderCrystal) world.spawnEntity(cen.clone().add(nxt[i][0],0,nxt[i][1]), EntityType.ENDER_CRYSTAL); + if(Config.auto_respawn_invulnerable) crystal.setInvulnerable(true); + crystal.setShowingBottom(false); + } + } + private Object getEnderDragonBattle(World world){ + String version = Version.getVersion(); + if (mcMainVersion >= 12) { + try { + Object worldServer = getWorldServer(world); + assert worldServer != null; + Field field = worldServer.getClass().getField("worldProvider"); + Object worldProvider = field.get(worldServer); + if(this.WorldProviderTheEndClass == null){ + WorldProviderTheEndClass = Class.forName("net.minecraft.server."+version+".WorldProviderTheEnd"); + } + Object WorldProviderTheEnd = WorldProviderTheEndClass.cast(worldProvider); + String method_name; + switch (version) { + case "v1_12_R1" -> method_name = "t"; + case "v1_13_R1", "v1_13_R2" -> method_name = "r"; + case "v1_14_R1" -> method_name = "q"; + case "v1_15_R1" -> method_name = "o"; + default -> method_name = null; + } + if(method_name == null) return null; + Method method = WorldProviderTheEnd.getClass().getDeclaredMethod(method_name); + return method.invoke(WorldProviderTheEnd); + } catch (ReflectiveOperationException e) { + warn("Your server version (" + Version.getVersion() + ") is not supported!"); + e.printStackTrace(); + return null; + } + } + warn("Your server version (" + Version.getVersion() + ") is not supported!"); + return null; + } + private Object getWorldServer(World ThisWorld) { + try { + Object castClass = getCraftWorld(ThisWorld); + return this.CraftWorldClass.getDeclaredMethod("getHandle").invoke(castClass); + } catch (ReflectiveOperationException e) { + e.printStackTrace(); + return null; + } + } + private Object getCraftWorld(World ThisWorld) { + try { + if (this.CraftWorldClass == null) { + this.CraftWorldClass = Class.forName("org.bukkit.craftbukkit." + Version.getVersion() + ".CraftWorld"); + } + if (this.CraftWorldClass.isInstance(ThisWorld)) { + return this.CraftWorldClass.cast(ThisWorld); + } + return null; + } catch (ReflectiveOperationException e) { + e.printStackTrace(); + return null; + } + } + private Object getWorld_e(World world){ + try { + Object world_c = getCraftWorld(world); + if(this.getNMSWord == null){ + this.getNMSWord = this.CraftWorldClass.getDeclaredMethod("getHandle"); + } + return this.getNMSWord.invoke(world_c); + } catch (ReflectiveOperationException e) { + e.printStackTrace(); + return null; + } + } + +} diff --git a/src/main/java/xanadu/enderdragon/manager/GuiManager.java b/src/main/java/xanadu/enderdragon/manager/GuiManager.java new file mode 100644 index 0000000..08470cf --- /dev/null +++ b/src/main/java/xanadu/enderdragon/manager/GuiManager.java @@ -0,0 +1,61 @@ +package xanadu.enderdragon.manager; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; +import xanadu.enderdragon.gui.GUIWrapper; +import xanadu.enderdragon.config.Lang; + +import java.io.File; +import java.util.HashMap; +import java.util.Iterator; + +import static xanadu.enderdragon.EnderDragon.plugin; +import static xanadu.enderdragon.config.Lang.info; +import static xanadu.enderdragon.config.Lang.sendFeedback; + +public class GuiManager { + private static HashMap f = new HashMap<>(); + public static void loadGui(){ + new BukkitRunnable(){ + @Override + public void run(){ + File folder = new File(plugin.getDataFolder(),"gui"); + if(!folder.exists()) return; + File[] files = folder.listFiles(); + if(files == null) return; + for(File file : files){ + if(!file.getName().endsWith(".yml")) continue; + info(Lang.plugin_read_file + file.getName()); + FileConfiguration fileConfiguration = YamlConfiguration.loadConfiguration(file); + Iterator it = fileConfiguration.getKeys(false).iterator(); + while (it.hasNext()){ + String name = (String) it.next(); + ConfigurationSection section = fileConfiguration.getConfigurationSection(name); + GUIWrapper guiWrapper = new GUIWrapper(section); + f.put(name, guiWrapper); + } + } + } + }.runTaskAsynchronously(plugin); + } + public static void disable(){ + f.clear(); + } + public static void openGui(Player player, String name) { + if (!f.containsKey(name)) { + sendFeedback(player,Lang.gui_not_found); + return; + } + player.openInventory(new GUIWrapper(f.get(name),name).current()); + } + public static void openGui(Player player,String name,String key){ + if (!f.containsKey(name)) { + sendFeedback(player,Lang.gui_not_found); + return; + } + player.openInventory(new GUIWrapper(f.get(name),key).current()); + } +} diff --git a/src/main/java/xanadu/enderdragon/manager/ItemManager.java b/src/main/java/xanadu/enderdragon/manager/ItemManager.java new file mode 100644 index 0000000..2a47044 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/manager/ItemManager.java @@ -0,0 +1,99 @@ +package xanadu.enderdragon.manager; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import xanadu.enderdragon.gui.Reward; +import xanadu.enderdragon.utils.Chance; + +import java.util.Collections; +import java.util.List; +import java.util.Set; + +public class ItemManager { + public static ConfigurationSection write(Reward reward){ + Chance chance = reward.getChance(); + return write(reward.getItem(),chance.getValue(),chance.getStr(),reward.getName()); + } + public static ConfigurationSection write(ItemStack item,double value,String str,String name){ + YamlConfiguration yaml = new YamlConfiguration(); + if(name == null){ + ItemMeta meta = item.getItemMeta(); + if(meta != null) name = meta.getDisplayName(); + else name = item.getType().name() + System.currentTimeMillis(); + } + yaml.set(name + ".data", item); + yaml.set(name + ".drop_chance.value",value); + yaml.set(name + ".drop_chance.format",str); + return yaml; + } + public static Reward readAsReward(ConfigurationSection section){ + Set strings = section.getKeys(false); + String name = strings.iterator().next(); + ConfigurationSection section0 = section.getConfigurationSection(name); + if(section0 == null) return null; + ItemStack item; + String nbt = section0.getString("data"); + if (nbt == null) item = new ItemStack(Material.AIR); + else item = section0.getItemStack("data"); + double d0 = section0.getDouble("drop_chance.value"); + String str = section0.getString("drop_chance.format"); + return new Reward(item,new Chance(d0, str)); + } + public static ItemStack readAsItem(ConfigurationSection section, String path){ +// if(!isValid(section)) { +// Bukkit.getServer().shutdown(); +// return new ItemStack(Material.AIR); +// } + String nbt = section.getString(path); + if (nbt == null) return new ItemStack(Material.AIR); +// if (!isValid(nbt)) return new ItemStack(Material.AIR); + return section.getItemStack(path); + } + public static void addLore(ItemStack item, String lore){ + ItemMeta meta = item.getItemMeta(); + if(meta != null) { + List lores = meta.getLore(); + if (lores != null) { + lores.add(0,lore); + meta.setLore(lores); + } + else { + meta.setLore(Collections.singletonList(lore)); + } + item.setItemMeta(meta); + } + } + public static boolean isEmpty(ItemStack item){ + if(item == null) return true; + if(item.getType() == Material.AIR) return true; + return false; + } +// public static ItemStack StringToItemStack(String str) { +// YamlConfiguration yml = new YamlConfiguration(); +// ItemStack item; +// try { +// yml.loadFromString(str); +// item = yml.getItemStack("item"); +// } catch (InvalidConfigurationException ex) { +// item = new ItemStack(Material.AIR, 1); +// } +// return item; +// } +// public Reward loadFromFile(ConfigurationSection section){ +// ItemStack item; +// if(section.getString("item.data") == null || section.getString("item.drop_chance") == null){ +// return new Reward(new ItemStack(Material.AIR),); +// } +// try { +// yamlManager.loadFromString(section.getString("item.")); +// } +// } + public static ItemStack read(ConfigurationSection section, String str, String str2, Material material){ + if(material == null) return new ItemStack(Material.AIR); + return new ItemStack(material,1); + + } +} diff --git a/src/main/java/xanadu/enderdragon/manager/RewardManager.java b/src/main/java/xanadu/enderdragon/manager/RewardManager.java new file mode 100644 index 0000000..18322a2 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/manager/RewardManager.java @@ -0,0 +1,70 @@ +package xanadu.enderdragon.manager; + +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.gui.Reward; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.utils.Chance; +import xanadu.enderdragon.utils.MyDragon; + +import java.io.IOException; +import java.util.List; + +import static xanadu.enderdragon.EnderDragon.data; +import static xanadu.enderdragon.EnderDragon.dataF; +import static xanadu.enderdragon.manager.DragonManager.dragons; +import static xanadu.enderdragon.manager.DragonManager.mp; +import static xanadu.enderdragon.manager.ItemManager.readAsReward; + +public class RewardManager { + public static void reload(){ + for(MyDragon dragon : dragons){ + dragon.datum.clear(); + String path = dragon.unique_name; + List list = data.getStringList(path); + for(String str : list){ + YamlConfiguration yml = new YamlConfiguration(); + try{ + yml.loadFromString(str); + Reward reward = readAsReward(yml); + dragon.datum.add(reward); + }catch (InvalidConfigurationException e){ + Lang.error(Lang.plugin_item_read_error + str); + } + } + } + } + public static void addItem(String key,Reward reward){ + addItem(key,reward.getItem(),reward.getChance()); + } + public static void addItem(String key, ItemStack item, Chance chance){ + MyDragon dragon = mp.get(key); + if(dragon == null) return; + String path = dragon.unique_name; + List list = data.getStringList(path); + Reward reward = new Reward(item,chance); + list.add(reward.toString()); + data.set(path,list); + try { + data.save(dataF); + } catch (IOException e) { + throw new RuntimeException(e); + } + data = YamlConfiguration.loadConfiguration(dataF); + dragon.datum.add(reward); + } + public static void clearItem(String key){ + MyDragon dragon = mp.get(key); + if(dragon == null) return; + String path = dragon.unique_name; + data.set(path,""); + try { + data.save(dataF); + } catch (IOException e) { + throw new RuntimeException(e); + } + data = YamlConfiguration.loadConfiguration(dataF); + dragon.datum.clear(); + } +} diff --git a/src/main/java/xanadu/enderdragon/manager/TaskManager.java b/src/main/java/xanadu/enderdragon/manager/TaskManager.java new file mode 100644 index 0000000..0c837f6 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/manager/TaskManager.java @@ -0,0 +1,93 @@ +package xanadu.enderdragon.manager; + +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; +import xanadu.enderdragon.task.types.*; + +import java.io.IOException; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeParseException; +import java.util.Date; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.config.Lang.error; +import static xanadu.enderdragon.config.Lang.plugin_file_save_error; + +public class TaskManager { + public static String path = "auto_respawn.next_respawn_time"; + public static Task task = null; + public static Task parse(String string){ + String[] str = string.split(":",2); + TaskType taskType = TaskType.getByName(str[0]); + switch (taskType){ + case minute -> { + return new Minute(TaskType.minute,str[1]); + } + case hour -> { + return new Hour(TaskType.hour,str[1]); + } + case day -> { + return new Day(TaskType.day,str[1]); + } + case week -> { + return new Week(TaskType.week,str[1]); + } + case month -> { + return new Month(TaskType.month,str[1]); + } + case year -> { + return new Year(TaskType.year,str[1]); + } + default -> { + return null; + } + } + } + public static void reload(){ + task = parse(Config.auto_respawn_respawn_time); + } + public static LocalTime getRoundTime(String str){ + try { + return LocalTime.parse(str, DateTimeFormatter.ofPattern("HH:mm")); + }catch (DateTimeParseException e){ + Lang.error("\"respawn_time\" in config.yml error!The format of time should be HH:mm."); + } + return null; + } + public static String getRoundTimeStr(LocalDateTime time){ + return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")); + } + public static LocalDateTime getLocalDateTime(String str){ + if(isValidTime(str)) return LocalDateTime.parse(str, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")); + return null; + } + public static boolean isValidTime(String str){ + SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm"); + try{ + df.parse(str); + } catch (ParseException e) { + Lang.error("\"next_respawn_time\" in data.yml error!The format of time should be HH:mm."); + return false; + } + return true; + } + public static void saveFile(LocalDateTime nextTime){ + data.set(TaskManager.path,getRoundTimeStr(nextTime)); + try{ + data.save(dataF); + }catch (IOException ex){ + error(plugin_file_save_error.replaceAll("\\{file_name}",dataF.getName())); + } + } + public static String getCurrentTimeWithSpecialFormat(){ + SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH∶mm∶ss"); + return df.format(new Date()); + } + +} diff --git a/src/main/java/xanadu/enderdragon/task/RespawnDragonRunnable.java b/src/main/java/xanadu/enderdragon/task/RespawnDragonRunnable.java new file mode 100644 index 0000000..e0139d2 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/RespawnDragonRunnable.java @@ -0,0 +1,43 @@ +package xanadu.enderdragon.task; + +import org.bukkit.Bukkit; +import org.bukkit.scheduler.BukkitRunnable; +import xanadu.enderdragon.EnderDragon; +import xanadu.enderdragon.config.Config; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.manager.TaskManager; + +import static xanadu.enderdragon.EnderDragon.plugin; +import static xanadu.enderdragon.config.Lang.*; + +public class RespawnDragonRunnable extends BukkitRunnable { + private static RespawnDragonRunnable runnable = null; + @Override + public void run(){ + if(TaskManager.task == null) { + this.cancel(); + runnable = null; + error("The config of auto-respawn errors!Task has been disabled..."); + return; + } + if(TaskManager.task.isTimeUp()){ + new BukkitRunnable(){ + @Override + public void run(){ + boolean f = EnderDragon.getInstance().getDragonManager().initiateRespawn(Bukkit.getWorld(Config.auto_respawn_world_the_end_name)); + if(f) Lang.broadcastMSG(Lang.dragon_auto_respawn); + } + }.runTask(plugin); + TaskManager.task.updateTime(); + } + } + public static void reload(){ + if(runnable != null){ + runnable.cancel(); + runnable = null; + } + runnable = new RespawnDragonRunnable(); + runnable.runTaskTimerAsynchronously(plugin,0,200L); + info("The task has started to run..."); + } +} diff --git a/src/main/java/xanadu/enderdragon/task/Task.java b/src/main/java/xanadu/enderdragon/task/Task.java new file mode 100644 index 0000000..ec0c699 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/Task.java @@ -0,0 +1,50 @@ +package xanadu.enderdragon.task; + +import xanadu.enderdragon.manager.TaskManager; + +import java.time.LocalDateTime; +import java.time.LocalTime; + +import static xanadu.enderdragon.EnderDragon.data; +import static xanadu.enderdragon.manager.TaskManager.*; + +public abstract class Task { + protected int period; + protected int day; + private final TaskType type; + public abstract LocalDateTime getNextTime(LocalDateTime cur); + public abstract void updateTime(); + protected LocalDateTime nextTime; + protected Task(TaskType type,String str){ + this.type = type; + switch (type){ + case minute, hour -> this.period = Integer.parseInt(str); + case day -> this.period = Integer.parseInt(str.split(",")[0]); + case week, month, year -> this.day = Integer.parseInt(str.split(",")[0]); + } + if(data.getString(path) == null){ + switch (type){ + case minute, hour -> this.nextTime = this.getNextTime(LocalDateTime.now()); + case day, week, month, year -> calcNextTime(str); + } + saveFile(nextTime); + } + else this.nextTime = TaskManager.getLocalDateTime(data.getString(path)); + } + private void calcNextTime(String str){ + LocalTime time = getRoundTime(str.split(",")[1]); + if(time != null) this.nextTime = this.getNextTime(LocalDateTime.now().with(time)); + else this.nextTime = this.getNextTime(LocalDateTime.now()); + } + public boolean isTimeUp(){ + LocalDateTime now = LocalDateTime.now(); + if(now.isEqual(nextTime) || now.isAfter(nextTime)){ + return true; + } + return false; + } + public TaskType getType(){ + return this.type; + } + +} diff --git a/src/main/java/xanadu/enderdragon/task/TaskType.java b/src/main/java/xanadu/enderdragon/task/TaskType.java new file mode 100644 index 0000000..4ade195 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/TaskType.java @@ -0,0 +1,26 @@ +package xanadu.enderdragon.task; + +import java.util.Map; +import java.util.TreeMap; + +public enum TaskType { + minute, + hour, + day, + week, + month, + year, + unknown; + private static final Map mp = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + public static TaskType getByName(String str){ + if(str == null) return unknown; + return mp.getOrDefault(str,unknown); + } + static{ + TaskType[] values = values(); + for (TaskType taskType : values) { + String name = taskType.name(); + mp.put(name, taskType); + } + } +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Day.java b/src/main/java/xanadu/enderdragon/task/types/Day.java new file mode 100644 index 0000000..88838db --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Day.java @@ -0,0 +1,24 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Day extends Task { + + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.plusDays(period); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusDays(period); + saveFile(nextTime); + } + public Day(TaskType type, String str){ + super(type,str); + } +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Hour.java b/src/main/java/xanadu/enderdragon/task/types/Hour.java new file mode 100644 index 0000000..86780ad --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Hour.java @@ -0,0 +1,23 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Hour extends Task { + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.plusHours(period); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusHours(period); + saveFile(nextTime); + } + public Hour(TaskType type, String str){ + super(type,str); + } +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Minute.java b/src/main/java/xanadu/enderdragon/task/types/Minute.java new file mode 100644 index 0000000..5f54a3b --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Minute.java @@ -0,0 +1,26 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Minute extends Task { + + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.plusMinutes(period); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusMinutes(period); + saveFile(nextTime); + } + + public Minute(TaskType type, String str){ + super(type,str); + } + +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Month.java b/src/main/java/xanadu/enderdragon/task/types/Month.java new file mode 100644 index 0000000..75d66e8 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Month.java @@ -0,0 +1,24 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Month extends Task { + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.plusMonths(1).withDayOfMonth(day); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusMonths(1).withDayOfMonth(day); + saveFile(nextTime); + } + public Month(TaskType type, String str){ + super(type,str); + } + +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Week.java b/src/main/java/xanadu/enderdragon/task/types/Week.java new file mode 100644 index 0000000..a308b00 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Week.java @@ -0,0 +1,25 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.DayOfWeek; +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Week extends Task { + + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.with(DayOfWeek.of(day)).plusDays(7); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusDays(7); + saveFile(nextTime); + } + public Week(TaskType type, String str){ + super(type,str); + } +} diff --git a/src/main/java/xanadu/enderdragon/task/types/Year.java b/src/main/java/xanadu/enderdragon/task/types/Year.java new file mode 100644 index 0000000..5857b28 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/task/types/Year.java @@ -0,0 +1,23 @@ +package xanadu.enderdragon.task.types; + +import xanadu.enderdragon.task.Task; +import xanadu.enderdragon.task.TaskType; + +import java.time.LocalDateTime; + +import static xanadu.enderdragon.manager.TaskManager.saveFile; + +public class Year extends Task { + @Override + public LocalDateTime getNextTime(LocalDateTime cur) { + return cur.plusYears(1).withDayOfMonth(day); + } + @Override + public void updateTime(){ + this.nextTime = LocalDateTime.now().plusYears(1); + saveFile(nextTime); + } + public Year(TaskType type, String str){ + super(type,str); + } +} diff --git a/src/main/java/xanadu/enderdragon/utils/Chance.java b/src/main/java/xanadu/enderdragon/utils/Chance.java new file mode 100644 index 0000000..6b0209a --- /dev/null +++ b/src/main/java/xanadu/enderdragon/utils/Chance.java @@ -0,0 +1,22 @@ +package xanadu.enderdragon.utils; + + +public class Chance { + private double value; + private String str; + public Chance(Chance chance){ + str = chance.str; + value = chance.value; + } + public Chance(double d0,String str){ + this.str = str; + this.value = d0; + } + public double getValue(){ + return value; + } + public String getStr(){ + return str; + } + +} diff --git a/src/main/java/xanadu/enderdragon/utils/Events.java b/src/main/java/xanadu/enderdragon/utils/Events.java new file mode 100644 index 0000000..41ec23c --- /dev/null +++ b/src/main/java/xanadu/enderdragon/utils/Events.java @@ -0,0 +1,84 @@ +package xanadu.enderdragon.utils; + +import org.bukkit.Bukkit; +import org.bukkit.event.*; +import org.bukkit.plugin.EventExecutor; + +import java.util.concurrent.atomic.AtomicLong; +import java.util.function.Consumer; + +import static xanadu.enderdragon.EnderDragon.plugin; +import static xanadu.enderdragon.EnderDragon.pm; + +public class Events implements Listener, EventExecutor { + private final Consumer consumer; + private final Class clazz; + private boolean G; + private final AtomicLong atomicLong; + + public Events withTime(final long a) { + this.atomicLong.set(a); + return this; + } + + public void unregister() { + if (this.G) return; + try { + HandlerList list = (HandlerList)this.clazz.getMethod("getHandlerList").invoke(null, new Object[0]); + if (Bukkit.isPrimaryThread()) list.unregister(this); + else Bukkit.getScheduler().runTask(plugin, () -> list.unregister(this)); + } + catch (final Exception ignored) {} + this.G = true; + } + + public static Events subscribe(Class a, EventPriority a2, boolean a3, Consumer a4) { + if (Bukkit.isPrimaryThread()) { + pm.registerEvent(a, (Listener) a4, a2, (EventExecutor) a4, plugin, a3); + return (Events) a4; + } + Bukkit.getScheduler().runTask(plugin,()->pm.registerEvent(a, (Listener)a4, a2, (EventExecutor)a4, plugin, a3)); + return (Events) a4; + } + + public static Events subscribe(Class clazz, Consumer consumer) { + return Events.subscribe(clazz, EventPriority.HIGHEST, true, consumer); + } + + public Events(Class clazz, Consumer consumer) { + this.atomicLong = new AtomicLong(-1L); + this.G = false; + this.consumer = consumer; + this.clazz = clazz; + } + + public void execute(Listener listener, Event event) { + if (listener == null) iIIiii(0); + if (event == null) iIIiii(1); + if (this.atomicLong.get() > 0L && System.currentTimeMillis() > this.atomicLong.get()) { + Bukkit.getScheduler().runTask(plugin, this::unregister); + return; + } + if (!this.clazz.isInstance(event)) return; + this.consumer.accept((T) event); + } + + public boolean releaseIfExpired() { + if (this.atomicLong.get() > 0L && System.currentTimeMillis() > this.atomicLong.get()) { + boolean b = true; + this.unregister(); + return b; + } + return false; + } + + private static /* synthetic */ void iIIiii(final int a) { + final String format = "Argument for @NotNull parameter '%s' of %s.%s must not be null"; + final Object[] args = new Object[3]; + if (a == 1) args[0] = "event"; + else args[0] = "listener"; + args[1] = "xanadu/enderdragon/utils/Events"; + args[2] = "execute"; + throw new IllegalArgumentException(String.format(format, args)); + } +} diff --git a/src/main/java/xanadu/enderdragon/utils/FileUpdater.java b/src/main/java/xanadu/enderdragon/utils/FileUpdater.java new file mode 100644 index 0000000..95a9a0e --- /dev/null +++ b/src/main/java/xanadu/enderdragon/utils/FileUpdater.java @@ -0,0 +1,122 @@ +package xanadu.enderdragon.utils; + +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.inventory.ItemStack; +import xanadu.enderdragon.EnderDragon; +import xanadu.enderdragon.config.Lang; +import xanadu.enderdragon.gui.Reward; + +import java.io.*; +import java.util.ArrayList; +import java.util.List; + +import static xanadu.enderdragon.EnderDragon.*; +import static xanadu.enderdragon.config.Config.saveResource; +import static xanadu.enderdragon.config.Lang.error; +import static xanadu.enderdragon.config.Lang.info; +import static xanadu.enderdragon.manager.ItemManager.readAsItem; + +public class FileUpdater { + public static void update() throws IOException { + FileConfiguration config_old = plugin.getConfig(); + FileConfiguration data_old = EnderDragon.data; + info("New setting files will be generated in plugins/EnderDragon/new."); + if("1.8.3".equals(config_old.getString("version"))){ + File base_F = new File(plugin.getDataFolder(),"setting/default.yml"); + File default_F = new File(plugin.getDataFolder(),"new/setting/default.yml"); + FileConfiguration default_ = YamlConfiguration.loadConfiguration(base_F); + default_.set("display_name",config_old.getString("normal-dragon.name","Ender Dragon")); + default_.set("crystal_heal_speed",config_old.getDouble("normal-dragon.crystal-heal",2.0d)); + if(config_old.getBoolean("command.enable")){ + default_.set("death_cmd",config_old.getStringList("command.normal-dragon")); + } + default_.save(default_F); + File base2_F = new File(plugin.getDataFolder(),"setting/special.yml"); + File special_F = new File(plugin.getDataFolder(),"new/setting/special.yml"); + FileConfiguration special = YamlConfiguration.loadConfiguration(base2_F); + String pre = "special-dragon."; + special.set("display_name",config_old.getString(pre+"name")); + special.set("spawn_chance",config_old.getString(pre+"chance")); + special.set("max_health",config_old.getDouble(pre+"max-health")); + special.set("spawn_health",config_old.getDouble(pre+"spawn-health")); + special.set("attack_potion_effect",config_old.getStringList(pre+"attack-effect")); + special.set("exp_drop",config_old.getInt(pre+"exp-drop")); + special.set("dragon_egg_spawn.chance",config_old.getDouble(pre+"dragon-egg-spawn.chance")); + special.set("dragon_egg_spawn.delay",config_old.getInt(pre+"dragon-egg-spawn.delay")); + special.set("dragon_egg_spawn.x",config_old.getInt(pre+"dragon-egg-spawn.x")); + special.set("dragon_egg_spawn.y",config_old.getInt(pre+"dragon-egg-spawn.y")); + special.set("dragon_egg_spawn.z",config_old.getInt(pre+"dragon-egg-spawn.z")); + String color = config_old.getString(pre+"glow-color"); + if("disable".equalsIgnoreCase(color)) color = "none"; + special.set("glow_color",color); + special.set("crystal_heal_speed",config_old.getDouble(pre+"crystal-heal")); + special.set("suck_blood.enable",config_old.getBoolean(pre+"suck-blood.enable")); + special.set("suck_blood.rate",config_old.getDouble(pre+"suck-blood.rate")); + special.set("suck_blood.base_amount",config_old.getDouble(pre+"suck-blood.base-suck-blood")); + special.set("suck_blood.only_player",config_old.getBoolean(pre+"suck-blood.only-player")); + if(config_old.getBoolean("command.enable")){ + special.set("death_cmd",config_old.getStringList(pre+"special-dragon")); + } + special.save(special_F); + } + else Lang.error("Your config.yml version is not supported!"); + if("1.8.4".equals(data_old.getString("version"))){ + saveResource("data.yml","new/data.yml",true); + File data_new_F = new File(plugin.getDataFolder(),"new/data.yml"); + FileConfiguration data_new = YamlConfiguration.loadConfiguration(data_new_F); + data_new.set("version","2.0.0"); + data_new.set("times",data_old.getInt("times")); + List items_old = data_old.getStringList("items"); + try{ + File base2_F = new File(plugin.getDataFolder(),"setting/special.yml"); + FileConfiguration special = YamlConfiguration.loadConfiguration(base2_F); + String special_key = special.getString("unique_name"); + List list = new ArrayList<>(); + for(int i=0;i+1{ + public ItemStack icon; + public String unique_name; + public String display_name; + public String drop_gui; + public int edge; + public int priority; + public double spawn_chance; + public int max_health; + public int spawn_health; + public int exp_drop; + public int dragon_egg_spawn_delay; + public int dragon_egg_spawn_x; + public int dragon_egg_spawn_y; + public int dragon_egg_spawn_z; + public double dragon_egg_spawn_chance; + public double attack_damage_modify; + public double move_speed_modify; + public double armor_modify; + public double armor_toughness_modify; + public double crystal_heal_speed; + public boolean suck_blood_enable; + public double suck_blood_rate; + public double suck_blood_base_amount; + public boolean suck_blood_only_player; + public List attack_potion_effect; + public List spawn_cmd; + public List death_cmd; + public List spawn_broadcast_msg; + public List death_broadcast_msg; + public List msg_to_killer; + public String glow_color; + public String bossbar_color; + public String bossbar_style; + public double effect_cloud_original_radius; + public double effect_cloud_expand_speed; + public int effect_cloud_duration; + public int effect_cloud_color_R; + public int effect_cloud_color_G; + public int effect_cloud_color_B; + public List effect_cloud_potion; + public List datum = new ArrayList<>(); + + @Override + public int compareTo(MyDragon o) { + return o.priority - this.priority;//降序 + } + +} diff --git a/src/main/java/xanadu/enderdragon/utils/Papi.java b/src/main/java/xanadu/enderdragon/utils/Papi.java new file mode 100644 index 0000000..4a80933 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/utils/Papi.java @@ -0,0 +1,52 @@ +package xanadu.enderdragon.utils; + +import me.clip.placeholderapi.expansion.PlaceholderExpansion; +import org.bukkit.OfflinePlayer; +import xanadu.enderdragon.EnderDragon; + +public class Papi extends PlaceholderExpansion { + private final EnderDragon plugin; + + public Papi(EnderDragon plugin) { + this.plugin = plugin; + } + + @Override + public String getAuthor() { + return "Xanadu13"; + } + + @Override + public String getIdentifier() { + return "ed"; + } + + @Override + public String getVersion() { + return "1.0.0"; + } + + @Override + public boolean persist() { + return true; + } + + @Override + public String onRequest(OfflinePlayer player, String params) { +// if(!Config.BossBar_Enable) return null; +// if(params.equalsIgnoreCase("bossbar_progress")) { +// if(player.isOnline() && groups.get(player.getUniqueId())!=null){ +// double progress = groups.get(player.getUniqueId()).getProgress(); +// return String.valueOf(div(progress,1,3)); +// } +// return String.valueOf(0); +// } +// else if(params.equalsIgnoreCase("remain_time")){ +// if(player.isOnline() && groups.get(player.getUniqueId())!=null){ +// return String.valueOf(groups.get(player.getUniqueId()).getRemainTime()); +// } +// return String.valueOf(0); +// } + return null; + } +} diff --git a/src/main/java/xanadu/enderdragon/utils/SpecialColor.java b/src/main/java/xanadu/enderdragon/utils/SpecialColor.java new file mode 100644 index 0000000..ede77a7 --- /dev/null +++ b/src/main/java/xanadu/enderdragon/utils/SpecialColor.java @@ -0,0 +1,64 @@ +package xanadu.enderdragon.utils; + +import net.md_5.bungee.api.ChatColor; + +import java.awt.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static xanadu.enderdragon.EnderDragon.mcMainVersion; +import static xanadu.enderdragon.utils.MathUtils.hexToInt; + +public class SpecialColor { + + public static Pattern hex_code = Pattern.compile("&#([0-9A-Fa-f]{6})"); + public static Pattern gradient = Pattern.compile("&\\[#([0-9a-fA-F]{6})-#([0-9a-fA-F]{6})(.+)]"); + public static String translateHexCodes (String str) { + if(mcMainVersion < 16) return str; + Matcher matcher = hex_code.matcher(str); + StringBuffer buffer = new StringBuffer(); + while(matcher.find()) { + matcher.appendReplacement(buffer, ChatColor.of("#" + matcher.group(1)).toString()); + } + return ChatColor.translateAlternateColorCodes('&', matcher.appendTail(buffer).toString()); + } + public static String transGradient(String str) { + if(mcMainVersion < 16) return str; + if (str.contains("&[#")&&str.contains("]")) { + Matcher matcher = gradient.matcher(str); + StringBuffer buffer = new StringBuffer(); + while (matcher.find()) { + String text = matcher.group(3); + int[] colors = gradient(matcher.group(1),matcher.group(2),text.length()); + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < text.length(); i++) { + Color c = new Color(colors[i]); + builder.append(ChatColor.of(c)).append(text.charAt(i)); + } + matcher.appendReplacement(buffer, builder.toString()); + } + matcher.appendTail(buffer); + return buffer.toString(); + } + return translateHexCodes(str); + } + private static int[] gradient(String start,String end,int length){ + int[] color = new int[length]; + int[] rgb1 = hexToInt(start); + int[] rgb2 = hexToInt(end); + if(length==0){return color;} + if(length==1){ + for(int j=0;j<3;j++){ + color[0] = color[0]*256+rgb1[j]; + } + return color; + } + for(int i=0;i