Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/net/Indyuce/mmocore/api/player/PlayerData.java
#	src/main/java/net/Indyuce/mmocore/comp/MMOCoreTargetRestriction.java

src/main/java/net/Indyuce/mmocore/MMOCore.java

@@ -177,8 +177,9 @@ public class MMOCore extends LuminePlugin {
 				for (PlayerData player : PlayerData.getAll())
 					if (player.isOnline() && !player.getPlayer().isDead())
 						for (PlayerResource resource : PlayerResource.values()) {
-							double d = player.getProfess().getHandler(resource).getRegen(player);
+							double regenAmount = player.getProfess().getHandler(resource).getRegen(player);
-							if (d != 0) resource.regen(player, d);
+							if (regenAmount != 0)
+								resource.regen(player, regenAmount);
 						}
 			}
 		}.runTaskTimer(MMOCore.plugin, 100, 20);

src/main/java/net/Indyuce/mmocore/api/block/VanillaBlockType.java

@@ -15,7 +15,7 @@ public class VanillaBlockType implements BlockType {
 
 	/*
 	 * allows to plant back crops with a custom age so that it does not always
-	 * have to full grow again
+	 * have to full grow again-
 	 */
 	private final int age;
 

src/main/java/net/Indyuce/mmocore/api/event/CustomBlockMineEvent.java

@@ -14,7 +14,7 @@ public class CustomBlockMineEvent extends PlayerDataEvent implements Cancellable
 
     private final Block block;
     private final BlockInfo info;
-    private final List<ItemStack> drops;
+    private List<ItemStack> drops;
 
     private boolean cancelled;
 
@@ -39,6 +39,10 @@ public class CustomBlockMineEvent extends PlayerDataEvent implements Cancellable
         return info;
     }
 
