update to v2.2.0

src/main/java/pers/xanadu/enderdragon/reward/Chance.java

@@ -0,0 +1,22 @@
+package pers.xanadu.enderdragon.reward;
+
+
+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;
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/reward/DistType.java

@@ -0,0 +1,28 @@
+package pers.xanadu.enderdragon.reward;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public enum DistType {
+    killer,
+    drop,//glow?
+    all,
+    rank,//num
+    pack,//num
+    termwise,
+    unknown;
+
+    private static final Map<String, DistType> mp = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+
+    public static DistType getByName(String str){
+        //if(str == null) return drop;
+        return mp.getOrDefault(str,unknown);
+    }
+    static {
+        DistType[] values = DistType.values();
+        for (DistType type : values) {
+            String name = type.name();
+            mp.put(name, type);
+        }
+    }
+}

src/main/java/pers/xanadu/enderdragon/reward/Reward.java

@@ -0,0 +1,50 @@
+package pers.xanadu.enderdragon.reward;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.manager.ItemManager;
+
+
+public class Reward extends ItemStack {
+    protected String name;
+    protected Chance chance;
+    private ItemStack item;
+
+    @Override
+    public String toString(){
+        return ItemManager.write(this);
+    }
+
+    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;
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/reward/RewardDist.java

@@ -0,0 +1,59 @@
+package pers.xanadu.enderdragon.reward;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.reward.dist.*;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+public abstract class RewardDist {
+    public static RewardDist parse(ConfigurationSection section){
+        if(section == null) return new Dist_Drop();
+        String type_name = section.getString("type");
+        DistType type = DistType.getByName(type_name);
+        switch (type){
+            case all : {
+                return new Dist_All();
+            }
+            case drop : {
+                return new Dist_Drop(section.getConfigurationSection("drop"));
+            }
+            case killer : {
+                return new Dist_Killer();
+            }
+            case pack : {
+                return new Dist_Pack(section.getConfigurationSection("pack"));
+            }
+            case rank : {
+                return new Dist_Rank(section.getConfigurationSection("rank"));
+            }
+            case termwise : {
+                return new Dist_Termwise();
+            }
+            default : {
+                Lang.error("Unknown reward_dist type: "+type_name);
+                return new Dist_Drop();
+            }
+        }
+    }
+    public List<ItemStack> getDropReward(MyDragon myDragon){
+        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());
+            }
+        }
+        return list;
+    }
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player killer){
+
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_All.java

@@ -0,0 +1,36 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.manager.DamageManager;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class Dist_All extends RewardDist {
+    @Override
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player killer){
+        ConcurrentHashMap<String,Double> damage_data = DamageManager.data.get(dragon.getUniqueId());
+        if(damage_data == null) return;
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        Bukkit.getOnlinePlayers().forEach(p->{
+            if(damage_data.containsKey(p.getName())){
+                boolean full = false;
+                for(ItemStack item : items){
+                    if(full || p.getInventory().firstEmpty() == -1){
+                        p.getWorld().dropItem(p.getLocation(),item);
+                        full = true;
+                    }
+                    else p.getInventory().addItem(item);
+                }
+                if(full) Lang.sendFeedback(p, Lang.dragon_player_inv_full);
+            }
+        });
+    }
+}

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_Drop.java

@@ -0,0 +1,53 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+import pers.xanadu.enderdragon.manager.GlowManager;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+import static pers.xanadu.enderdragon.manager.GlowManager.setGlowingColor;
+
+public class Dist_Drop extends RewardDist {
+    private final GlowManager.GlowColor color;
+    public Dist_Drop(ConfigurationSection section){
+        if(section == null) color = GlowManager.GlowColor.NONE;
+        else {
+            String color = section.getString("glow","NONE").toUpperCase();
+            this.color = GlowManager.GlowColor.valueOf(color);
+        }
+    }
+    public Dist_Drop(){
+        color = GlowManager.GlowColor.NONE;
+    }
+    @Override
+    public void handle_dist(final MyDragon myDragon, final EnderDragon dragon, final Player killer){
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        World world = dragon.getWorld();
+        Location loc = dragon.getLocation();
+        items.forEach(item->{
+            Item entity_item = world.dropItemNaturally(loc,item);
+            ChatColor color = getGlowColor();
+            if(color!=null) setGlowingColor(entity_item,color);
+            double x = ThreadLocalRandom.current().nextDouble(0.25);
+            double y = ThreadLocalRandom.current().nextDouble(0.25);
+            double z = ThreadLocalRandom.current().nextDouble(0.25);
+            entity_item.setVelocity(new Vector(x,y,z));
+        });
+    }
+
+    public ChatColor getGlowColor(){
+        return GlowManager.getGlowColor(color);
+    }
+}

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_Killer.java

@@ -0,0 +1,29 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.List;
+
+public class Dist_Killer extends RewardDist {
+    @Override
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player p){
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        if(p != null){
+            boolean full = false;
+            for(ItemStack item : items){
+                if(full || p.getInventory().firstEmpty() == -1){
+                    p.getWorld().dropItem(p.getLocation(),item);
+                    full = true;
+                }
+                else p.getInventory().addItem(item);
+            }
+            if(full) Lang.sendFeedback(p, Lang.dragon_player_inv_full);
+        }
+    }
+}

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_Pack.java

@@ -0,0 +1,53 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.manager.DamageManager;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.AExpJ;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class Dist_Pack extends RewardDist {
+    private final int max_num;
+    public Dist_Pack(ConfigurationSection section){
+        if(section == null) max_num = 1;
+        else max_num = section.getInt("max_num",1);
+    }
+
+    @Override
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player killer){
+        ConcurrentHashMap<String,Double> damage_data = DamageManager.data.get(dragon.getUniqueId());
+        if(damage_data == null) return;
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        int m = Math.min(max_num,damage_data.size());
+        if(m<=0) return;
+        List<String> receivers = AExpJ.sample(damage_data,m);
+        receivers.forEach(receiver->{
+            Player p = Bukkit.getPlayer(receiver);
+            if(p != null){
+                boolean full = false;
+                for(ItemStack item : items){
+                    if(full || p.getInventory().firstEmpty() == -1){
+                        p.getWorld().dropItem(p.getLocation(),item);
+                        full = true;
+                    }
+                    else p.getInventory().addItem(item);
+                }
+                if(full) Lang.sendFeedback(p, Lang.dragon_player_inv_full);
+            }
+        });
+    }
+
+    public int getMax_num(){
+        return max_num;
+    }
+}
+

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_Rank.java

