update to 2.0.0
This commit is contained in:
Xanadu13
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -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<String> 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<String> datum = data.getStringList("items");
|
||||
int max = datum.size() / 2 ;
|
||||
for(int i=0 ; i<max ; ){
|
||||
i = i + 1;
|
||||
String str = datum.get(i*2-2);
|
||||
ItemStack item = StringToItemStack(str);
|
||||
ItemMeta meta = item.getItemMeta();
|
||||
if(meta != null) {
|
||||
List<String> 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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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<String> arguments = new ArrayList<>();
|
||||
|
||||
private static final List<String> arguments_1 = List.of(new String[]{"drop", "reload", "respawn", "update"});
|
||||
private static final List<String> arguments_2 = List.of(new String[]{"add", "clear", "gui"});
|
||||
@Override
|
||||
public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
|
||||
|
||||
List<String> 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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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<String> 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<String> 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) {}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<String> 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 <name> <chance> §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<String> list){
|
||||
if(list == null) return;
|
||||
for(String str : list){
|
||||
Bukkit.broadcastMessage(Lang.plugin_prefix + str);
|
||||
}
|
||||
}
|
||||
public static void runCommands(List<String> 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<String> list){
|
||||
if(list == null) return;
|
||||
for(String cmd : list){
|
||||
if(cmd.equals("")) continue;
|
||||
server.dispatchCommand(server.getConsoleSender(),cmd);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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<ItemStack[]> pagedItems;
|
||||
protected ArrayList<String[]> pagedData;
|
||||
protected List<GUISlot> slots;
|
||||
protected Inventory inv;
|
||||
protected HashSet<Integer> 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.slots.size();i++){
|
||||
GUISlot slot = this.slots.get(i);
|
||||
if (slot instanceof ItemSlot) {
|
||||
this.inv.setItem(i, new ItemStack(Material.AIR));
|
||||
}
|
||||
}
|
||||
if (this.pagedItems.isEmpty()) {
|
||||
this.pagedItems.add(new ItemStack[this.size]);
|
||||
}
|
||||
if (this.pagedData.isEmpty()) {
|
||||
this.pagedData.add(new String[this.size]);
|
||||
}
|
||||
ItemStack[] array = this.pagedItems.get(a);
|
||||
for(int i=0 ; i<array.length ; i++){
|
||||
ItemStack itemStack = array[i];
|
||||
if (itemStack != null) {
|
||||
this.inv.setItem(i, itemStack);
|
||||
}
|
||||
}
|
||||
for(Integer n2 : this.dynamics){
|
||||
GUISlotType type = this.getSlot(n2).getType();
|
||||
ItemStack clone;
|
||||
if(type == GUISlotType.PAGE_PREV){
|
||||
if(a == 0) clone = this.slots.get(n2).getItemOnDisable();
|
||||
else clone = this.slots.get(n2).getItem();
|
||||
this.inv.setItem(n2,clone);
|
||||
}
|
||||
else if(type == GUISlotType.PAGE_NEXT){
|
||||
if(a == this.pagedItems.size()-1) clone = this.slots.get(n2).getItemOnDisable();
|
||||
else clone = this.slots.get(n2).getItem();
|
||||
this.inv.setItem(n2,clone);
|
||||
}
|
||||
else if(type == GUISlotType.PAGE_TIP){
|
||||
clone = this.slots.get(n2).getItem().clone();
|
||||
ItemMeta itemMeta = clone.getItemMeta();
|
||||
if (itemMeta != null) {
|
||||
itemMeta.setDisplayName(String.format("§r%d/" + this.pagedItems.size(),a+1));
|
||||
clone.setItemMeta(itemMeta);
|
||||
this.inv.setItem(n2, clone);
|
||||
}
|
||||
}
|
||||
// else if(type == GUISlotType.PAGE_JUMP){
|
||||
// clone = this.slots.get(n2).getItem().clone();
|
||||
// this.inv.setItem(n2,clone);
|
||||
// }
|
||||
}
|
||||
}
|
||||
public Inventory current() {
|
||||
return this.inv;
|
||||
}
|
||||
public Inventory getInventory() {
|
||||
return this.inv;
|
||||
}
|
||||
protected void init() {
|
||||
for(int i=0;i<this.slots.size();i++){
|
||||
GUISlot slot = slots.get(i);
|
||||
inv.setItem(i, slot.getItem());
|
||||
}
|
||||
}
|
||||
public void resetPagedItem(int type, String key){
|
||||
this.pagedItems.clear();
|
||||
this.pagedData.clear();
|
||||
if(type == 1){
|
||||
resetPagedItem(key);
|
||||
}
|
||||
else if(type == 2){
|
||||
for(MyDragon myDragon : dragons){
|
||||
this.addDragon(myDragon.icon.clone(),myDragon.unique_name);
|
||||
}
|
||||
}
|
||||
}
|
||||
public void resetPagedItem(String key){
|
||||
this.pagedItems.clear();
|
||||
MyDragon dragon = mp.get(key);
|
||||
if(dragon == null) return;
|
||||
for(Reward reward : dragon.datum){
|
||||
if(ItemManager.isEmpty(reward.getItem())) continue;
|
||||
ItemStack item = reward.getItem().clone();
|
||||
if("".equals(Lang.gui_item_lore)) Lang.gui_item_lore = "§6(chance: {drop_chance}%)§r";
|
||||
String lore = Lang.gui_item_lore.replaceAll("\\{drop_chance}",reward.getChance().getStr());
|
||||
ItemManager.addLore(item,lore);
|
||||
this.addItem(item);
|
||||
}
|
||||
}
|
||||
protected void addItem(ItemStack item) {
|
||||
for(int i = 0 ; i < this.maxPage ; i++){
|
||||
if (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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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<String,GUISlotType> mp = new TreeMap<String,GUISlotType>(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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Character,GUISlot> 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<String> 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);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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<Boolean> 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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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<Entity> 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<Entity> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<ItemStack> 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<Entity> 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<MyDragon> dragons = new ArrayList<>();
|
||||
public static HashMap<String, MyDragon> mp = new HashMap<>();
|
||||
public static List<String> 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<MyDragon> 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<String> stringList = f.getStringList("attack_potion_effect");
|
||||
List<PotionEffect> 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<String> stringList2 = f.getStringList("effect_cloud.potion");
|
||||
List<PotionEffect> 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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<String, GUIWrapper> 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());
|
||||
}
|
||||
}
|
||||
@@ -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<String> 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<String> 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);
|
||||
|
||||
}
|
||||
}
|
||||
@@ -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<String> 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<String> 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();
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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...");
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<String,TaskType> 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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<T extends Event> implements Listener, EventExecutor {
|
||||
private final Consumer<T> consumer;
|
||||
private final Class<T> clazz;
|
||||
private boolean G;
|
||||
private final AtomicLong atomicLong;
|
||||
|
||||
public Events<T> 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 <T extends Event> Events<T> subscribe(Class<T> a, EventPriority a2, boolean a3, Consumer<T> a4) {
|
||||
if (Bukkit.isPrimaryThread()) {
|
||||
pm.registerEvent(a, (Listener) a4, a2, (EventExecutor) a4, plugin, a3);
|
||||
return (Events<T>) a4;
|
||||
}
|
||||
Bukkit.getScheduler().runTask(plugin,()->pm.registerEvent(a, (Listener)a4, a2, (EventExecutor)a4, plugin, a3));
|
||||
return (Events<T>) a4;
|
||||
}
|
||||
|
||||
public static <T extends Event> Events<T> subscribe(Class<T> clazz, Consumer<T> consumer) {
|
||||
return Events.subscribe(clazz, EventPriority.HIGHEST, true, consumer);
|
||||
}
|
||||
|
||||
public Events(Class<T> clazz, Consumer<T> 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));
|
||||
}
|
||||
}
|
||||
@@ -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<String> 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<String> list = new ArrayList<>();
|
||||
for(int i=0;i+1<items_old.size();i+=2){
|
||||
YamlConfiguration yml = new YamlConfiguration();
|
||||
yml.loadFromString(items_old.get(i));
|
||||
ItemStack item = readAsItem(yml,"item");
|
||||
String str = items_old.get(i+1);
|
||||
double d0 = Double.parseDouble(str);
|
||||
Reward reward = new Reward(item,new Chance(d0,str));
|
||||
list.add(reward.toString());
|
||||
}
|
||||
if(special_key == null){
|
||||
error("\"unique_name\" in setting/special.yml is missing.Update data.yml failed!");
|
||||
return;
|
||||
}
|
||||
data_new.set(special_key,list);
|
||||
data_new.save(data_new_F);
|
||||
}catch (InvalidConfigurationException | NumberFormatException | IOException e){
|
||||
error("The format of data.yml is invalid!");
|
||||
}
|
||||
}
|
||||
else Lang.error("Your data.yml version is not supported!");
|
||||
if("1.8.3".equals(config_old.getString("version"))){
|
||||
saveResource("config.yml","new/config.yml",true);
|
||||
File config_new_F = new File(plugin.getDataFolder(),"new/config.yml");
|
||||
FileConfiguration config_new = YamlConfiguration.loadConfiguration(config_new_F);
|
||||
config_new.set("lang",config_old.getString("lang"));
|
||||
config_new.save(config_new_F);
|
||||
}
|
||||
String lang_name = config_old.getString("lang","English") + ".yml";
|
||||
FileConfiguration lang_old = lang;
|
||||
if("1.8.3".equals(lang_old.getString("version"))){
|
||||
saveResource("lang/"+lang_name,"new/lang/"+lang_name,true);
|
||||
File lang_new_F = new File(plugin.getDataFolder(),"new/lang/"+lang_name);
|
||||
FileConfiguration lang_new = YamlConfiguration.loadConfiguration(lang_new_F);
|
||||
lang_new.set("plugin.prefix",lang_old.getString("prefix"));
|
||||
lang_new.set("command.no_permission",lang_old.getString("NoCommandPermission"));
|
||||
lang_new.set("command.reload_config",lang_old.getString("configReloaded"));
|
||||
lang_new.set("command.only_player",lang_old.getString("PlayerCommand"));
|
||||
lang_new.set("command.drop_item.clear",lang_old.getString("ClearDropItemConfig"));
|
||||
lang_new.set("dragon.player_inv_full",lang_old.getString("player-inv-full"));
|
||||
lang_new.set("dragon.no_killer",lang_old.getString("nobody-kill"));
|
||||
lang_new.save(lang_new_F);
|
||||
}
|
||||
else error("Your "+lang_name+" version is not supported!");
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package xanadu.enderdragon.utils;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
import static xanadu.enderdragon.EnderDragon.server;
|
||||
|
||||
public class MathUtils {
|
||||
public static double div(double d1,double d2,int len){
|
||||
BigDecimal b1 = new BigDecimal(d1);
|
||||
BigDecimal b2 = new BigDecimal(d2);
|
||||
return b1.divide(b2,len, RoundingMode.HALF_UP).doubleValue();
|
||||
}
|
||||
public static int[] hexToInt(String hex){
|
||||
int[] result = new int[3];
|
||||
String s1 = hex.substring(0,2);
|
||||
String s2 = hex.substring(2,4);
|
||||
String s3 = hex.substring(4,6);
|
||||
result[0] = Integer.parseInt(s1,16);
|
||||
result[1] = Integer.parseInt(s2,16);
|
||||
result[2] = Integer.parseInt(s3,16);
|
||||
return result;
|
||||
}
|
||||
public static String locationToString(Location loc){
|
||||
if (loc.getWorld() == null) return "";
|
||||
return loc.getWorld().getName()+";"+loc.getX()+";"+loc.getY()+";"+loc.getZ();
|
||||
}
|
||||
public static Location stringToLocation(String str){
|
||||
final String[] parts = str.split(";");
|
||||
if(parts.length != 4) return null;
|
||||
final World world = server.getWorld(parts[0]);
|
||||
final double x = Double.parseDouble(parts[1]);
|
||||
final double y = Double.parseDouble(parts[2]);
|
||||
final double z = Double.parseDouble(parts[3]);
|
||||
return new Location(world,x,y,z);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package xanadu.enderdragon.utils;
|
||||
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.potion.PotionEffect;
|
||||
import xanadu.enderdragon.gui.Reward;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class MyDragon implements Comparable<MyDragon>{
|
||||
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<PotionEffect> attack_potion_effect;
|
||||
public List<String> spawn_cmd;
|
||||
public List<String> death_cmd;
|
||||
public List<String> spawn_broadcast_msg;
|
||||
public List<String> death_broadcast_msg;
|
||||
public List<String> 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<PotionEffect> effect_cloud_potion;
|
||||
public List<Reward> datum = new ArrayList<>();
|
||||
|
||||
@Override
|
||||
public int compareTo(MyDragon o) {
|
||||
return o.priority - this.priority;//降序
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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<length;i++){
|
||||
for(int j=0;j<3;j++){
|
||||
color[i] = color[i]*256+rgb1[j]+(rgb2[j]-rgb1[j])*i/(length-1);
|
||||
}
|
||||
}
|
||||
return color;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package xanadu.enderdragon.utils;
|
||||
|
||||
import org.bukkit.scheduler.BukkitRunnable;
|
||||
import xanadu.enderdragon.config.Lang;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.net.URL;
|
||||
import java.net.URLConnection;
|
||||
|
||||
import static xanadu.enderdragon.EnderDragon.plugin;
|
||||
import static xanadu.enderdragon.config.Lang.*;
|
||||
|
||||
public class Updater {
|
||||
public static void checkUpdate(){
|
||||
new BukkitRunnable(){
|
||||
@Override
|
||||
public void run(){
|
||||
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)) {
|
||||
warn(Lang.plugin_out_of_date.replace("{0}",localVer).replace("{1}",newVer));
|
||||
}
|
||||
else{
|
||||
info(Lang.plugin_up_to_date.replace("{1}",newVer));
|
||||
}
|
||||
} catch (Exception e) {
|
||||
warn(plugin_check_update_fail);
|
||||
}
|
||||
}
|
||||
}.runTaskAsynchronously(plugin);
|
||||
info(Lang.plugin_checking_update);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package xanadu.enderdragon.utils;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
|
||||
import static xanadu.enderdragon.config.Lang.info;
|
||||
import static xanadu.enderdragon.config.Lang.warn;
|
||||
|
||||
public class Version {
|
||||
private static String version = "no version found";
|
||||
public static void init(){
|
||||
try {
|
||||
version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
|
||||
} catch (ArrayIndexOutOfBoundsException exception) {
|
||||
warn("ArrayIndexOutOfBoundsExceptions, please make sure the path is correct and exists!");
|
||||
}
|
||||
info("Found version: " + version);
|
||||
}
|
||||
public static String getVersion() {
|
||||
return version;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user