+    public void setDrops(List<ItemStack> list) {
+        this.drops = list;
+    }
+
     @Override
     public boolean isCancelled() {
         return cancelled;

src/main/java/net/Indyuce/mmocore/api/player/profess/PlayerClass.java

@@ -10,7 +10,7 @@ import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.player.profess.event.EventTrigger;
 import net.Indyuce.mmocore.api.player.profess.resource.ManaDisplayOptions;
 import net.Indyuce.mmocore.api.player.profess.resource.PlayerResource;
-import net.Indyuce.mmocore.api.player.profess.resource.ResourceHandler;
+import net.Indyuce.mmocore.api.player.profess.resource.ResourceRegeneration;
 import net.Indyuce.mmocore.api.player.stats.StatType;
 import net.Indyuce.mmocore.api.util.MMOCoreUtils;
 import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
@@ -47,7 +47,7 @@ public class PlayerClass extends PostLoadObject {
     private final Map<String, SkillInfo> skills = new LinkedHashMap<>();
     private final List<Subclass> subclasses = new ArrayList<>();
 
-    private final Map<PlayerResource, ResourceHandler> resourceHandlers = new HashMap<>();
+    private final Map<PlayerResource, ResourceRegeneration> resourceHandlers = new HashMap<>();
     private final Map<String, EventTrigger> eventTriggers = new HashMap<>();
 
     private final CastingParticle castParticle;
@@ -142,7 +142,7 @@ public class PlayerClass extends PostLoadObject {
                     String format = key.toLowerCase().replace("_", "-").replace(" ", "-");
                     eventTriggers.put(format, new EventTrigger(format, config.getStringList("triggers." + key)));
                 } catch (IllegalArgumentException exception) {
-                    MMOCore.log(Level.WARNING, "[PlayerClasses:" + id + "] " + exception.getMessage());
+                    MMOCore.log(Level.WARNING, "Could not load trigger '" + key + "' from class '" + id + "':" + exception.getMessage());
                 }
             }
 
@@ -153,15 +153,15 @@ public class PlayerClass extends PostLoadObject {
         for (PlayerResource resource : PlayerResource.values()) {
             if (config.isConfigurationSection("resource." + resource.name().toLowerCase()))
                 try {
-                    resourceHandlers.put(resource, new ResourceHandler(resource,
+                    resourceHandlers.put(resource, new ResourceRegeneration(resource,
                             config.getConfigurationSection("resource." + resource.name().toLowerCase())));
                 } catch (IllegalArgumentException exception) {
-                    MMOCore.log(Level.WARNING, "[PlayerClasses:" + id + "] Could not load special resource regen for "
+                    MMOCore.log(Level.WARNING, "Could not load special " + resource.name().toLowerCase() + " regen from class '"
-                            + resource.name() + ": " + exception.getMessage());
+                            + id + "': " + exception.getMessage());
-                    resourceHandlers.put(resource, new ResourceHandler(resource));
+                    resourceHandlers.put(resource, new ResourceRegeneration(resource));
                 }
             else
-                resourceHandlers.put(resource, new ResourceHandler(resource));
+                resourceHandlers.put(resource, new ResourceRegeneration(resource));
         }
     }
 
@@ -185,7 +185,7 @@ public class PlayerClass extends PostLoadObject {
         setOption(ClassOption.DEFAULT, false);
 
         for (PlayerResource resource : PlayerResource.values())
-            resourceHandlers.put(resource, new ResourceHandler(resource));
+            resourceHandlers.put(resource, new ResourceRegeneration(resource));
     }
 
     @Override
@@ -215,7 +215,7 @@ public class PlayerClass extends PostLoadObject {
         return manaDisplay;
     }
 
-    public ResourceHandler getHandler(PlayerResource resource) {
+    public ResourceRegeneration getHandler(PlayerResource resource) {
         return resourceHandlers.get(resource);
     }
 

src/main/java/net/Indyuce/mmocore/api/player/profess/resource/PlayerResource.java

@@ -12,115 +12,118 @@ import java.util.function.Function;
 
 public enum PlayerResource {
 
-	HEALTH(StatType.HEALTH_REGENERATION, ClassOption.OFF_COMBAT_HEALTH_REGEN,
+    HEALTH(data -> data.getPlayer().getHealth(),
-			(data) -> data.getPlayer().getHealth(),
+            data -> data.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(),
-			data -> data.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(),
+            (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
-			(data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
+            (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.heal(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.heal(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.getPlayer().setHealth(amount)),
-			(data, amount) -> data.getPlayer().setHealth(amount)),
 
-	MANA(StatType.MANA_REGENERATION, ClassOption.OFF_COMBAT_MANA_REGEN,
+    MANA(PlayerData::getMana,
-			PlayerData::getMana,
+            data -> data.getStats().getStat(StatType.MAX_MANA),
-			data -> data.getStats().getStat(StatType.MAX_MANA),
+            (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
-			(data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
+            (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.giveMana(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveMana(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.setMana(amount)),
-			(data, amount) -> data.setMana(amount)),
 
-	STAMINA(StatType.STAMINA_REGENERATION, ClassOption.OFF_COMBAT_STAMINA_REGEN,
+    STAMINA(PlayerData::getStamina,
-			PlayerData::getStamina,
+            data -> data.getStats().getStat(StatType.MAX_STAMINA),
-			data -> data.getStats().getStat(StatType.MAX_STAMINA),
+            (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
-			(data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
+            (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.giveStamina(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveStamina(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.setStamina(amount)),
-			(data, amount) -> data.setStamina(amount)),
 
-	STELLIUM(StatType.STELLIUM_REGENERATION, ClassOption.OFF_COMBAT_STELLIUM_REGEN,
+    STELLIUM(PlayerData::getStellium,
-			PlayerData::getStellium,
+            data -> data.getStats().getStat(StatType.MAX_STELLIUM),
-			data -> data.getStats().getStat(StatType.MAX_STELLIUM),
+            (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
-			(data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION),
+            (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.giveStellium(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
-			(data, amount) -> data.giveStellium(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND),
+            (data, amount) -> data.setStellium(amount));
-			(data, amount) -> data.setStellium(amount));
 
-	private final StatType regenStat;
+    private final StatType regenStat, maxRegenStat;
-	private final ClassOption offCombatRegen;
+    private final ClassOption offCombatRegen;
-	private final Function<PlayerData, Double> current, max;
+    private final Function<PlayerData, Double> current, max;
-	private final BiConsumer<PlayerData, Double> regen;
+    private final BiConsumer<PlayerData, Double> regen;
 
-	// Used for MMOCore commands
+    // Used for MMOCore commands
-	private final BiConsumer<PlayerData, Double> set, give, take;
+    private final BiConsumer<PlayerData, Double> set, give, take;
 
-	PlayerResource(StatType regenStat, ClassOption offCombatRegen,
+    PlayerResource(Function<PlayerData, Double> current,
-				   Function<PlayerData, Double> current,
+                   Function<PlayerData, Double> max,
-				   Function<PlayerData, Double> max,
+                   BiConsumer<PlayerData, Double> regen,
-				   BiConsumer<PlayerData, Double> regen,
+                   BiConsumer<PlayerData, Double> give,
-				   BiConsumer<PlayerData, Double> give,
+                   BiConsumer<PlayerData, Double> take,
-				   BiConsumer<PlayerData, Double> take,
+                   BiConsumer<PlayerData, Double> set) {
-				   BiConsumer<PlayerData, Double> set) {
+        this.regenStat = StatType.valueOf(name() + "_REGENERATION");
-		this.regenStat = regenStat;
+        this.maxRegenStat = StatType.valueOf("MAX_" + name() + "_REGENERATION");
-		this.offCombatRegen = offCombatRegen;
+        this.offCombatRegen = ClassOption.valueOf("OFF_COMBAT_" + name() + "_REGEN");
-		this.current = current;
+        this.current = current;
-		this.max = max;
+        this.max = max;
-		this.regen = regen;
+        this.regen = regen;
-		this.give = give;
+        this.give = give;
-		this.take = take;
+        this.take = take;
-		this.set = set;
+        this.set = set;
-	}
+    }
 
-	/**
+    /**
-	 * @return Stat which corresponds to resource regeneration
+     * @return Stat which corresponds to flat resource regeneration
-	 */
+     */
-	public StatType getRegenStat() {
+    public StatType getRegenStat() {
-		return regenStat;
+        return regenStat;
-	}
+    }
 
-	/**
+    /**
-	 * @return Class option which determines whether or not resource should be
+     * @return Stat which corresponds to resource regeneration scaling with the player's max health
-	 *         regenerated off combat only
+     */
-	 */
+    public StatType getMaxRegenStat() {
-	public ClassOption getOffCombatRegen() {
+        return maxRegenStat;
-		return offCombatRegen;
+    }
-	}
 
-	/**
+    /**
-	 * @return Current resource of the given player
+     * @return Class option which determines whether or not resource should be
-	 */
+     *         regenerated off combat only
-	public double getCurrent(PlayerData player) {
+     */
-		return current.apply(player);
+    public ClassOption getOffCombatRegen() {
-	}
+        return offCombatRegen;
+    }
 
-	/**
+    /**
-	 * @return Max amount of that resource of the given player
+     * @return Current resource of the given player
-	 */
+     */
-	public double getMax(PlayerData player) {
+    public double getCurrent(PlayerData player) {
-		return max.apply(player);
+        return current.apply(player);
-	}
+    }
 
-	/**
+    /**
-	 * Regens a player resource. Whatever resource, a bukkit event is triggered
+     * @return Max amount of that resource of the given player
-	 *
+     */
-	 * @param player Player to regen
+    public double getMax(PlayerData player) {
-	 * @param amount Amount to regen
+        return max.apply(player);
-	 */
+    }
-	public void regen(PlayerData player, double amount) {
-		regen.accept(player, amount);
-	}
 
-	/**
+    /**
-	 * Used by MMOCore admin commands here: {@link net.Indyuce.mmocore.command.rpg.admin.ResourceCommandTreeNode}
+     * Regens a player resource. Whatever resource, a bukkit event is triggered
-	 */
+     *
-	public BiConsumer<PlayerData, Double> getConsumer(ManaTrigger.Operation operation) {
+     * @param player Player to regen
-		switch (operation) {
+     * @param amount Amount to regen
-			case SET:
+     */
-				return set;
+    public void regen(PlayerData player, double amount) {
-			case TAKE:
+        regen.accept(player, amount);
-				return take;
+    }
-			case GIVE:
+
-				return give;
+    /**
-			default:
+     * Used by MMOCore admin commands here: {@link net.Indyuce.mmocore.command.rpg.admin.ResourceCommandTreeNode}
-				throw new IllegalArgumentException("Operation cannot be null");
+     */
-		}
+    public BiConsumer<PlayerData, Double> getConsumer(ManaTrigger.Operation operation) {
-	}
+        switch (operation) {
+            case SET:
+                return set;
+            case TAKE:
+                return take;
+            case GIVE:
+                return give;
+            default:
+                throw new IllegalArgumentException("Operation cannot be null");
+        }
+    }
 }

src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceHandler.java

@@ -1,100 +0,0 @@
-package net.Indyuce.mmocore.api.player.profess.resource;
-
-import java.util.function.BiFunction;
-
-import org.apache.commons.lang.Validate;
-import org.bukkit.configuration.ConfigurationSection;
-
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
-
-public class ResourceHandler {
-
-	/**
-	 * Resource should only regenerate when the player is out of combat
-	 */
-	private final boolean offCombatOnly;
-
-	/**
-	 * Percentage of scaling which the player regenerates every second
-	 */
-	private final LinearValue scalar;
-
-	/**
-	 * Whether the resource regeneration scales on missing or max resource. if
-	 * TYPE is null, then there is no special regeneration.
-	 */
-	private final HandlerType type;
-	private final PlayerResource resource;
-
-	/**
-	 * Used when there is no special resource regeneration
-	 */
-	public ResourceHandler(PlayerResource resource) {
-		this(resource, null, null, false);
-	}
-
-	public ResourceHandler(PlayerResource resource, ConfigurationSection config) {
-		this.resource = resource;
-		offCombatOnly = config.getBoolean("off-combat");
-
-		Validate.isTrue(config.contains("type"), "Could not find resource regen scaling type");
-		type = HandlerType.valueOf(config.getString("type").toUpperCase());
-
-		Validate.notNull(config.getConfigurationSection("value"), "Could not find resource regen value config section");
-		scalar = new LinearValue(config.getConfigurationSection("value"));
-	}
-
-	public ResourceHandler(PlayerResource resource, HandlerType type, LinearValue scalar, boolean offCombatOnly) {
-		this.resource = resource;
-		this.type = type;
-		this.scalar = scalar;
-		this.offCombatOnly = offCombatOnly;
-	}
-
-	/**
-	 * Apply regeneration formulas: first calculates base resource regen due to
-	 * the player stats and then apply the special resource regeneration due to
-	 * the player class
-	 * 
-	 * @param player
-	 *            Player regenerating
-	 * @return The amount of resource which should be regenerated EVERY SECOND
-	 */
-	public double getRegen(PlayerData player) {
-		double d = 0;
-
-		// base resource regeneration = value of the corresponding regen stat
-		if (!player.isInCombat() || !player.getProfess().hasOption(resource.getOffCombatRegen()))
-			d += player.getStats().getStat(resource.getRegenStat());
-
-		// extra resource regeneration based on CLASS, scales on LEVEL
-		if (type != null && (!player.isInCombat() || !offCombatOnly))
-			d = this.scalar.calculate(player.getLevel()) / 100 * type.getScaling(player, resource);
-
-		return d;
-	}
-
-	public enum HandlerType {
-
-		/**
-		 * Resource regeneration scales on max resource
-		 */
-		MAX((player, resource) -> resource.getMax(player)),
-
-		/**
-		 * Resource regeneration scales on missing resource
-		 */
-		MISSING((player, resource) -> resource.getMax(player) - resource.getCurrent(player));
-
-		private final BiFunction<PlayerData, PlayerResource, Double> calculation;
-
-		HandlerType(BiFunction<PlayerData, PlayerResource, Double> calculation) {
-			this.calculation = calculation;
-		}
-
-		public double getScaling(PlayerData player, PlayerResource resource) {
-			return calculation.apply(player, resource);
-		}
-	}
-}

src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceRegeneration.java

@@ -0,0 +1,103 @@
+package net.Indyuce.mmocore.api.player.profess.resource;
+
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
+import org.apache.commons.lang.Validate;
+import org.bukkit.configuration.ConfigurationSection;
+
+import java.util.function.BiFunction;
+
+public class ResourceRegeneration {
+
+    /**
+     * Resource should only regenerate when the player is out of combat
+     */
+    private final boolean offCombatOnly;
+
+    /**
+     * Percentage of scaling which the player regenerates every second
+     */
+    private final LinearValue scalar;
+
+    /**
+     * Whether the resource regeneration scales on missing or max resource. if
+     * TYPE is null, then there is no special regeneration.
+     */
+    private final HandlerType type;
+    private final PlayerResource resource;
+
+    /**
+     * Used when there is no special resource regeneration
+     */
+    public ResourceRegeneration(PlayerResource resource) {
+        this(resource, null, null, false);
+    }
+
+    public ResourceRegeneration(PlayerResource resource, ConfigurationSection config) {
+        this.resource = resource;
+        offCombatOnly = config.getBoolean("off-combat");
+
+        Validate.isTrue(config.contains("type"), "Could not find resource regen scaling type");
+        type = HandlerType.valueOf(config.getString("type").toUpperCase());
+
+        Validate.notNull(config.getConfigurationSection("value"), "Could not find resource regen value config section");
+        scalar = new LinearValue(config.getConfigurationSection("value"));
+    }
+
+    public ResourceRegeneration(PlayerResource resource, HandlerType type, LinearValue scalar, boolean offCombatOnly) {
+        this.resource = resource;
+        this.type = type;
+        this.scalar = scalar;
+        this.offCombatOnly = offCombatOnly;
+    }
+
+    /**
+     * Apply regeneration formulas: first calculates base resource regen due to
+     * the player stats and then apply the special resource regeneration due to
+     * the player class
+     *
+     * @param player Player regenerating
+     * @return The amount of resource which should be regenerated EVERY SECOND
+     */
+    public double getRegen(PlayerData player) {
+        double d = 0;
+
+        if (!player.isInCombat() || !player.getProfess().hasOption(resource.getOffCombatRegen())) {
+
+            // Flat resource regeneration
+            d += player.getStats().getStat(resource.getRegenStat());
+
+            // Component which scales with max resource
+            d += player.getStats().getStat(resource.getMaxRegenStat()) / 100 * resource.getMax(player);
+        }
+
+        // Special resource regeneration
+        if (type != null && (!player.isInCombat() || !offCombatOnly))
+            d += this.scalar.calculate(player.getLevel()) / 100 * type.getScaling(player, resource);
+
+        return d;
+    }
+
+    public enum HandlerType {
+
+        /**
+         * Resource regeneration scales on max resource
+         */
+        MAX((player, resource) -> resource.getMax(player)),
+
+        /**
+         * Resource regeneration scales on missing resource
+         */
+        MISSING((player, resource) -> resource.getMax(player) - resource.getCurrent(player));
+
+        private final BiFunction<PlayerData, PlayerResource, Double> calculation;
+
+        HandlerType(BiFunction<PlayerData, PlayerResource, Double> calculation) {
+            this.calculation = calculation;
+        }
+
+        public double getScaling(PlayerData player, PlayerResource resource) {
+            return calculation.apply(player, resource);
+        }
+    }
+}

src/main/java/net/Indyuce/mmocore/api/player/stats/PlayerStats.java

@@ -1,6 +1,6 @@
 package net.Indyuce.mmocore.api.player.stats;
 
-import io.lumine.mythic.lib.api.player.EquipmentSlot;
+import io.lumine.mythic.lib.player.EquipmentSlot;
 import io.lumine.mythic.lib.api.stat.StatInstance;
 import io.lumine.mythic.lib.api.stat.StatMap;
 import io.lumine.mythic.lib.api.stat.modifier.ModifierSource;

src/main/java/net/Indyuce/mmocore/api/player/stats/StatType.java

@@ -1,130 +1,160 @@
 package net.Indyuce.mmocore.api.player.stats;
 
+import io.lumine.mythic.lib.MythicLib;
 import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.ConfigFile;
-import net.Indyuce.mmocore.experience.Profession;
 import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
-import io.lumine.mythic.lib.MythicLib;
+import net.Indyuce.mmocore.experience.Profession;
 import org.bukkit.configuration.file.FileConfiguration;
 
 import java.text.DecimalFormat;
 
 public enum StatType {
 
-	ATTACK_DAMAGE,
+    // Vanilla stats
-	ATTACK_SPEED,
+    ATTACK_DAMAGE,
-	MAX_HEALTH,
+    ATTACK_SPEED,
-	HEALTH_REGENERATION,
+    MAX_HEALTH,
+    HEALTH_REGENERATION,
+    MAX_HEALTH_REGENERATION,
 
-	MOVEMENT_SPEED,
+    // Misc
-	SPEED_MALUS_REDUCTION,
+    MOVEMENT_SPEED,
-	KNOCKBACK_RESISTANCE,
+    SPEED_MALUS_REDUCTION,
+    KNOCKBACK_RESISTANCE,
 
-	MAX_MANA,
+    // Mana
-	MAX_STAMINA,
+    MAX_MANA,
-	MAX_STELLIUM,
+    MANA_REGENERATION,
-	MANA_REGENERATION,
+    MAX_MANA_REGENERATION,
-	STAMINA_REGENERATION,
-	STELLIUM_REGENERATION,
 
-	ARMOR,
+    // Stamina
-	ARMOR_TOUGHNESS,
+    MAX_STAMINA,
+    STAMINA_REGENERATION,
+    MAX_STAMINA_REGENERATION,
 
-	CRITICAL_STRIKE_CHANCE,
+    // Stellium
-	CRITICAL_STRIKE_POWER,
+    MAX_STELLIUM,
-	SKILL_CRITICAL_STRIKE_CHANCE,
+    STELLIUM_REGENERATION,
-	SKILL_CRITICAL_STRIKE_POWER,
+    MAX_STELLIUM_REGENERATION,
 
-	BLOCK_POWER,
+    // Vanilla armor stats
-	BLOCK_RATING,
+    ARMOR,
-	BLOCK_COOLDOWN_REDUCTION,
+    ARMOR_TOUGHNESS,
-	DODGE_RATING,
-	DODGE_COOLDOWN_REDUCTION,
-	PARRY_RATING,
-	PARRY_COOLDOWN_REDUCTION,
 
-	ADDITIONAL_EXPERIENCE,
+    // Critical strikes
-	COOLDOWN_REDUCTION,
+    CRITICAL_STRIKE_CHANCE,
+    CRITICAL_STRIKE_POWER,
+    SKILL_CRITICAL_STRIKE_CHANCE,
+    SKILL_CRITICAL_STRIKE_POWER,
 
-	MAGIC_DAMAGE,
+    // Mitigation
-	PHYSICAL_DAMAGE,
+    DEFENSE,
-	PROJECTILE_DAMAGE,
+    BLOCK_POWER,
-	WEAPON_DAMAGE,
+    BLOCK_RATING,
-	SKILL_DAMAGE,
+    BLOCK_COOLDOWN_REDUCTION,
-	UNDEAD_DAMAGE,
+    DODGE_RATING,
+    DODGE_COOLDOWN_REDUCTION,
+    PARRY_RATING,
+    PARRY_COOLDOWN_REDUCTION,
 
-	PVP_DAMAGE,
+    // Utility
-	PVE_DAMAGE,
+    ADDITIONAL_EXPERIENCE,
+    COOLDOWN_REDUCTION,
 
-	DEFENSE,
+    // Damage-type based stats
-	DAMAGE_REDUCTION,
+    MAGIC_DAMAGE,
-	MAGIC_DAMAGE_REDUCTION,
+    PHYSICAL_DAMAGE,
-	PHYSICAL_DAMAGE_REDUCTION,
+    PROJECTILE_DAMAGE,
-	PROJECTILE_DAMAGE_REDUCTION,
+    WEAPON_DAMAGE,
-	WEAPON_DAMAGE_REDUCTION,
+    SKILL_DAMAGE,
-	SKILL_DAMAGE_REDUCTION,
+    UNDEAD_DAMAGE,
 
-	// reduces amount of tugs needed to fish
+    // Misc damage stats
-	FISHING_STRENGTH("fishing"),
+    PVP_DAMAGE,
+    PVE_DAMAGE,
 
-	// chance of instant success when fishing
+    // Damage reduction stats
-	CRITICAL_FISHING_CHANCE("fishing"),
+    DAMAGE_REDUCTION,
+    MAGIC_DAMAGE_REDUCTION,
+    PHYSICAL_DAMAGE_REDUCTION,
+    PROJECTILE_DAMAGE_REDUCTION,
+    WEAPON_DAMAGE_REDUCTION,
+    SKILL_DAMAGE_REDUCTION,
 
-	// chance of crit fishing failure
+    /**
-	CRITICAL_FISHING_FAILURE_CHANCE("fishing"),
+     * Reduces amount of tugs needed to fish
+     */
+    FISHING_STRENGTH("fishing"),
 
-	// chance of dropping more minerals when mining.
+    /**
-	FORTUNE,
+     * Chance of instant success when fishing
+     */
+    CRITICAL_FISHING_CHANCE("fishing"),
 
-	// get haste when mining blocks.
+    /**
-	GATHERING_HASTE,
+     * Chance of crit fishing failure
+     */
+    CRITICAL_FISHING_FAILURE_CHANCE("fishing"),
 
-	// chance of getting more crops when farming
+    /**
-	LUCK_OF_THE_FIELD;
+     * Chance of dropping more minerals when mining.
+     */
+    FORTUNE,
 
-	private String profession;
+    /**
+     * Get haste when mining blocks.
+     */
+    GATHERING_HASTE,
 
-	private LinearValue defaultInfo;
+    /**
-	private DecimalFormat format;
+     * Chance of getting more crops when farming
+     */
+    LUCK_OF_THE_FIELD;
 
-	StatType() {
+    private String profession;
-		// completely custom stat.
-	}
 
-	@SuppressWarnings("SameParameterValue")
+    private LinearValue defaultInfo;
-	StatType(String profession) {
+    private DecimalFormat format;
-		this.profession = profession;
-	}
 
-	public String getProfession() {
+    StatType() {
-		return profession;
+        // Completely custom stat
-	}
+    }
 
-	public Profession findProfession() {
+    @SuppressWarnings("SameParameterValue")
-		return MMOCore.plugin.professionManager.get(profession);
+    StatType(String profession) {
-	}
+        this.profession = profession;
+    }
 
-	public boolean hasProfession() {
+    public String getProfession() {
-		return profession != null;
+        return profession;
-	}
+    }
 
-	public LinearValue getDefault() {
+    public Profession findProfession() {
-		return defaultInfo;
+        return MMOCore.plugin.professionManager.get(profession);
-	}
+    }
 
-	public boolean matches(Profession profession) {
+    public boolean hasProfession() {
-		return this.profession != null && this.profession.equals(profession.getId());
+        return profession != null;
-	}
+    }
 
-	public String format(double value) {
+    public LinearValue getDefault() {
-		return format.format(value);
+        return defaultInfo;
-	}
+    }
 
-	public static void load() {
+    public boolean matches(Profession profession) {
-		FileConfiguration config = new ConfigFile("stats").getConfig();
+        return this.profession != null && this.profession.equals(profession.getId());
-		for (StatType stat : values()) {
+    }
-			stat.defaultInfo = config.contains("default." + stat.name()) ? new LinearValue(config.getConfigurationSection("default." + stat.name())) : new LinearValue(0, 0);
+
-			stat.format = MythicLib.plugin.getMMOConfig().newFormat(config.contains("decimal-format." + stat.name()) ? config.getString("decimal-format." + stat.name()) : "0.#");
+    public String format(double value) {
-		}
+        return format.format(value);
-	}
+    }
+
+    public static void load() {
+        FileConfiguration config = new ConfigFile("stats").getConfig();
+        for (StatType stat : values()) {
+            stat.defaultInfo = config.contains("default." + stat.name()) ? new LinearValue(config.getConfigurationSection("default." + stat.name())) : new LinearValue(0, 0);
+            stat.format = MythicLib.plugin.getMMOConfig().newFormat(config.contains("decimal-format." + stat.name()) ? config.getString("decimal-format." + stat.name()) : "0.#");
+        }
+    }
 }

src/main/java/net/Indyuce/mmocore/api/util/MMOCoreUtils.java

@@ -190,7 +190,7 @@ public class MMOCoreUtils {
      * @return If the player can target the entity given the attack type (buff or attack)
      */
     public static boolean canTarget(PlayerData player, Entity target, InteractionType interaction) {
-        return target instanceof LivingEntity && MythicLib.plugin.getEntities().canTarget(player.getPlayer(), (LivingEntity) target, interaction);
+        return target instanceof LivingEntity && MythicLib.plugin.getEntities().canTarget(player.getPlayer(), target, interaction);
     }
 
     public static void heal(LivingEntity target, double value) {

src/main/java/net/Indyuce/mmocore/comp/MMOCoreTargetRestriction.java

@@ -11,7 +11,7 @@ public class MMOCoreTargetRestriction implements TargetRestriction {
     @Override
     public boolean canTarget(Player player, LivingEntity target, InteractionType interaction) {
 
-        if (interaction.isOffense() && target instanceof Player && PlayerData.has((Player) target)) {
+        if (interaction.isOffense() && target instanceof Player && PlayerData.has(target.getUniqueId())) {
             PlayerData targetData = PlayerData.get(target.getUniqueId());
 
             // Check for the same party

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/MythicSkill.java

@@ -1,6 +1,11 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill;
+package net.Indyuce.mmocore.comp.mythicmobs;
 
 import io.lumine.mythic.lib.api.util.EnumUtils;
+import io.lumine.mythic.lib.player.cooldown.CooldownInfo;
+import io.lumine.mythic.lib.skill.metadata.TriggerMetadata;
+import io.lumine.mythic.lib.skill.trigger.PassiveSkill;
+import io.lumine.mythic.lib.skill.trigger.TriggerType;
+import io.lumine.mythic.lib.skill.trigger.TriggeredSkill;
 import io.lumine.xikage.mythicmobs.MythicMobs;
 import io.lumine.xikage.mythicmobs.adapters.AbstractEntity;
 import io.lumine.xikage.mythicmobs.adapters.AbstractLocation;
@@ -9,6 +14,11 @@ import io.lumine.xikage.mythicmobs.mobs.GenericCaster;
 import io.lumine.xikage.mythicmobs.skills.SkillCaster;
 import io.lumine.xikage.mythicmobs.skills.SkillTrigger;
 import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.event.PlayerPostCastSkillEvent;
+import net.Indyuce.mmocore.api.event.PlayerPreCastSkillEvent;
+import net.Indyuce.mmocore.api.event.PlayerResourceUpdateEvent;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.api.player.stats.StatType;
 import net.Indyuce.mmocore.api.util.MMOCoreUtils;
 import net.Indyuce.mmocore.api.util.math.formula.IntegerLinearValue;
 import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
@@ -27,9 +37,10 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.logging.Level;
 
-public class MythicSkill extends Skill {
+public class MythicSkill extends Skill implements TriggeredSkill {
     private final io.lumine.xikage.mythicmobs.skills.Skill skill;
     private final Map<CheatType, Integer> antiCheat = new HashMap<>();
+    private final PassiveSkill mythicLibSkill;
 
     public MythicSkill(String id, FileConfiguration config) {
         super(id);
@@ -64,11 +75,12 @@ public class MythicSkill extends Skill {
             }
 
         if (config.isString("passive-type")) {
-            Optional<PassiveSkillType> passiveType = EnumUtils.getIfPresent(PassiveSkillType.class, config.getString("passive-type").toUpperCase());
+            Optional<TriggerType> passiveType = EnumUtils.getIfPresent(TriggerType.class, config.getString("passive-type").toUpperCase());
             Validate.isTrue(passiveType.isPresent(), "Invalid passive skill type");
             setPassive();
-            Bukkit.getPluginManager().registerEvents(passiveType.get().getHandler(this), MMOCore.plugin);
+            mythicLibSkill = new PassiveSkill("MMOCorePassiveSkill", passiveType.get(), this);
-        }
+        } else
+            mythicLibSkill = null;
     }
 
     public Map<CheatType, Integer> getAntiCheat() {
@@ -79,10 +91,14 @@ public class MythicSkill extends Skill {
         return skill;
     }
 
+    public PassiveSkill toMythicLib() {
+        return mythicLibSkill;
+    }
+
     @Override
     public SkillMetadata whenCast(CasterMetadata caster, SkillInfo skill) {
         SkillMetadata cast = new SkillMetadata(caster, skill);
-        if (!cast.isSuccessful() || isPassive())
+        if (isPassive() || !cast.isSuccessful())
             return cast;
 
         // Gather MythicMobs skill info
@@ -101,7 +117,7 @@ public class MythicSkill extends Skill {
         skillMeta.getVariables().putObject("MMOSkill", cast);
         skillMeta.getVariables().putObject("MMOStatMap", caster.getStats());
 
-        //  Yo is that me or the second argument is f***ing useless
+        // Yo is that me or the second argument is f***ing useless
         if (this.skill.usable(skillMeta, SkillTrigger.CAST))
             this.skill.execute(skillMeta);
         else
@@ -117,4 +133,68 @@ public class MythicSkill extends Skill {
     private LinearValue readLinearValue(ConfigurationSection section) {
         return section.getBoolean("int") ? new IntegerLinearValue(section) : new LinearValue(section);
     }
+
+    @Override
+    public void execute(TriggerMetadata triggerMeta) {
+        PlayerData playerData = PlayerData.get(triggerMeta.getAttack().getPlayer().getUniqueId());
+        if (!playerData.getProfess().hasSkill(this))
+            return;
+
+        // Check for Bukkit pre cast event
+        Skill.SkillInfo skill = playerData.getProfess().getSkill(this);
+        PlayerPreCastSkillEvent preEvent = new PlayerPreCastSkillEvent(playerData, skill);
+        Bukkit.getPluginManager().callEvent(preEvent);
+        if (preEvent.isCancelled())
+            return;
+
+        // Gather MMOCore skill info
+        CasterMetadata caster = new CasterMetadata(playerData);
+        SkillMetadata cast = new SkillMetadata(caster, skill);
+        if (!cast.isSuccessful())
+            return;
+
+        // Gather MythicMobs skill info
+        HashSet<AbstractEntity> targetEntities = new HashSet<>();
+        HashSet<AbstractLocation> targetLocations = new HashSet<>();
+
+        // The only difference
+        if (triggerMeta.getTarget() != null)
+            targetEntities.add(BukkitAdapter.adapt(triggerMeta.getTarget()));
+
+        AbstractEntity trigger = BukkitAdapter.adapt(caster.getPlayer());
+        SkillCaster skillCaster = new GenericCaster(trigger);
+        io.lumine.xikage.mythicmobs.skills.SkillMetadata skillMeta = new io.lumine.xikage.mythicmobs.skills.SkillMetadata(SkillTrigger.API, skillCaster, trigger, BukkitAdapter.adapt(caster.getPlayer().getEyeLocation()), targetEntities, targetLocations, 1);
+
+        // Check if the MythicMobs skill can be cast
+        if (!this.skill.usable(skillMeta, SkillTrigger.CAST)) {
+            cast.abort();
+            return;
+        }
+
+        // Disable anticheat
+        if (MMOCore.plugin.hasAntiCheat())
+            MMOCore.plugin.antiCheatSupport.disableAntiCheat(caster.getPlayer(), antiCheat);
+
+        // Place cast skill info in a variable
+        skillMeta.getVariables().putObject("MMOSkill", cast);
+        skillMeta.getVariables().putObject("MMOStatMap", caster.getStats());
+
+        // Apply cooldown, mana and stamina costs
+        if (!playerData.noCooldown) {
+
+            // Cooldown
+            double flatCooldownReduction = Math.max(0, Math.min(1, playerData.getStats().getStat(StatType.COOLDOWN_REDUCTION) / 100));
+            CooldownInfo cooldownHandler = playerData.getCooldownMap().applyCooldown(cast.getSkill(), cast.getCooldown());
+            cooldownHandler.reduceInitialCooldown(flatCooldownReduction);
+
+            // Mana and stamina cost
+            playerData.giveMana(-cast.getManaCost(), PlayerResourceUpdateEvent.UpdateReason.SKILL_COST);
+            playerData.giveStamina(-cast.getStaminaCost(), PlayerResourceUpdateEvent.UpdateReason.SKILL_COST);
+        }
+
+        // Execute the MythicMobs skill
+        this.skill.execute(skillMeta);
+
+        Bukkit.getPluginManager().callEvent(new PlayerPostCastSkillEvent(playerData, skill, cast));
+    }
 }

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/PassiveMythicSkillHandler.java

@@ -1,65 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill;
-
-import io.lumine.xikage.mythicmobs.adapters.AbstractEntity;
-import io.lumine.xikage.mythicmobs.adapters.AbstractLocation;
-import io.lumine.xikage.mythicmobs.adapters.bukkit.BukkitAdapter;
-import io.lumine.xikage.mythicmobs.mobs.GenericCaster;
-import io.lumine.xikage.mythicmobs.skills.SkillCaster;
-import io.lumine.xikage.mythicmobs.skills.SkillTrigger;
-import net.Indyuce.mmocore.MMOCore;
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.skill.CasterMetadata;
-import net.Indyuce.mmocore.skill.Skill;
-import net.Indyuce.mmocore.skill.metadata.SkillMetadata;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Listener;
-
-import java.util.HashSet;
-
-public abstract class PassiveMythicSkillHandler implements Listener {
-    protected final MythicSkill skill;
-
-    /**
-     * Core class for all passive types
-     */
-    protected PassiveMythicSkillHandler(MythicSkill skill) {
-        this.skill = skill;
-    }
-
-    public SkillMetadata castSkill(PlayerData data) {
-        return castSkill(data, null);
-    }
-
-    public SkillMetadata castSkill(PlayerData playerData, Entity target) {
-        if (!playerData.getProfess().hasSkill(skill))
-            return null;
-
-        Skill.SkillInfo skill = playerData.getProfess().getSkill(this.skill);
-        CasterMetadata caster = new CasterMetadata(playerData);
-        SkillMetadata cast = new SkillMetadata(caster, skill);
-        if (!cast.isSuccessful() || this.skill.isPassive())
-            return cast;
-
-        HashSet<AbstractEntity> targetEntities = new HashSet<>();
-        HashSet<AbstractLocation> targetLocations = new HashSet<>();
-
-        // The only difference
-        if (target != null)
-            targetEntities.add(BukkitAdapter.adapt(target));
-
-        AbstractEntity trigger = BukkitAdapter.adapt(caster.getPlayer());
-        SkillCaster skillCaster = new GenericCaster(trigger);
-        io.lumine.xikage.mythicmobs.skills.SkillMetadata skillMeta = new io.lumine.xikage.mythicmobs.skills.SkillMetadata(SkillTrigger.API, skillCaster, trigger, BukkitAdapter.adapt(caster.getPlayer().getEyeLocation()), targetEntities, targetLocations, 1);
-
-        // Disable anticheat
-        if (MMOCore.plugin.hasAntiCheat())
-            MMOCore.plugin.antiCheatSupport.disableAntiCheat(caster.getPlayer(), this.skill.getAntiCheat());
-
-        if (this.skill.getSkill().usable(skillMeta, SkillTrigger.API))
-            this.skill.getSkill().execute(skillMeta);
-        else
-            cast.abort();
-
-        return cast;
-    }
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/PassiveSkillType.java

@@ -1,31 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill;
-
-import net.Indyuce.mmocore.comp.mythicmobs.skill.handlers.*;
-
-public enum PassiveSkillType {
-	PLAYER_ATTACK,
-	PLAYER_DAMAGE,
-	PLAYER_DAMAGE_BY_ENTITY,
-	PLAYER_DEATH,
-	PLAYER_KILL_ENTITY,
-	PLAYER_LOGIN,
-	SHOOT_BOW;
-
-	public PassiveMythicSkillHandler getHandler(MythicSkill skill) {
-		if (this == PLAYER_ATTACK)
-			return new PlayerAttackSkillHandler(skill);
-		if (this == PLAYER_DAMAGE)
-			return new PlayerDamageSkillHandler(skill);
-		if (this == PLAYER_KILL_ENTITY)
-			return new EntityDeathSkillHandler(skill);
-		if (this == PLAYER_DAMAGE_BY_ENTITY)
-			return new PlayerDamageByEntitySkillHandler(skill);
-		if (this == PLAYER_DEATH)
-			return new PlayerDeathSkillHandler(skill);
-		if (this == SHOOT_BOW)
-			return new ShootBowSkillHandler(skill);
-		if (this == PLAYER_LOGIN)
-			return new PlayerLoginSkillHandler(skill);
-		throw new NullPointerException();
-	}
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/EntityDeathSkillHandler.java

@@ -1,26 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import io.lumine.mythic.lib.api.event.EntityKillEntityEvent;
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-
-
-public class EntityDeathSkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player kills
-	 * another entity
-	 */
-	public EntityDeathSkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void event(EntityKillEntityEvent e) {
-		if (e.getEntity().getType() == EntityType.PLAYER)
-			castSkill(PlayerData.get((Player) e.getEntity()), e.getTarget());
-	}	
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/PlayerAttackSkillHandler.java

@@ -1,23 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import net.Indyuce.mmocore.api.player.PlayerData;
-import org.bukkit.event.EventHandler;
-
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-import io.lumine.mythic.lib.api.event.PlayerAttackEvent;
-
-public class PlayerAttackSkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player attacks another
-	 * entity
-	 */
-	public PlayerAttackSkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void event(PlayerAttackEvent e) {
-		castSkill(PlayerData.get(e.getData().getUniqueId()), e.getEntity());
-	}
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/PlayerDamageByEntitySkillHandler.java

@@ -1,27 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import io.lumine.mythic.lib.comp.target.InteractionType;
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.api.util.MMOCoreUtils;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-
-public class PlayerDamageByEntitySkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player takes damage
-	 * from another entity
-	 */
-	public PlayerDamageByEntitySkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void a(EntityDamageByEntityEvent event) {
-		if (event.getEntity().getType() == EntityType.PLAYER && MMOCoreUtils.canTarget(PlayerData.get(event.getEntity().getUniqueId()), event.getDamager(), InteractionType.OFFENSE_SKILL))
-			castSkill(PlayerData.get((Player) event.getEntity()), event.getDamager());
-	}	
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/PlayerDamageSkillHandler.java

@@ -1,25 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.EntityDamageEvent;
-
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-
-public class PlayerDamageSkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player takes damage
-	 */
-	public PlayerDamageSkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void event(EntityDamageEvent event) {
-		if (event.getEntityType() == EntityType.PLAYER && !event.getEntity().hasMetadata("NPC"))
-			castSkill(PlayerData.get((Player) event.getEntity()));
-	}	
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/PlayerDeathSkillHandler.java

@@ -1,25 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.EntityDeathEvent;
-
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-
-public class PlayerDeathSkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player dies
-	 */
-	public PlayerDeathSkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void event(EntityDeathEvent e) {
-		if (e.getEntityType() == EntityType.PLAYER)
-			castSkill(PlayerData.get((Player) e.getEntity()));
-	}	
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/PlayerLoginSkillHandler.java

@@ -1,28 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.player.PlayerLoginEvent;
-
-import io.lumine.mythic.utils.Schedulers;
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-
-public class PlayerLoginSkillHandler extends PassiveMythicSkillHandler {
-    /**
-     * Used when a player logins
-     *
-     * @param skill
-     */
-    public PlayerLoginSkillHandler(MythicSkill skill) {
-        super(skill);
-    }
-
-    @EventHandler
-    private void event(PlayerLoginEvent e){
-        Schedulers.sync().runLater(() -> {
-            castSkill(PlayerData.get( e.getPlayer()));
-        }, 50);
-
-    }
-}

src/main/java/net/Indyuce/mmocore/comp/mythicmobs/skill/handlers/ShootBowSkillHandler.java

@@ -1,25 +0,0 @@
-package net.Indyuce.mmocore.comp.mythicmobs.skill.handlers;
-
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.EntityShootBowEvent;
-
-import net.Indyuce.mmocore.api.player.PlayerData;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.PassiveMythicSkillHandler;
-
-public class ShootBowSkillHandler extends PassiveMythicSkillHandler {
-	/**
-	 * Used to handle passive skills which trigger when a player shoots a bow
-	 */
-	public ShootBowSkillHandler(MythicSkill skill) {
-		super(skill);
-	}
-
-	@EventHandler
-	private void event(EntityShootBowEvent e) {
-		if(e.getEntity().getType() == EntityType.PLAYER)
-			castSkill(PlayerData.get((Player) e.getEntity()), e.getProjectile());
-	}
-}

src/main/java/net/Indyuce/mmocore/experience/source/KillMobExperienceSource.java

@@ -1,16 +1,15 @@
 package net.Indyuce.mmocore.experience.source;
 
 import io.lumine.mythic.lib.api.MMOLineConfig;
-import io.lumine.mythic.lib.api.event.EntityKillEntityEvent;
+import io.lumine.mythic.lib.api.event.PlayerKillEntityEvent;
 import net.Indyuce.mmocore.MMOCore;
+import net.Indyuce.mmocore.api.player.PlayerData;
 import net.Indyuce.mmocore.experience.provider.ExperienceDispenser;
 import net.Indyuce.mmocore.experience.source.type.SpecificExperienceSource;
-import net.Indyuce.mmocore.api.player.PlayerData;
 import net.Indyuce.mmocore.manager.profession.ExperienceSourceManager;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 
@@ -28,11 +27,10 @@ public class KillMobExperienceSource extends SpecificExperienceSource<Entity> {
     public ExperienceSourceManager<KillMobExperienceSource> newManager() {
         return new ExperienceSourceManager<KillMobExperienceSource>() {
             @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-            public void a(EntityKillEntityEvent event) {
+            public void a(PlayerKillEntityEvent event) {
                 Bukkit.getScheduler().runTaskLater(MMOCore.plugin, () -> {
-                    if (event.getTarget().isDead() && event.getEntity() instanceof Player && !event.getEntity().hasMetadata("NPC")
+                    if (event.getTarget().isDead() && !event.getTarget().hasMetadata("spawner_spawned")) {
-                            && !event.getTarget().hasMetadata("spawner_spawned")) {
+                        PlayerData data = PlayerData.get(event.getPlayer());
-                        PlayerData data = PlayerData.get((Player) event.getEntity());
 
                         for (KillMobExperienceSource source : getSources())
                             if (source.matches(data, event.getTarget()))

src/main/java/net/Indyuce/mmocore/experience/source/MineBlockExperienceSource.java

@@ -33,7 +33,7 @@ public class MineBlockExperienceSource extends SpecificExperienceSource<Material
     @Override
     public ExperienceSourceManager<MineBlockExperienceSource> newManager() {
         return new ExperienceSourceManager<MineBlockExperienceSource>() {
-            @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+            @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
             public void a(BlockBreakEvent event) {
                 if (event.getPlayer().getGameMode() != GameMode.SURVIVAL)
                     return;

src/main/java/net/Indyuce/mmocore/listener/BlockListener.java

@@ -102,6 +102,8 @@ public class BlockListener implements Listener {
             return;
         }
 
+        drops = called.getDrops();
+
         /*
          * Remove vanilla drops if needed and
          * decreases the durability of the item

src/main/java/net/Indyuce/mmocore/listener/option/PlayerProfileCheck.java

@@ -1,15 +1,20 @@
 package net.Indyuce.mmocore.listener.option;
 
+import io.lumine.mythic.lib.MythicLib;
+import io.lumine.mythic.lib.comp.target.InteractionType;
+import net.Indyuce.mmocore.api.player.PlayerData;
+import net.Indyuce.mmocore.manager.InventoryManager;
+import org.bukkit.entity.EntityType;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.Inventory;
 
 public class PlayerProfileCheck implements Listener {
 
     @EventHandler
     public void a(PlayerInteractEntityEvent event) {
-        /**
+        if (event.getRightClicked().getType() != EntityType.PLAYER || !event.getPlayer().isSneaking() || !MythicLib.plugin.getEntities().canTarget(event.getPlayer(), event.getRightClicked(), InteractionType.SUPPORT_ACTION))
-        if (event.getRightClicked().getType() != EntityType.PLAYER || !MythicLib.plugin.getEntities().canTarget(event.getPlayer(), event.getRightClicked(), InteractionType.SUPPORT_ACTION))
             return;
 
         /*
@@ -19,10 +24,7 @@ public class PlayerProfileCheck implements Listener {
          * Opening inventories like that to other players does NOT
          * necessarily works for any other custom inventory.
          * */
-        /**
         Inventory inv = InventoryManager.PLAYER_STATS.newInventory(PlayerData.get(event.getRightClicked().getUniqueId())).getInventory();
         event.getPlayer().openInventory(inv);
-        **/
     }
-
 }

src/main/java/net/Indyuce/mmocore/manager/SkillManager.java

@@ -19,7 +19,7 @@ import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.ConfigFile;
 import net.Indyuce.mmocore.skill.Skill;
 import net.Indyuce.mmocore.api.util.math.formula.LinearValue;
-import net.Indyuce.mmocore.comp.mythicmobs.skill.MythicSkill;
+import net.Indyuce.mmocore.comp.mythicmobs.MythicSkill;
 
 public class SkillManager {
 	private final Map<String, Skill> skills = new LinkedHashMap<>();

src/main/java/net/Indyuce/mmocore/manager/data/PlayerDataManager.java

@@ -1,12 +1,11 @@
 package net.Indyuce.mmocore.manager.data;
 
-import io.lumine.mythic.lib.api.player.MMOPlayerData;
+import io.lumine.mythic.lib.player.MMOPlayerData;
 import net.Indyuce.mmocore.MMOCore;
 import net.Indyuce.mmocore.api.event.AsyncPlayerDataLoadEvent;
 import net.Indyuce.mmocore.api.event.PlayerDataLoadEvent;
 import net.Indyuce.mmocore.api.player.OfflinePlayerData;
 import net.Indyuce.mmocore.api.player.PlayerData;
-import org.apache.commons.lang.Validate;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.configuration.ConfigurationSection;

src/main/java/net/Indyuce/mmocore/skill/CasterMetadata.java

@@ -1,7 +1,7 @@
 package net.Indyuce.mmocore.skill;
 
 import io.lumine.mythic.lib.MythicLib;
-import io.lumine.mythic.lib.api.player.EquipmentSlot;
+import io.lumine.mythic.lib.player.EquipmentSlot;
 import io.lumine.mythic.lib.api.stat.StatMap;
 import io.lumine.mythic.lib.damage.AttackMetadata;
 import io.lumine.mythic.lib.damage.DamageMetadata;

src/main/java/net/Indyuce/mmocore/skill/Skill.java

@@ -1,6 +1,6 @@
 package net.Indyuce.mmocore.skill;
 
-import io.lumine.mythic.lib.player.CooldownObject;
+import io.lumine.mythic.lib.player.cooldown.CooldownObject;
 import net.Indyuce.mmocore.api.player.PlayerData;
 import net.Indyuce.mmocore.api.util.MMOCoreUtils;
 import net.Indyuce.mmocore.api.util.math.formula.IntegerLinearValue;

src/main/java/net/Indyuce/mmocore/skill/list/Fire_Rage.java

@@ -1,7 +1,7 @@
 package net.Indyuce.mmocore.skill.list;
 
 import io.lumine.mythic.lib.MythicLib;
-import io.lumine.mythic.lib.api.player.EquipmentSlot;
+import io.lumine.mythic.lib.player.EquipmentSlot;
 import io.lumine.mythic.lib.api.stat.StatMap;
 import io.lumine.mythic.lib.damage.DamageType;
 import io.lumine.mythic.lib.version.VersionMaterial;

src/main/java/net/Indyuce/mmocore/skill/metadata/SkillMetadata.java

@@ -118,7 +118,9 @@ public class SkillMetadata implements MythicSkillInfo {
         LOCKED,
 
         /**
-         * Anything else
+         * Anything else, used for instance when MythicMobs
+         * skill conditions prevent the skill from casting or
+         * when the Bukkit pre cast event is cancelled
          */
         OTHER;
     }

src/main/resources/config.yml

@@ -8,7 +8,7 @@
 # a Spigot Plugin by Team Requiem
 
 # DO NOT TOUCH
-config-version: 7
+config-version: 8
 
 # Auto-Save feature automatically saves playerdata
 # (class, level, etc.) and guild data
@@ -122,7 +122,7 @@ vanilla-exp-redirection:
 override-vanilla-exp: true
 
 # Check the target player's RPG profile when shift when shift right clicking.
-shift-click-player-profile-check: true
+shift-click-player-profile-check: false
 
 # If main class experience holograms should be displayed
 # whenever a player earns main class exp