@@ -0,0 +1,57 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.manager.DamageManager;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+public class Dist_Rank extends RewardDist {
+    private final int max_num;
+    public Dist_Rank(ConfigurationSection section){
+        if(section == null) max_num = 1;
+        else max_num = section.getInt("max_num",1);
+    }
+    public int getMax_num(){
+        return max_num;
+    }
+    @Override
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player killer){
+        ConcurrentHashMap<String,Double> damage_data = DamageManager.data.get(dragon.getUniqueId());
+        if(damage_data == null) return;
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        int m = Math.min(max_num,damage_data.size());
+        if(m<=0) return;
+        List<Map.Entry<String, Double>> list = damage_data.entrySet().stream().sorted(Dist_Rank::sortByDamage).collect(Collectors.toList());
+        for(int i=0;i<m;i++){
+            String name = list.get(i).getKey();
+            Player p = Bukkit.getPlayer(name);
+            if(p != null){
+                boolean full = false;
+                for(ItemStack item : items){
+                    if(full || p.getInventory().firstEmpty() == -1){
+                        p.getWorld().dropItem(p.getLocation(),item);
+                        full = true;
+                    }
+                    else p.getInventory().addItem(item);
+                }
+                if(full) Lang.sendFeedback(p, Lang.dragon_player_inv_full);
+            }
+        }
+    }
+    private static <T> int sortByDamage(Map.Entry<T, Double> e1,Map.Entry<T, Double> e2){
+        if(e2.getValue()>e1.getValue()) return 1;
+        if(e2.getValue().equals(e1.getValue())) return 0;
+        return -1;
+    }
+}

src/main/java/pers/xanadu/enderdragon/reward/dist/Dist_Termwise.java

@@ -0,0 +1,39 @@
+package pers.xanadu.enderdragon.reward.dist;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.manager.DamageManager;
+import pers.xanadu.enderdragon.reward.RewardDist;
+import pers.xanadu.enderdragon.util.AliasSample;
+import pers.xanadu.enderdragon.util.MyDragon;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class Dist_Termwise extends RewardDist {
+    @Override
+    public void handle_dist(final MyDragon myDragon,final EnderDragon dragon,final Player killer){
+        ConcurrentHashMap<String,Double> damage_data = DamageManager.data.get(dragon.getUniqueId());
+        if(damage_data == null) return;
+        List<ItemStack> items = getDropReward(myDragon);
+        if(items.isEmpty()) return;
+        AliasSample alias = new AliasSample(new ArrayList<>(damage_data.values()));
+        List<String> list = new ArrayList<>(damage_data.keySet());
+        items.forEach(item->{
+            int idx = alias.next();
+            String receiver = list.get(idx);
+            Player p = Bukkit.getPlayer(receiver);
+            if(p != null){
+                if(p.getInventory().firstEmpty() == -1){
+                    p.getWorld().dropItem(p.getLocation(),item);
+                    Lang.sendFeedback(p, Lang.dragon_player_inv_full);
+                }
+                else p.getInventory().addItem(item);
+            }
+        });
+    }
+}

src/main/java/pers/xanadu/enderdragon/script/Events.java

@@ -0,0 +1,101 @@
+package pers.xanadu.enderdragon.script;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.EventExecutor;
+import org.jetbrains.annotations.NotNull;
+import pers.xanadu.enderdragon.manager.GroovyManager;
+
+import static pers.xanadu.enderdragon.EnderDragon.plugin;
+
+public class Events<T extends Event> implements Listener, EventExecutor {
+    private final Consumer<T> consumer;
+    private final Class<T> clazz;
+    private boolean disabled;
+    private final AtomicLong expireTime;
+    public Events(Class<T> clazz, Consumer<T> consumer) {
+        this.clazz = clazz;
+        this.consumer = consumer;
+        this.expireTime = new AtomicLong(-1L);
+        this.disabled = false;
+    }
+
+    public void unregister() {
+        if (!this.disabled) {
+            try {
+                Method method = this.clazz.getMethod("getHandlerList");
+                HandlerList handlerList = (HandlerList) method.invoke(null);
+                if (Bukkit.isPrimaryThread()) {
+                    handlerList.unregister(this);
+                }
+                else {
+                    Bukkit.getScheduler().runTask(plugin, () -> handlerList.unregister(this));
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            this.disabled = true;
+        }
+    }
+    public static <T extends Event> Events<T> registerPersistently(Class<T> clazz, Consumer<T> consumer) {
+        return Events.registerPersistently(clazz, EventPriority.NORMAL, false, consumer);
+    }
+    public static <T extends Event> Events<T> registerPersistently(Class<T> clazz, EventPriority priority, boolean ignoreCancelled, Consumer<T> consumer) {
+        Events<T> tmp = new Events<>(clazz, consumer);
+        if (Bukkit.isPrimaryThread()) {
+            Bukkit.getPluginManager().registerEvent(clazz,tmp,priority,tmp,plugin,ignoreCancelled);
+        }
+        else {
+            Bukkit.getScheduler().runTask(plugin, () -> Bukkit.getPluginManager().registerEvent(clazz,tmp,priority,tmp,plugin,ignoreCancelled));
+        }
+        return tmp;
+    }
+    public static <T extends Event> Events<T> register(Class<T> clazz, Consumer<T> consumer) {
+        return Events.register(clazz, EventPriority.NORMAL, false, consumer);
+    }
+    public static <T extends Event> Events<T> register(Class<T> clazz, EventPriority priority, boolean ignoreCancelled, Consumer<T> consumer) {
+        Events<T> tmp = new Events<>(clazz, consumer);
+        if (Bukkit.isPrimaryThread()) {
+            Bukkit.getPluginManager().registerEvent(clazz,tmp,priority,tmp,plugin,ignoreCancelled);
+        }
+        else {
+            Bukkit.getScheduler().runTask(plugin, () -> Bukkit.getPluginManager().registerEvent(clazz,tmp,priority,tmp,plugin,ignoreCancelled));
+        }
+        GroovyManager.event_set.add(tmp);
+        return tmp;
+    }
+//    private static <T extends Event> void register(Class<T> clazz, Events<T> event, EventPriority priority, boolean ignoreCancelled) {
+//        Bukkit.getPluginManager().registerEvent(clazz,event,priority,event,plugin,ignoreCancelled);
+//    }
+
+    @Override
+    public void execute(@NotNull Listener listener, @NotNull Event event) {
+        if (this.expireTime.get() > 0L && System.currentTimeMillis() > this.expireTime.get()) {
+            Bukkit.getScheduler().runTask(plugin, this::unregister);
+            return;
+        }
+        if (this.clazz.isInstance(event)) {
+            this.consumer.accept((T) event);
+        }
+    }
+    public Events<T> withTime(long time) {
+        this.expireTime.set(time);
+        return this;
+    }
+
+    public boolean cancelIfExpired() {
+        if (this.expireTime.get() > 0L && System.currentTimeMillis() > this.expireTime.get()) {
+            this.unregister();
+            return true;
+        }
+        return false;
+    }
+
+}
+

src/main/java/pers/xanadu/enderdragon/task/DragonRespawnRunnable.java

@@ -0,0 +1,37 @@
+package pers.xanadu.enderdragon.task;
+
+import org.bukkit.scheduler.BukkitRunnable;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.EnderDragon;
+
+import static pers.xanadu.enderdragon.EnderDragon.*;
+
+public class DragonRespawnRunnable extends BukkitRunnable {
+    private final Task task;
+    public DragonRespawnRunnable(Task task){
+        this.task = task;
+    }
+    @Override
+    public void run(){
+        if(task == null) {
+            this.cancel();
+            Lang.error("The config of auto-respawn errors!Task has been disabled...");
+            return;
+        }
+        if(task.isTimeUp()){
+            new BukkitRunnable(){
+                @Override
+                public void run(){
+                    EnderDragon.getInstance().getDragonManager().initiateRespawn(task.world_name);
+                    task.updateTime();
+                    task.saveFile();
+                }
+            }.runTask(plugin);
+        }
+    }
+    public void start(){
+        this.runTaskTimerAsynchronously(plugin,0,200L);
+    }
+
+
+}

src/main/java/pers/xanadu/enderdragon/task/DragonRespawnTimer.java

@@ -0,0 +1,82 @@
+package pers.xanadu.enderdragon.task;
+
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitRunnable;
+import pers.xanadu.enderdragon.EnderDragon;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.util.MathUtil;
+
+import static pers.xanadu.enderdragon.EnderDragon.plugin;
+
+public class DragonRespawnTimer {
+    private final String world_name;
+    private final int delay;
+    private BukkitRunnable runnable;
+    private int remainSecond;
+    private boolean isRunning;
+    public DragonRespawnTimer(String WorldName,int second){
+        this(WorldName,second,second);
+    }
+    public DragonRespawnTimer(String WorldName,int second,int rest_second){
+        this.world_name = WorldName;
+        this.delay = second;
+        this.remainSecond = rest_second;
+        this.isRunning = false;
+        resetRunnable();
+    }
+    public void run(){
+        if(!isRunning) runnable.runTaskTimerAsynchronously(plugin,0L,20L);
+        isRunning = true;
+    }
+    public void update(){
+        remainSecond = delay;
+        runnable.cancel();
+        isRunning = false;
+        resetRunnable();
+    }
+    public void del(){
+        if(isRunning) runnable.cancel();
+    }
+    public String getWorld_name(){
+        return this.world_name;
+    }
+    public int getSetTime(){
+        return this.delay;
+    }
+    public int getRestTime(){
+        return this.remainSecond;
+    }
+    public boolean isRunning(){
+        return isRunning;
+    }
+    public double getProgress(){
+        return 1d*remainSecond/delay;
+    }
+    @Override
+    public String toString(){
+        return "(" + world_name + ") " +
+                "remain:" + MathUtil.formatDuration(remainSecond) +
+                ", set:" + MathUtil.formatDuration(delay);
+    }
+    private void resetRunnable(){
+        this.runnable = new BukkitRunnable() {
+            @Override
+            public void run() {
+                remainSecond--;
+                if(remainSecond <= 0){
+                    Bukkit.getScheduler().runTask(plugin,() -> {
+                        if(EnderDragon.getInstance().getDragonManager().canRespawn(world_name)){
+                            EnderDragon.getInstance().getDragonManager().initiateRespawn(world_name);
+                            update();
+                        }
+                        else {
+                            remainSecond = delay;
+                            Lang.error(Lang.command_respawn_cd_retry);
+                        }
+                    });
+                }
+            }
+        };
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/task/Task.java

@@ -0,0 +1,94 @@
+package pers.xanadu.enderdragon.task;
+
+import pers.xanadu.enderdragon.EnderDragon;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.manager.TaskManager;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+import static pers.xanadu.enderdragon.EnderDragon.data;
+import static pers.xanadu.enderdragon.EnderDragon.dataF;
+import static pers.xanadu.enderdragon.manager.TaskManager.getRoundTimeStr;
+
+public abstract class Task {
+    protected int period;
+    protected int day;
+    private final TaskType type;
+    protected abstract LocalDateTime initNextTime(LocalDateTime cur);
+    public abstract void updateTime();
+    protected LocalDateTime nextTime;
+    protected final String world_name;
+    protected final String unique_name;
+    protected Task(TaskType type, String unique_name,String world_name,String str){
+        this.type = type;
+        this.unique_name = unique_name;
+        this.world_name = world_name;
+        switch (type){
+            case minute :
+            case hour : {
+                this.period = Integer.parseInt(str);
+                break;
+            }
+            case day : {
+                this.period = Integer.parseInt(str.split(",")[0]);
+                break;
+            }
+            case week :
+            case month :
+            case year : {
+                this.day = Integer.parseInt(str.split(",")[0]);
+                break;
+            }
+        }
+        char split = data.options().pathSeparator();
+        String next_time = EnderDragon.data.getString("auto_respawn"+split+unique_name+split+"next_respawn_time");
+        if(next_time == null){
+            switch (type){
+                case minute :
+                case hour : {
+                    this.nextTime = this.initNextTime(LocalDateTime.now().withSecond(0));
+                    break;
+                }
+                case day :
+                case week :
+                case month :
+                case year : {
+                    calcNextTime(str);
+                    break;
+                }
+            }
+            this.saveFile();
+        }
+        else this.nextTime = TaskManager.getLocalDateTime(next_time);
+    }
+    private void calcNextTime(String str){
+        LocalTime time = TaskManager.getRoundTime(str.split(",")[1]);
+        if(time != null) this.nextTime = this.initNextTime(LocalDateTime.now().withSecond(0).with(time));
+        else this.nextTime = this.initNextTime(LocalDateTime.now().withSecond(0));
+    }
+    public boolean isTimeUp(){
+        LocalDateTime now = LocalDateTime.now().plusSeconds(1);
+        if(now.isAfter(nextTime)){
+            return true;
+        }
+        return false;
+    }
+    public void saveFile(){
+        char split = data.options().pathSeparator();
+        String path = "auto_respawn"+split+unique_name+split;
+        data.set(path+"world_name",world_name);
+        data.set(path+"next_respawn_time",getRoundTimeStr(nextTime));
+        try{
+            data.save(dataF);
+        }catch (IOException ex){
+            Lang.error(Lang.plugin_file_save_error.replaceAll("\\{file_name}",dataF.getName()));
+        }
+    }
+
+    public TaskType getType(){
+        return this.type;
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/task/TaskType.java

@@ -0,0 +1,26 @@
+package pers.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);
+        }
+    }
+}

src/main/java/pers/xanadu/enderdragon/task/type/Day.java

@@ -0,0 +1,21 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.LocalDateTime;
+
+public class Day extends Task {
+
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.plusDays(period);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusDays(period);
+    }
+    public Day(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+}

src/main/java/pers/xanadu/enderdragon/task/type/Hour.java

@@ -0,0 +1,20 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.LocalDateTime;
+
+public class Hour extends Task {
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.plusHours(period);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusHours(period);
+    }
+    public Hour(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+}

src/main/java/pers/xanadu/enderdragon/task/type/Minute.java

@@ -0,0 +1,22 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.LocalDateTime;
+
+public class Minute extends Task {
+
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.plusMinutes(period);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusMinutes(period);
+    }
+
+    public Minute(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+}

src/main/java/pers/xanadu/enderdragon/task/type/Month.java

@@ -0,0 +1,21 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.LocalDateTime;
+
+public class Month extends Task {
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.plusMonths(1).withDayOfMonth(day);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusMonths(1).withDayOfMonth(day);
+    }
+    public Month(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/task/type/Week.java

@@ -0,0 +1,22 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.DayOfWeek;
+import java.time.LocalDateTime;
+
+public class Week extends Task {
+
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.with(DayOfWeek.of(day)).plusDays(7);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusDays(7);
+    }
+    public Week(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+}

src/main/java/pers/xanadu/enderdragon/task/type/Year.java

@@ -0,0 +1,20 @@
+package pers.xanadu.enderdragon.task.type;
+
+import pers.xanadu.enderdragon.task.Task;
+import pers.xanadu.enderdragon.task.TaskType;
+
+import java.time.LocalDateTime;
+
+public class Year extends Task {
+    @Override
+    public LocalDateTime initNextTime(LocalDateTime cur) {
+        return cur.plusYears(1).withDayOfMonth(day);
+    }
+    @Override
+    public void updateTime(){
+        this.nextTime = LocalDateTime.now().withSecond(0).plusYears(1);
+    }
+    public Year(TaskType type, String unique_name,String world_name,String str){
+        super(type,unique_name,world_name,str);
+    }
+}

src/main/java/pers/xanadu/enderdragon/util/AExpJ.java

@@ -0,0 +1,63 @@
+package pers.xanadu.enderdragon.util;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
+
+public final class AExpJ {
+    public static <T> List<T> sample(final ConcurrentHashMap<T,Double> mp,int m){
+        List<Pair<T,Double>> list = new ArrayList<>();
+        mp.forEach((k,v)->list.add(new Pair<>(k,v)));
+        return sample(list,m);
+    }
+    public static <T> List<T> sample(final List<Pair<T,Double>> samples, int m) {
+        PriorityQueue<Pair<T,Double>> heap = new PriorityQueue<>(Comparator.comparingDouble(p -> p.second));
+        double Xw = 0.0;
+        double Tw = 0.0;
+        double w_acc = 0.0;
+        for (Pair<T,Double> sample : samples) {
+            if (heap.size() < m) {
+                double wi = sample.second;
+                double ui = ThreadLocalRandom.current().nextDouble();
+                double ki = Math.pow(ui, 1 / wi);
+                heap.offer(new Pair<>(sample.first, ki));
+                continue;
+            }
+            if (w_acc == 0) {
+                if (heap.isEmpty()) break;
+                Tw = heap.peek().second;
+                double r = ThreadLocalRandom.current().nextDouble();
+                Xw = Math.log(r) / Math.log(Tw);
+            }
+            double wi = sample.second;
+            if (w_acc + wi < Xw) {
+                w_acc += wi;
+                continue;
+            }
+            else w_acc = 0;
+            double tw = Math.pow(Tw, wi);
+            double r2 = ThreadLocalRandom.current().nextDouble() * (1 - tw) + tw;
+            double ki = Math.pow(r2, 1 / wi);
+            heap.poll();
+            heap.offer(new Pair<>(sample.first, ki));
+        }
+        List<T> res = new ArrayList<>();
+        for (Pair<T,Double> pair : heap) {
+            res.add(pair.first);
+        }
+        return res;
+    }
+
+//    public static void main(String[] args) {
+//        List<Pair<String,Double>> samples = new ArrayList<>();
+//        samples.add(new Pair<>("item1", 0.8));
+//        samples.add(new Pair<>("item2", 0.4));
+//        samples.add(new Pair<>("item3", 0.2));
+//        Map<String,Integer> mp = new HashMap<>();
+//        for(int i=0;i<1e5;i++){
+//            List<String> result = sample(samples, 1);
+//            mp.compute(result.get(0), (k, v)->v==null?1:v+1);
+//        }
+//        System.out.println(mp);
+//    }
+}

src/main/java/pers/xanadu/enderdragon/util/AliasSample.java

@@ -0,0 +1,42 @@
+package pers.xanadu.enderdragon.util;
+
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+public final class AliasSample {
+    private final int[] alias;
+    private final double[] probability;
+    public AliasSample(List<Double> probabilities) {
+        if (probabilities == null) throw new NullPointerException();
+        if (probabilities.size() == 0)
+            throw new IllegalArgumentException("Probability vector can't be empty.");
+        this.probability = new double[probabilities.size()];
+        this.alias = new int[probabilities.size()];
+        final double average = 1.0 / probabilities.size();
+        probabilities = new ArrayList<>(probabilities);//make a copy of list, avoid modifying the param
+        Deque<Integer> small = new ArrayDeque<>();
+        Deque<Integer> large = new ArrayDeque<>();
+        for (int i = 0; i < probabilities.size(); ++i) {
+            if (probabilities.get(i) >= average) large.add(i);
+            else small.add(i);
+        }
+        while (!small.isEmpty() && !large.isEmpty()) {
+            int less = small.removeLast();
+            int more = large.removeLast();
+            probability[less] = probabilities.get(less) * probabilities.size();
+            alias[less] = more;
+            probabilities.set(more, (probabilities.get(more) + probabilities.get(less)) - average);
+            if (probabilities.get(more) >= 1.0 / probabilities.size()) large.add(more);
+            else small.add(more);
+        }
+        while (!small.isEmpty()) probability[small.removeLast()] = 1.0;
+        while (!large.isEmpty()) probability[large.removeLast()] = 1.0;
+    }
+
+    public int next() {
+        int column = ThreadLocalRandom.current().nextInt(probability.length);
+        boolean coinToss = ThreadLocalRandom.current().nextDouble() < probability[column];
+        return coinToss ? column : alias[column];
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/ColorUtil.java

@@ -0,0 +1,69 @@
+package pers.xanadu.enderdragon.util;
+
+import net.md_5.bungee.api.ChatColor;
+
+import java.awt.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static pers.xanadu.enderdragon.util.Version.mcMainVersion;
+
+public class ColorUtil {
+
+    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 parse(String str){
+        if(mcMainVersion >= 16){
+            return org.bukkit.ChatColor.translateAlternateColorCodes('&',transGradient(str));
+        }
+        else{
+            return org.bukkit.ChatColor.translateAlternateColorCodes('&',str);
+        }
+    }
+    private static String translateHexCodes(String 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());
+    }
+    private static String transGradient(String 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 = MathUtil.hexToInt(start);
+        int[] rgb2 = MathUtil.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;
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/ExtraPotionEffect.java

@@ -0,0 +1,32 @@
+package pers.xanadu.enderdragon.util;
+
+import org.bukkit.entity.Player;
+
+public class ExtraPotionEffect {
+    private final ExtraPotionEffectType type;
+    private final int tick;
+
+    public void apply(final Player player){
+        switch (type){
+            case fire: {
+                player.setFireTicks(player.getFireTicks()+tick);
+                break;
+            }
+            case freeze: {
+                player.setFreezeTicks(player.getFreezeTicks()+tick);
+                break;
+            }
+        }
+    }
+    public ExtraPotionEffect(final String effect,int second){
+        this(ExtraPotionEffectType.valueOf(effect.toLowerCase()),second);
+    }
+    public ExtraPotionEffect(final ExtraPotionEffectType type,int second){
+        this.type = type;
+        this.tick = second*20;
+    }
+    public enum ExtraPotionEffectType{
+        fire,
+        freeze
+    }
+}

src/main/java/pers/xanadu/enderdragon/util/MathUtil.java

@@ -0,0 +1,100 @@
+package pers.xanadu.enderdragon.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class MathUtil {
+    public static int floor(double d) {
+        int i = (int)d;
+        return d < (double)i ? i - 1 : i;
+    }
+    public static double c(final Entity entity, double x, double y, double z) {
+        Location loc = entity.getLocation();
+        double d0 = loc.getX() - x;
+        double d1 = loc.getY() - y;
+        double d2 = loc.getZ() - z;
+        return d0 * d0 + d1 * d1 + d2 * d2;
+    }
+    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(final 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(final Location loc){
+        if (loc.getWorld() == null) return "";
+        return loc.getWorld().getName()+";"+loc.getX()+";"+loc.getY()+";"+loc.getZ();
+    }
+    public static Location stringToLocation(final String str){
+        final String[] parts = str.split(";");
+        if(parts.length != 4) return null;
+        final World world = Bukkit.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);
+    }
+    public static String formatDuration(int seconds) {
+        if (seconds < 0) throw new IllegalArgumentException("Duration must be a positive number.");
+        int days = seconds / (24 * 3600);
+        int hours = (seconds % (24 * 3600)) / 3600;
+        int minutes = ((seconds % (24 * 3600)) % 3600) / 60;
+        int remainingSeconds = ((seconds % (24 * 3600)) % 3600) % 60;
+        StringBuilder duration = new StringBuilder();
+        boolean f = false;
+        if(days>0){
+            duration.append(days).append("d");
+            f = true;
+        }
+        if(f||hours>0){
+            duration.append(hours).append("h");
+            f = true;
+        }
+        if(f||minutes>0){
+            duration.append(minutes).append("m");
+        }
+        duration.append(remainingSeconds).append("s");
+        return duration.toString();
+    }
+    public static int[] getDate(int seconds){
+        if (seconds < 0) throw new IllegalArgumentException("Duration must be a positive number.");
+        int days = seconds / (24 * 3600);
+        int hours = (seconds % (24 * 3600)) / 3600;
+        int minutes = ((seconds % (24 * 3600)) % 3600) / 60;
+        int remainingSeconds = ((seconds % (24 * 3600)) % 3600) % 60;
+        return new int[]{days,hours,minutes,remainingSeconds};
+    }
+    @Deprecated
+    public static <K> K getByWeight(final ConcurrentHashMap<K,Double> mp){
+        double sum = mp.values().stream().mapToDouble(Double::doubleValue).sum();
+        double rand = ThreadLocalRandom.current().nextDouble(sum);
+        final AtomicReference<Double> cur = new AtomicReference<>(0d);
+        final AtomicReference<K> res = new AtomicReference<>();
+        mp.forEach((k,v)->{
+            Double value = cur.get();
+            if(value<=rand && value+v>rand) {
+                res.set(k);
+                return;
+            }
+            cur.updateAndGet(v1 -> v1 + v);
+        });
+        return res.get();
+    }
+}

src/main/java/pers/xanadu/enderdragon/util/MyDragon.java

@@ -0,0 +1,62 @@
+package pers.xanadu.enderdragon.util;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import pers.xanadu.enderdragon.reward.Reward;
+import pers.xanadu.enderdragon.reward.RewardDist;
+
+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 no_damage_tick;
+    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<ExtraPotionEffect> attack_extra_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<>();
+    public RewardDist reward_dist;
+
+    @Override
+    public int compareTo(final MyDragon o) {
+        return o.priority - this.priority;//降序
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/NMSUtil.java

@@ -0,0 +1,453 @@
+package pers.xanadu.enderdragon.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import pers.xanadu.enderdragon.EnderDragon;
+import pers.xanadu.enderdragon.config.Config;
+import pers.xanadu.enderdragon.config.Lang;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import static pers.xanadu.enderdragon.EnderDragon.getInstance;
+
+public class NMSUtil {
+    private String getEDB_base;
+    private Method getNMSWord;
+    private Method asNMSCopy;
+    private Method copyNMSStack;
+    private Method asBukkitCopy;
+    private Method asCraftMirror;
+    private Method asCraftCopy;
+    private Method NMSItemStack_save;
+    private Method NMSItemStack_setTag;
+    private Method cpdToEi;
+    private Method stringToCPD;
+    private Method stringToNBTBase;
+    private Method serializeNBTBase;
+    private Method deserializeObject;
+    private Method PDCtoCPD;
+    private Method PersistentDataContainer_putAll;
+    private Method NBTTagCompound_set;
+    private Field unhandledTags;
+    private Field internalTag;
+    private Field MOJANGSON_PARSER;
+    private Field world_c_environment;
+    private Field NBTTagCompound_map;
+    private Class<?> WorldClass;
+    private Class<?> CraftWorldClass;
+    private Class<?> WorldProviderClass;
+    private Class<?> WorldProviderTheEndClass;
+    private Class<?> CraftItemStackClass;
+    private Class<?> CraftMetaItemClass;
+    private Class<?> NMSItemStackClass;
+    private Class<?> CraftEntityClass;
+    private Class<?> NBTTagCompoundClass;
+    private Class<?> NBTBaseClass;
+    private Class<?> MojangsonParserClass;
+    private Class<?> CraftNBTTagConfigSerializerClass;
+    private Class<?> CraftPersistentDataContainerClass;
+
+    public void init(){
+        String version = Version.getVersion();
+        try{
+            this.CraftWorldClass = Class.forName("org.bukkit.craftbukkit." + version + ".CraftWorld");
+            this.getNMSWord = CraftWorldClass.getDeclaredMethod("getHandle");
+            this.WorldClass = this.getNMSWord.getReturnType().getSuperclass();
+            this.world_c_environment = CraftWorldClass.getDeclaredField("environment");
+            this.world_c_environment.setAccessible(true);
+            if(Version.mcMainVersion>=12 && Version.mcMainVersion<16){
+                this.WorldProviderClass = Class.forName("net.minecraft.server."+version+".WorldProvider");
+                this.WorldProviderTheEndClass = Class.forName("net.minecraft.server."+version+".WorldProviderTheEnd");
+            }
+            this.CraftItemStackClass = Class.forName("org.bukkit.craftbukkit." + version + ".inventory.CraftItemStack");
+            this.CraftMetaItemClass = Class.forName("org.bukkit.craftbukkit." + version + ".inventory.CraftMetaItem");
+            this.unhandledTags = CraftMetaItemClass.getDeclaredField("unhandledTags");
+            unhandledTags.setAccessible(true);
+            this.internalTag = CraftMetaItemClass.getDeclaredField("internalTag");
+            internalTag.setAccessible(true);
+            this.NMSItemStackClass = CraftItemStackClass.getDeclaredField("handle").getType();
+            this.CraftEntityClass = Class.forName("org.bukkit.craftbukkit."+version+".entity.CraftEntity");
+            init_NBTTagCompoundClass();
+            init_NBTBaseClass();
+            init_NBTTagCompound_map();
+            this.NBTTagCompound_set = NBTTagCompoundClass.getMethod(getMethodName(ReflectiveMethod.NBTTagCompound_set),String.class,NBTBaseClass);
+            this.asNMSCopy = CraftItemStackClass.getMethod("asNMSCopy",ItemStack.class);
+            this.copyNMSStack = CraftItemStackClass.getMethod("copyNMSStack",NMSItemStackClass,int.class);
+            this.asBukkitCopy = CraftItemStackClass.getMethod("asBukkitCopy",NMSItemStackClass);
+            this.asCraftMirror = CraftItemStackClass.getMethod("asCraftMirror",NMSItemStackClass);
+            this.asCraftCopy = CraftItemStackClass.getMethod("asCraftCopy",ItemStack.class);
+            this.NMSItemStack_save = NMSItemStackClass.getMethod(getMethodName(ReflectiveMethod.NMSItemStack_save),NBTTagCompoundClass);
+            this.NMSItemStack_setTag = NMSItemStackClass.getMethod(getMethodName(ReflectiveMethod.NMSItemStack_setTag),NBTTagCompoundClass);
+            if(Version.mcMainVersion>=13) this.cpdToEi = NMSItemStackClass.getMethod("a",NBTTagCompoundClass);
+
+            if(Version.mcMainVersion<=16) this.MojangsonParserClass = Class.forName("net.minecraft.server."+version+".MojangsonParser");
+            else this.MojangsonParserClass = Class.forName("net.minecraft.nbt.MojangsonParser");
+            this.stringToCPD = MojangsonParserClass.getMethod(getMethodName(ReflectiveMethod.MojangsonParser_parse),String.class);
+            this.stringToNBTBase = MojangsonParserClass.getDeclaredMethod(getMethodName(ReflectiveMethod.MojangsonParser_parseLiteral),String.class);
+            stringToNBTBase.setAccessible(true);
+
+            if(Version.mcMainVersion>13 || "v1_13_R2".equals(Version.getVersion())){
+                this.CraftNBTTagConfigSerializerClass = Class.forName("org.bukkit.craftbukkit." + version + ".util.CraftNBTTagConfigSerializer");
+                this.serializeNBTBase = CraftNBTTagConfigSerializerClass.getMethods()[0];
+                this.deserializeObject = CraftNBTTagConfigSerializerClass.getMethod("deserialize",Object.class);
+                this.MOJANGSON_PARSER = CraftNBTTagConfigSerializerClass.getDeclaredField("MOJANGSON_PARSER");
+                MOJANGSON_PARSER.setAccessible(true);
+            }
+            if(Version.mcMainVersion>=14){
+                this.CraftPersistentDataContainerClass = Class.forName("org.bukkit.craftbukkit." + version + ".persistence.CraftPersistentDataContainer");
+                this.PDCtoCPD = CraftPersistentDataContainerClass.getDeclaredMethod("toTagCompound");
+                this.PersistentDataContainer_putAll = CraftPersistentDataContainerClass.getDeclaredMethod("putAll",NBTTagCompoundClass);
+            }
+
+
+
+        }catch(ReflectiveOperationException e){
+            e.printStackTrace();
+        }
+        switch (version) {
+            case "v1_12_R1" : {
+                getEDB_base = "t";
+                break;
+            }
+            case "v1_13_R1" :
+            case "v1_13_R2" : {
+                getEDB_base = "r";
+                break;
+            }
+            case "v1_14_R1" : {
+                getEDB_base = "q";
+                break;
+            }
+            case "v1_15_R1" : {
+                getEDB_base = "o";
+                break;
+            }
+            default : getEDB_base = null;
+        }
+        if(Config.debug) check();
+    }
+    public void check(){
+        try{
+            Field[] fields = NMSUtil.class.getDeclaredFields();
+            for(Field field : fields){
+                Bukkit.getLogger().info(field.getName()+"->"+field.get(this));
+            }
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+        }
+    }
+//    public Object getMetaCPD(ItemMeta meta){
+//        try{
+//            Object craft_meta = CraftMetaItemClass.cast(meta);
+//            Object internalTag = this.internalTag.get(craft_meta);
+//            return internalTag;
+//        }catch (ReflectiveOperationException e){
+//            e.printStackTrace();
+//            return null;
+//        }
+//    }
+
+    /**
+     * 只保留物品type和amount
+     * nbt深合并需要遍历每一层
+     */
+    @Deprecated
+    public ItemStack mergeItemCPD(final ItemStack item,final Object cpd){
+        Map<String,Object> self = cpdToMap(getCPD(item));
+        Map<String,Object> rhs = cpdToMap(cpd);
+        self.putAll(rhs);
+        Object new_cpd = getNBTTagCompound(self);
+        return EnderDragon.getInstance().getNMSItemManager().cpdToItem(new_cpd);
+    }
+    public Map<String,Object> cpdToMap(final Object cpd){
+        try{
+            return (Map<String, Object>) NBTTagCompound_map.get(cpd);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public Object getNBTTagCompound(final Map<String,Object> mp){
+        try{
+            Object cpd = NBTTagCompoundClass.newInstance();
+            mp.forEach((key,value)->{
+                Object res;
+                if(value instanceof Map){
+                    res = getNBTTagCompound((Map<String, Object>) value);
+                }
+                else res = value;
+                try{
+                    NBTTagCompound_set.invoke(cpd,key,res);
+                }catch (ReflectiveOperationException e){
+                    throw new RuntimeException("Reflective error!");
+                }
+            });
+            return cpd;
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public Object StringParseLiteral(final String str){
+        try{
+            return stringToNBTBase.invoke(MOJANGSON_PARSER.get(null),str);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public void setPersistentDataContainer(final PersistentDataContainer dataContainer,final Object cpd){
+        try{
+            Object PDC = CraftPersistentDataContainerClass.cast(dataContainer);
+            PersistentDataContainer_putAll.invoke(PDC,cpd);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+        }
+    }
+    public String PDCtoString(final PersistentDataContainer dataContainer){
+        try{
+            Object PDC = CraftPersistentDataContainerClass.cast(dataContainer);
+            return PDCtoCPD.invoke(PDC).toString();
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Object deserializeObject(final Object object){
+        try{
+            return deserializeObject.invoke(null,object);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public Object serializeNBTBase(final Object nbt_base){
+        try{
+            return serializeNBTBase.invoke(null, nbt_base);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public void setUnhandledTags(final ItemMeta meta, Map<String,?> unhandledTags){
+        try{
+            Object craft_meta = CraftMetaItemClass.cast(meta);
+            this.unhandledTags.set(craft_meta, unhandledTags);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+        }
+    }
+    public Map<String,Object> getUnhandledTags(final ItemMeta meta){
+        try{
+            Object craft_meta = CraftMetaItemClass.cast(meta);
+            Object unhandledTags = this.unhandledTags.get(craft_meta);
+            return (Map<String, Object>) unhandledTags;
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public ItemStack applyItemTag(final ItemStack item,final Object cpd){
+        try{
+            Object ei = asNMSCopy.invoke(null,item);
+            NMSItemStack_setTag.invoke(ei,cpd);
+            return (ItemStack) asBukkitCopy.invoke(null,ei);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return new ItemStack(Material.AIR);
+        }
+    }
+    public String getNBT(final ItemStack item){
+        try{
+            Object ci = CraftItemStackClass.isInstance(item)?CraftItemStackClass.cast(item):asCraftCopy.invoke(null,item);
+            Object ei = asNMSCopy.invoke(null, ci);
+            Object cpd = NMSItemStack_save.invoke(ei, NBTTagCompoundClass.newInstance());
+            return cpd.toString();
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return "{id:\"minecraft:air\"}";
+        }
+    }
+    public Object getCPD(final ItemStack item){
+        try{
+            Object ci = CraftItemStackClass.isInstance(item)?CraftItemStackClass.cast(item):asCraftCopy.invoke(null,item);
+            Object ei = asNMSCopy.invoke(null, ci);
+            return NMSItemStack_save.invoke(ei, NBTTagCompoundClass.newInstance());
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public Object getCPD(final String nbt){
+        try{
+            return stringToCPD.invoke(null,nbt);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    /**
+     *  仅1.13+可用
+     */
+    public ItemStack getItemStack(final Object cpd){
+        try{
+            Object ei = cpdToEi.invoke(null,cpd);
+            Object ci = asBukkitCopy.invoke(null,ei);
+            return (ItemStack) ci;
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    /**
+     *  仅1.13+可用
+     */
+    public ItemStack getItemStack(final String nbt){
+        try{
+            Object cpd = stringToCPD.invoke(null,nbt);
+            Object ei = cpdToEi.invoke(null,cpd);
+            Object ci = asBukkitCopy.invoke(null,ei);
+            return (ItemStack) ci;
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+            return null;
+        }
+    }
+    public void setEnvironment(final World world,final World.Environment env){
+        Object world_c = getCraftWorld(world);
+        try{
+            //Object old_env = world_c_environment.get(world_c);
+            world_c_environment.set(world_c,env);
+        }catch (ReflectiveOperationException e){
+            e.printStackTrace();
+        }
+    }
+    public Object getEnderDragonBattle(final World world){
+        String version = Version.getVersion();
+        if (Version.mcMainVersion>=12 && Version.mcMainVersion<16) {
+            try {
+                Object worldServer = getInstance().getNMSManager().getWorldServer(world);
+                assert worldServer != null;
+                Field field = worldServer.getClass().getField("worldProvider");
+                Object worldProvider = field.get(worldServer);
+                Object WorldProviderTheEnd = WorldProviderTheEndClass.cast(worldProvider);
+                String method_name = getInstance().getNMSManager().getEDB_base;
+                if(method_name == null) return null;
+                Method method = WorldProviderTheEnd.getClass().getDeclaredMethod(method_name);
+                return method.invoke(WorldProviderTheEnd);
+            } catch (ReflectiveOperationException e) {
+                Lang.warn("Your server version (" + version + ") is not supported!");
+                e.printStackTrace();
+            }
+        }
+        Lang.warn("Your server version (" + version + ") is not supported!");
+        return null;
+    }
+    public Object getWorldServer(final World ThisWorld) {
+        try {
+            Object castClass = getCraftWorld(ThisWorld);
+            return this.CraftWorldClass.getDeclaredMethod("getHandle").invoke(castClass);
+        } catch (ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+    public Object getCraftWorld(final World ThisWorld) {
+        if (this.CraftWorldClass.isInstance(ThisWorld)) return this.CraftWorldClass.cast(ThisWorld);
+        return null;
+    }
+    public Object getWorld_e(final World world){
+        try {
+            Object world_c = getCraftWorld(world);
+            return this.getNMSWord.invoke(world_c);
+        } catch (ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+    public Class<?> getNBTBaseClass(){
+        return this.NBTBaseClass;
+    }
+    public Class<?> getNBTTagCompoundClass(){
+        return this.NBTTagCompoundClass;
+    }
+    public Class<?> getWorldClass(){
+        return this.WorldClass;
+    }
+    public Class<?> getWorldProviderClass(){
+        return this.WorldProviderClass;
+    }
+    private String getMethodName(final ReflectiveMethod method){
+        switch (method){
+            case NMSItemStack_save: {
+                if(Version.mcMainVersion<=17) return "save";
+                return "b";
+            }
+            case NMSItemStack_setTag: {
+                if(Version.mcMainVersion<=17) return "setTag";
+                return "c";
+            }
+            case MojangsonParser_parse: {
+                if(Version.mcMainVersion<=17) return "parse";
+                return "a";
+            }
+            case MojangsonParser_parseLiteral: {
+                if(Version.mcMainVersion==12) return "c";
+                else if("v1_13_R1".equals(Version.getVersion())) return "b";
+                else if(Version.mcMainVersion<=17) return "parseLiteral";
+                else return "b";
+            }
+            case NBTTagCompound_set: {
+                if(Version.mcMainVersion<=17) return "set";
+                return "a";
+            }
+            default: return "unreachable";
+        }
+    }
+    private void init_NBTTagCompoundClass(){
+        try{
+            Class<?> CraftMetaBlockStateClass = Class.forName("org.bukkit.craftbukkit."+Version.getVersion()+".inventory.CraftMetaBlockState");
+            Field field = CraftMetaBlockStateClass.getDeclaredField("blockEntityTag");
+            this.NBTTagCompoundClass = field.getType();
+            return;
+        }catch (ReflectiveOperationException ignored){}
+
+        Method[] methods = CraftEntityClass.getDeclaredMethods();
+        for (Method method : methods) {
+            if ("save".equals(method.getName())) this.NBTTagCompoundClass = method.getReturnType();
+        }
+    }
+    private void init_NBTTagCompound_map(){
+        Field[] fields = NBTTagCompoundClass.getDeclaredFields();
+        for(Field field : fields){
+            if(field.getType() == this.unhandledTags.getType()){
+                this.NBTTagCompound_map = field;
+                break;
+            }
+        }
+        this.NBTTagCompound_map.setAccessible(true);
+    }
+    private void init_NBTBaseClass(){
+        try{
+            //在mohist端使用getPackage()喜提null
+            this.NBTBaseClass = Class.forName(this.NBTTagCompoundClass.getName().replace(".NBTTagCompound",".NBTBase"));
+        }catch (ClassNotFoundException e){
+            e.printStackTrace();
+        }
+    }
+    private static enum ReflectiveMethod {
+        NMSItemStack_save,
+        NMSItemStack_setTag,
+        MojangsonParser_parse,
+        MojangsonParser_parseLiteral,
+        NBTTagCompound_set
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/Pair.java

@@ -0,0 +1,11 @@
+package pers.xanadu.enderdragon.util;
+
+public class Pair<P1,P2> {
+    public P1 first;
+    public P2 second;
+    public Pair(P1 first, P2 second) {
+        this.first = first;
+        this.second = second;
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/UpdateChecker.java

@@ -0,0 +1,48 @@
+package pers.xanadu.enderdragon.util;
+
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import pers.xanadu.enderdragon.EnderDragon;
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.script.Events;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+
+public class UpdateChecker {
+    public static void checkUpdate(){
+        Lang.info(Lang.plugin_checking_update);
+        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 = EnderDragon.plugin.getDescription().getVersion();
+                    if (!localVer.equals(newVer)) {
+                        Lang.warn(Lang.plugin_out_of_date.replace("{0}",localVer).replace("{1}",newVer));
+                        Events.registerPersistently(PlayerJoinEvent.class,e->{
+                            if(e.getPlayer().hasPermission("ed.update.notify")) {
+                                e.getPlayer().sendMessage("§3An update for §bEnderDragon §r(v" + newVer + ")§3 is available at", "§7§nhttps://www.spigotmc.org/resources/enderdragon.101583/");
+                            }
+                        });
+                    }
+                    else{
+                        Lang.info(Lang.plugin_up_to_date.replace("{1}",newVer));
+                    }
+                } catch (Exception e) {
+                    Lang.warn(Lang.plugin_check_update_fail);
+                }
+            }
+        }.runTaskAsynchronously(EnderDragon.plugin);
+    }
+
+}

src/main/java/pers/xanadu/enderdragon/util/Version.java

@@ -0,0 +1,87 @@
+package pers.xanadu.enderdragon.util;
+
+import pers.xanadu.enderdragon.config.Lang;
+import pers.xanadu.enderdragon.nms.BossBar.I_BossBarManager;
+import pers.xanadu.enderdragon.nms.NMSItem.I_NMSItemManager;
+import pers.xanadu.enderdragon.nms.RespawnAnchor.I_RespawnAnchorManager;
+import pers.xanadu.enderdragon.nms.WorldData.I_WorldDataManager;
+
+import static org.bukkit.Bukkit.getServer;
+
+public class Version {
+    public static final String setting_dragon = "2.2.0";
+    public static final String lang = "2.2.0";
+    public static final String config = "2.2.0";
+    public static final String data = "2.2.0";
+    public static int mcMainVersion;
+    public static int mcPatchVersion;
+    private static String version = "no version found";
+    private static boolean isMohist = false;
+    public static void init(){
+        try {
+            version = getServer().getClass().getPackage().getName().split("\\.")[3];
+            String[] mc_version = getServer().getBukkitVersion().split("-")[0].split("\\.");
+            mcMainVersion = Integer.parseInt(mc_version[1]);
+            if(mc_version.length<=2) mcPatchVersion = 0;
+            else mcPatchVersion = Integer.parseInt(mc_version[2]);
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
+            Lang.warn("Failed to get nms-version!");
+        }
+        Lang.info("Found version: " + version);
+        try{
+            Class.forName("net.minecraftforge.server.ServerMain");
+            isMohist = true;
+        }catch(ReflectiveOperationException ignored){}
+
+    }
+    public static I_NMSItemManager getNMSItemManager(){
+        switch (version){
+            case "v1_12_R1" : return new pers.xanadu.enderdragon.nms.NMSItem.v1_12_R1.NMSItemManager();
+            case "v1_13_R1" : return new pers.xanadu.enderdragon.nms.NMSItem.v1_13_R1.NMSItemManager();
+            default: return new pers.xanadu.enderdragon.nms.NMSItem.v1_13_R2_above.NMSItemManager();
+        }
+    }
+    public static I_BossBarManager getBossBarManager(){
+        switch(version){
+            case "v1_12_R1" : return new pers.xanadu.enderdragon.nms.BossBar.v1_12_R1.BossBarManager();
+            case "v1_13_R1" : return new pers.xanadu.enderdragon.nms.BossBar.v1_13_R1.BossBarManager();
+            case "v1_13_R2" : return new pers.xanadu.enderdragon.nms.BossBar.v1_13_R2.BossBarManager();
+            default: return null;
+        }
+    }
+    public static I_WorldDataManager getWorldDataManager(){
+        switch (version){
+            case "v1_12_R1" : return new pers.xanadu.enderdragon.nms.WorldData.v1_12_R1.WorldDataManager();
+            case "v1_13_R1" : return new pers.xanadu.enderdragon.nms.WorldData.v1_13_R1.WorldDataManager();
+            case "v1_13_R2" : return new pers.xanadu.enderdragon.nms.WorldData.v1_13_R2.WorldDataManager();
+            case "v1_14_R1" : return new pers.xanadu.enderdragon.nms.WorldData.v1_14_R1.WorldDataManager();
+            case "v1_15_R1" : return new pers.xanadu.enderdragon.nms.WorldData.v1_15_R1.WorldDataManager();
+            case "v1_16_R1" : return new pers.xanadu.enderdragon.nms.WorldData.v1_16_R1.WorldDataManager();
+            case "v1_16_R2" : return new pers.xanadu.enderdragon.nms.WorldData.v1_16_R2.WorldDataManager();
+            case "v1_16_R3" : return new pers.xanadu.enderdragon.nms.WorldData.v1_16_R3.WorldDataManager();
+            default : return new pers.xanadu.enderdragon.nms.WorldData.v1_17_above.WorldDataManager();
+        }
+    }
+    public static I_RespawnAnchorManager getRespawnAnchorManager(){
+        switch (version){
+            case "v1_12_R1" :
+            case "v1_13_R1" :
+            case "v1_14_R1" :
+            case "v1_13_R2" :
+            case "v1_15_R1" : return null;
+            case "v1_16_R1" : return new pers.xanadu.enderdragon.nms.RespawnAnchor.v1_16_R1.RespawnAnchorManager();
+            case "v1_16_R2" : return new pers.xanadu.enderdragon.nms.RespawnAnchor.v1_16_R2.RespawnAnchorManager();
+            case "v1_16_R3" : return new pers.xanadu.enderdragon.nms.RespawnAnchor.v1_16_R3.RespawnAnchorManager();
+            case "v1_17_R1" : return new pers.xanadu.enderdragon.nms.RespawnAnchor.v1_17_R1.RespawnAnchorManager();
+            default: return new pers.xanadu.enderdragon.nms.RespawnAnchor.v1_18_above.RespawnAnchorManager();
+        }
+    }
+    public static String getVersion() {
+        return version;
+    }
+    public static boolean isMohist(){
+        return isMohist;
+    }
+
+}