Reimplement Impact event

- Added custom events for Skill Shot and Daze.
- Archery metadata is now stored directly as a location, rather than a
string.
- Fixed bug where arrows weren't properly tracked.
- Use HashMap instead of ArrayList for entity tracking.

Changelog.txt

@@ -19,6 +19,8 @@ Version 1.4.08-dev
  = Fixed exploit where you could receive smelting XP for improper items
  = Fixed bug where the Unbreaking enchantment was ignored when using "Super Breaker" or "Giga Drill Breaker"
  = Fixed bug which prevented players from gaining Acrobatics XP when the setting 'Prevent_XP_After_Teleport' was set to false
+ = Fixed McMMOPlayerDisarmEvent reporting the skill level of the defending player, not the attacking player.
+ = Fixed bug where arrow retrieval was not properly detecting entities that already existed in the tracker
  ! Updated localization files
 
 Version 1.4.07

src/main/java/com/gmail/nossr50/config/Config.java

@@ -205,7 +205,6 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getStatsTrackingEnabled() { return config.getBoolean("General.Stats_Tracking", true); }
     public boolean getUpdateCheckEnabled() { return config.getBoolean("General.Update_Check", true); }
     public boolean getPreferBeta() { return config.getBoolean("General.Prefer_Beta", false); }
-    public boolean getEventCallbackEnabled() { return config.getBoolean("General.Event_Callback", true); }
     public boolean getVerboseLoggingEnabled() { return config.getBoolean("General.Verbose_Logging", false); }
     public boolean getConfigOverwriteEnabled() { return config.getBoolean("General.Config_Update_Overwrite", true); }
 

src/main/java/com/gmail/nossr50/datatypes/player/McMMOPlayer.java

@@ -528,7 +528,7 @@ public class McMMOPlayer {
             return;
         }
 
-        if (!EventUtils.handleXpGainEvent(player, skillType, xp)) {
+        if (!EventUtils.handleXpChangeEvent(player, skillType, xp, true)) {
             return;
         }
 
@@ -757,6 +757,10 @@ public class McMMOPlayer {
         ToolType tool = skill.getTool();
         AbilityType ability = skill.getAbility();
 
+        if (!getToolPreparationMode(tool) || !ability.getPermissions(player)) {
+            return;
+        }
+
         setToolPreparationMode(tool, false);
 
         if (getAbilityMode(ability)) {
@@ -777,7 +781,7 @@ public class McMMOPlayer {
             return;
         }
 
-        if (EventUtils.callPlayerAbilityActivateEvent(player, skill).isCancelled()) {
+        if (!EventUtils.handlePlayerAbilityActivateEvent(player, ability)) {
             return;
         }
 

src/main/java/com/gmail/nossr50/events/abilities/McMMOPlayerAbilityActivateEvent.java

@@ -1,18 +1,25 @@
-package com.gmail.nossr50.events.skills.abilities;
+package com.gmail.nossr50.events.abilities;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
 
+import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
 public class McMMOPlayerAbilityActivateEvent extends McMMOPlayerAbilityEvent implements Cancellable {
     private boolean cancelled;
 
+    @Deprecated
     public McMMOPlayerAbilityActivateEvent(Player player, SkillType skill) {
         super(player, skill);
         cancelled = false;
     }
 
+    public McMMOPlayerAbilityActivateEvent(Player player, AbilityType ability) {
+        super(player, ability);
+        cancelled = false;
+    }
+
     public boolean isCancelled() {
         return cancelled;
     }

src/main/java/com/gmail/nossr50/events/abilities/McMMOPlayerAbilityDeactivateEvent.java

@@ -1,11 +1,17 @@
-package com.gmail.nossr50.events.skills.abilities;
+package com.gmail.nossr50.events.abilities;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
 public class McMMOPlayerAbilityDeactivateEvent extends McMMOPlayerAbilityEvent {
+    @Deprecated
     public McMMOPlayerAbilityDeactivateEvent(Player player, SkillType skill) {
         super(player, skill);
     }
+
+    public McMMOPlayerAbilityDeactivateEvent(Player player, AbilityType ability) {
+        super(player, ability);
+    }
 }

src/main/java/com/gmail/nossr50/events/abilities/McMMOPlayerAbilityEvent.java

@@ -0,0 +1,62 @@
+package com.gmail.nossr50.events.abilities;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+
+public abstract class McMMOPlayerAbilityEvent extends PlayerEvent {
+    private SkillType skill;
+    private AbilityType ability;
+    private boolean useParticleEffects;
+
+    @Deprecated
+    protected McMMOPlayerAbilityEvent(Player player, SkillType skill) {
+        super(player);
+        ability = skill.getAbility();
+        useParticleEffects = true;
+    }
+
+    protected McMMOPlayerAbilityEvent(Player player, AbilityType ability) {
+        super(player);
+        this.ability = ability;
+        this.useParticleEffects = true;
+    }
+
+    protected McMMOPlayerAbilityEvent(Player player, AbilityType ability, boolean useParticleEffects) {
+        super(player);
+        this.ability = ability;
+        this.useParticleEffects = useParticleEffects;
+    }
+
+    @Deprecated
+    public SkillType getSkill() {
+        return skill;
+    }
+
+    public AbilityType getAbility() {
+        return ability;
+    }
+
+    public boolean useParticleEffects() {
+        return useParticleEffects;
+    }
+
+    public void shouldUseParticleEffects(boolean useParticleEffects) {
+        this.useParticleEffects = useParticleEffects;
+    }
+
+    /** Rest of file is required boilerplate for custom events **/
+    private static final HandlerList handlers = new HandlerList();
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

src/main/java/com/gmail/nossr50/events/experience/levels/McMMOPlayerLevelChangeEvent.java

@@ -1,8 +1,9 @@
-package com.gmail.nossr50.events.experience;
+package com.gmail.nossr50.events.experience.levels;
 
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.experience.McMMOPlayerExperienceEvent;
 
 /**
  * Called when a user levels change

src/main/java/com/gmail/nossr50/events/experience/levels/McMMOPlayerLevelDownEvent.java

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience;
+package com.gmail.nossr50.events.experience.levels;
 
 import org.bukkit.entity.Player;
 

src/main/java/com/gmail/nossr50/events/experience/levels/McMMOPlayerLevelUpEvent.java

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience;
+package com.gmail.nossr50.events.experience.levels;
 
 import org.bukkit.entity.Player;
 

src/main/java/com/gmail/nossr50/events/experience/xp/McMMOPlayerXpChangeEvent.java

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.events.experience.xp;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.experience.McMMOPlayerExperienceEvent;
+
+public abstract class McMMOPlayerXpChangeEvent extends McMMOPlayerExperienceEvent {
+    public McMMOPlayerXpChangeEvent(Player player, SkillType skill) {
+        super(player, skill);
+    }
+}

src/main/java/com/gmail/nossr50/events/experience/xp/McMMOPlayerXpGainEvent.java

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience;
+package com.gmail.nossr50.events.experience.xp;
 
 import org.bukkit.entity.Player;
 
@@ -7,7 +7,7 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 /**
  * Called when a player gains XP in a skill
  */
-public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
+public class McMMOPlayerXpGainEvent extends McMMOPlayerXpChangeEvent {
     private float xpGained;
 
     public McMMOPlayerXpGainEvent(Player player, SkillType skill, float xpGained) {
@@ -31,7 +31,7 @@ public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
     }
 
     /**
-     * @param xpGained int amount of experience gained in this event
+     * @param xpGained float amount of experience gained in this event
      */
     public void setRawXpGained(float xpGained) {
         this.xpGained = xpGained;

src/main/java/com/gmail/nossr50/events/experience/xp/McMMOPlayerXpLossEvent.java

@@ -0,0 +1,28 @@
+package com.gmail.nossr50.events.experience.xp;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+
+public class McMMOPlayerXpLossEvent extends McMMOPlayerXpChangeEvent {
+    private float xpLost;
+
+    public McMMOPlayerXpLossEvent(Player player, SkillType skill, float xpLost) {
+        super(player, skill);
+        this.xpLost = xpLost;
+    }
+
+    /**
+     * @return The amount of experience lost in this event
+     */
+    public float getRawXpLost() {
+        return xpLost;
+    }
+
+    /**
+     * @param xpLost amount of experience lost in this event
+     */
+    public void setRawXpLost(float xpLost) {
+        this.xpLost = xpLost;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/McMMOPlayerCombatEvent.java

@@ -0,0 +1,40 @@
+package com.gmail.nossr50.events.skills;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
+import com.gmail.nossr50.util.player.UserManager;
+
+public abstract class McMMOPlayerCombatEvent extends FakeEntityDamageByEntityEvent {
+    private Player player;
+    private SkillType skill;
+    private int skillLevel;
+
+    protected McMMOPlayerCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage, SkillType skill) {
+        super(damager, damagee, cause, damage);
+        this.player = player;
+        this.skill = skill;
+        skillLevel = UserManager.getPlayer(player).getProfile().getSkillLevel(skill);
+    }
+
+    protected McMMOPlayerCombatEvent(Player player, Entity damagee, DamageCause cause, double damage, SkillType skill) {
+        super(player, damagee, cause, damage);
+        this.player = player;
+        this.skill = skill;
+        skillLevel = UserManager.getPlayer(player).getProfile().getSkillLevel(skill);
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public SkillType getSkill() {
+        return skill;
+    }
+
+    public int getSkillLevel() {
+        return skillLevel;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/McMMOPlayerTreasureEvent.java

@@ -0,0 +1,44 @@
+package com.gmail.nossr50.events.skills;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+
+public abstract class McMMOPlayerTreasureEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
+    private ItemStack treasure;
+    private int xpGained;
+
+    protected McMMOPlayerTreasureEvent(Player player, SkillType skill, ItemStack treasure, int xpGained) {
+        super(player, skill);
+        this.treasure = treasure;
+        this.xpGained = xpGained;
+        this.cancelled = false;
+    }
+
+    public ItemStack getTreasure() {
+        return treasure;
+    }
+
+    public void setTreasure(ItemStack item) {
+        this.treasure = item;
+    }
+
+    public int getXpGained() {
+        return xpGained;
+    }
+
+    public void setXpGained(int xpGained) {
+        this.xpGained = xpGained;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean newValue) {
+        this.cancelled = newValue;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/abilities/McMMOPlayerAbilityEvent.java

@@ -1,20 +0,0 @@
-package com.gmail.nossr50.events.skills.abilities;
-
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.AbilityType;
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public class McMMOPlayerAbilityEvent extends McMMOPlayerSkillEvent {
-    private AbilityType ability;
-
-    protected McMMOPlayerAbilityEvent(Player player, SkillType skill) {
-        super(player, skill);
-        ability = skill.getAbility();
-    }
-
-    public AbilityType getAbility() {
-        return ability;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerAcrobaticsEvent.java

@@ -0,0 +1,24 @@
+package com.gmail.nossr50.events.skills.acrobatics;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class McMMOPlayerAcrobaticsEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
+
+    protected McMMOPlayerAcrobaticsEvent(Player player) {
+        super(player, SkillType.ACROBATICS);
+        cancelled = false;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerDodgeEvent.java

@@ -0,0 +1,30 @@
+package com.gmail.nossr50.events.skills.acrobatics;
+
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerDodgeEvent extends McMMOPlayerAcrobaticsEvent {
+    private double damageTaken;
+    private float xpGained;
+
+    public McMMOPlayerDodgeEvent(Player player, double damageTaken, float xpGained) {
+        super(player);
+        this.damageTaken = damageTaken;
+        this.xpGained = xpGained;
+    }
+
+    public double getDamageTaken() {
+        return damageTaken;
+    }
+
+    public void setDamageTaken(double damageTaken) {
+        this.damageTaken = damageTaken;
+    }
+
+    public float getXpGained() {
+        return xpGained;
+    }
+
+    public void setXpGained(float xpGained) {
+        this.xpGained = xpGained;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerRollEvent.java

@@ -0,0 +1,36 @@
+package com.gmail.nossr50.events.skills.acrobatics;
+
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerRollEvent extends McMMOPlayerAcrobaticsEvent {
+    private double damageTaken;
+    private float xpGained;
+    private boolean graceful;
+
+    public McMMOPlayerRollEvent(Player player, double damageTaken, float xpGained, boolean graceful) {
+        super(player);
+        this.damageTaken = damageTaken;
+        this.xpGained = xpGained;
+        this.graceful = graceful;
+    }
+
+    public double getDamageTaken() {
+        return damageTaken;
+    }
+
+    public void setDamageTaken(double damageTaken) {
+        this.damageTaken = damageTaken;
+    }
+
+    public float getXpGained() {
+        return xpGained;
+    }
+
+    public void setXpGained(float xpGained) {
+        this.xpGained = xpGained;
+    }
+
+    public boolean isGraceful() {
+        return graceful;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerArcheryCombatEvent.java

@@ -0,0 +1,13 @@
+package com.gmail.nossr50.events.skills.archery;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
+
+public class McMMOPlayerArcheryCombatEvent extends McMMOPlayerCombatEvent {
+    public McMMOPlayerArcheryCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage) {
+        super(player, damager, damagee, cause, damage, SkillType.ARCHERY);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerArcheryEvent.java

@@ -0,0 +1,24 @@
+package com.gmail.nossr50.events.skills.archery;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class McMMOPlayerArcheryEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
+
+    protected McMMOPlayerArcheryEvent(Player player) {
+        super(player, SkillType.ARCHERY);
+        cancelled = false;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerDazeEvent.java

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.events.skills.archery;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.skills.archery.Archery;
+
+public class McMMOPlayerDazeEvent extends McMMOPlayerArcheryCombatEvent {
+    public McMMOPlayerDazeEvent(Player player, Entity damager, Entity damagee) {
+        super(player, damager, damagee, DamageCause.PROJECTILE, Archery.dazeModifier);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerSkillShotEvent.java

@@ -0,0 +1,10 @@
+package com.gmail.nossr50.events.skills.archery;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerSkillShotEvent extends McMMOPlayerArcheryCombatEvent {
+    public McMMOPlayerSkillShotEvent(Player player, Entity damager, Entity damagee, double damage) {
+        super(player, damager, damagee, DamageCause.PROJECTILE, damage);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeCombatEvent.java

@@ -0,0 +1,13 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
+
+public class McMMOPlayerAxeCombatEvent extends McMMOPlayerCombatEvent {
+    public McMMOPlayerAxeCombatEvent(Player player, Entity damagee, DamageCause cause, double damage) {
+        super(player, damagee, cause, damage, SkillType.AXES);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeEvent.java

@@ -0,0 +1,24 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class McMMOPlayerAxeEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
+
+    protected McMMOPlayerAxeEvent(Player player) {
+        super(player, SkillType.AXES);
+        cancelled = false;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeMasteryEvent.java

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerAxeMasteryEvent extends McMMOPlayerAxeCombatEvent {
+    public McMMOPlayerAxeMasteryEvent(Player player, Entity damagee, double damage) {
+        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
+        // TODO Auto-generated constructor stub
+    }
+
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerCriticalHitEvent.java

@@ -0,0 +1,10 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerCriticalHitEvent extends McMMOPlayerAxeCombatEvent {
+    public McMMOPlayerCriticalHitEvent(Player player, Entity damagee, double damage) {
+        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerGreaterImpactEvent.java

@@ -0,0 +1,22 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+public class McMMOPlayerGreaterImpactEvent extends McMMOPlayerAxeCombatEvent {
+    private Vector knockbackVelocity;
+
+    public McMMOPlayerGreaterImpactEvent(Player player, Entity damagee, double damage, Vector knockbackVelocity) {
+        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
+        this.knockbackVelocity = knockbackVelocity;
+    }
+
+    public Vector getKnockbackVelocity() {
+        return knockbackVelocity;
+    }
+
+    public void setKnockbackVelocity(Vector knockbackVelocity) {
+        this.knockbackVelocity = knockbackVelocity;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerImpactEvent.java

@@ -0,0 +1,17 @@
+package com.gmail.nossr50.events.skills.axes;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class McMMOPlayerImpactEvent extends McMMOPlayerAxeEvent {
+    private ItemStack armor;
+
+    public McMMOPlayerImpactEvent(Player player, ItemStack armor) {
+        super(player);
+        this.armor = armor;
+    }
+
+    public ItemStack getArmor() {
+        return armor;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/excavation/McMMOPlayerExcavationTreasureEvent.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.events.skills.excavation;
+
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerTreasureEvent;
+
+public class McMMOPlayerExcavationTreasureEvent extends McMMOPlayerTreasureEvent {
+    private Block block;
+
+    public McMMOPlayerExcavationTreasureEvent(Player player, ItemStack treasure, int xpGained, Block block) {
+        super(player, SkillType.EXCAVATION, treasure, xpGained);
+        this.block = block;
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerFishingCombatEvent.java

@@ -0,0 +1,13 @@
+package com.gmail.nossr50.events.skills.fishing;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
+
+public abstract class McMMOPlayerFishingCombatEvent extends McMMOPlayerCombatEvent {
+    public McMMOPlayerFishingCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage) {
+        super(player, damager, damagee, cause, damage, SkillType.FISHING);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerFishingTreasureEvent.java

@@ -3,29 +3,11 @@ package com.gmail.nossr50.events.skills.fishing;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-public class McMMOPlayerFishingTreasureEvent extends McMMOPlayerFishingEvent {
-    private ItemStack treasure;
-    private int xp;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerTreasureEvent;
 
-    public McMMOPlayerFishingTreasureEvent(Player player, ItemStack treasure, int xp) {
-        super(player);
-        this.treasure = treasure;
-        this.xp = xp;
-    }
-
-    public ItemStack getTreasure() {
-        return treasure;
-    }
-
-    public void setTreasure(ItemStack item) {
-        this.treasure = item;
-    }
-
-    public int getXp() {
-        return xp;
-    }
-
-    public void setXp(int xp) {
-        this.xp = xp;
+public class McMMOPlayerFishingTreasureEvent extends McMMOPlayerTreasureEvent {
+    public McMMOPlayerFishingTreasureEvent(Player player, ItemStack treasure, int xpGained) {
+        super(player, SkillType.FISHING, treasure, xpGained);
     }
 }

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerShakeEvent.java

@@ -1,13 +1,15 @@
 package com.gmail.nossr50.events.skills.fishing;
 
+import org.bukkit.entity.Fish;
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-public class McMMOPlayerShakeEvent extends McMMOPlayerFishingEvent {
+public class McMMOPlayerShakeEvent extends McMMOPlayerFishingCombatEvent {
     private ItemStack drop;
 
-    public McMMOPlayerShakeEvent(Player player, ItemStack drop) {
-        super(player);
+    public McMMOPlayerShakeEvent(Player player, Fish hook, ItemStack drop, LivingEntity target, double damage) {
+        super(player, hook, target, DamageCause.PROJECTILE, damage);
         this.drop = drop;
     }
 

src/main/java/com/gmail/nossr50/events/skills/herbalism/McMMOPlayerHerbalismEvent.java

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.events.skills.herbalism;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class McMMOPlayerHerbalismEvent extends McMMOPlayerSkillEvent {
+    public McMMOPlayerHerbalismEvent(Player player) {
+        super(player, SkillType.HERBALISM);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerDeflectEvent.java

@@ -0,0 +1,9 @@
+package com.gmail.nossr50.events.skills.unarmed;
+
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerDeflectEvent extends McMMOPlayerUnarmedEvent {
+    public McMMOPlayerDeflectEvent(Player player) {
+        super(player);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerDisarmEvent.java

@@ -1,32 +1,27 @@
 package com.gmail.nossr50.events.skills.unarmed;
 
 import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
+import org.bukkit.inventory.ItemStack;
 
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public class McMMOPlayerDisarmEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
+public class McMMOPlayerDisarmEvent extends McMMOPlayerUnarmedEvent {
     private Player defender;
+    private ItemStack droppedItem;
 
-    public McMMOPlayerDisarmEvent(Player defender) {
-        super(defender, SkillType.UNARMED);
+    public McMMOPlayerDisarmEvent(Player attacker, Player defender) {
+        super(attacker);
         this.defender = defender;
+        this.setDroppedItem(defender.getItemInHand());
     }
 
     public Player getDefender() {
         return defender;
     }
 
-    /** Following are required for Cancellable **/
-    @Override
-    public boolean isCancelled() {
-        return cancelled;
+    public ItemStack getDroppedItem() {
+        return droppedItem;
     }
 
-    @Override
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
+    public void setDroppedItem(ItemStack droppedItem) {
+        this.droppedItem = droppedItem;
     }
 }

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerUnarmedEvent.java

@@ -0,0 +1,24 @@
+package com.gmail.nossr50.events.skills.unarmed;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class McMMOPlayerUnarmedEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
+
+    protected McMMOPlayerUnarmedEvent(Player player) {
+        super(player, SkillType.UNARMED);
+        cancelled = false;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

src/main/java/com/gmail/nossr50/listeners/BlockListener.java

@@ -26,7 +26,6 @@ import com.gmail.nossr50.config.HiddenConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.events.fake.FakeBlockBreakEvent;
 import com.gmail.nossr50.events.fake.FakeBlockDamageEvent;
 import com.gmail.nossr50.runnables.StickyPistonTrackerTask;
@@ -144,21 +143,17 @@ public class BlockListener implements Listener {
         ItemStack heldItem = player.getItemInHand();
 
         /* HERBALISM */
-        if (BlockUtils.affectedByGreenTerra(blockState)) {
+        if (BlockUtils.affectedByGreenTerra(blockState) && Permissions.skillEnabled(player, SkillType.HERBALISM)) {
             HerbalismManager herbalismManager = mcMMOPlayer.getHerbalismManager();
 
             /* Green Terra */
-            if (herbalismManager.canActivateAbility()) {
-                mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
-            }
+            mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
 
             /*
              * We don't check the block store here because herbalism has too many unusual edge cases.
              * Instead, we check it inside the drops handler.
              */
-            if (SkillType.HERBALISM.getPermissions(player)) {
-                herbalismManager.herbalismBlockCheck(blockState);
-            }
+            herbalismManager.blockBreak(blockState);
         }
 
         /* MINING */
@@ -182,7 +177,7 @@ public class BlockListener implements Listener {
         /* EXCAVATION */
         else if (BlockUtils.affectedByGigaDrillBreaker(blockState) && ItemUtils.isShovel(heldItem) && SkillType.EXCAVATION.getPermissions(player) && !mcMMO.getPlaceStore().isTrue(blockState)) {
             ExcavationManager excavationManager = mcMMOPlayer.getExcavationManager();
-            excavationManager.excavationBlockCheck(blockState);
+            excavationManager.blockBreak(blockState);
 
             if (mcMMOPlayer.getAbilityMode(AbilityType.GIGA_DRILL_BREAKER)) {
                 excavationManager.gigaDrillBreaker(blockState);
@@ -279,19 +274,19 @@ public class BlockListener implements Listener {
                 }
             }
 
-            if (mcMMOPlayer.getToolPreparationMode(ToolType.HOE) && ItemUtils.isHoe(heldItem) && (BlockUtils.affectedByGreenTerra(blockState) || BlockUtils.canMakeMossy(blockState)) && Permissions.greenTerra(player)) {
+            if (ItemUtils.isHoe(heldItem) && (BlockUtils.affectedByGreenTerra(blockState) || BlockUtils.canMakeMossy(blockState))) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
             }
-            else if (mcMMOPlayer.getToolPreparationMode(ToolType.AXE) && ItemUtils.isAxe(heldItem) && BlockUtils.isLog(blockState) && Permissions.treeFeller(player)) {
+            else if (ItemUtils.isAxe(heldItem) && BlockUtils.isLog(blockState)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.WOODCUTTING);
             }
-            else if (mcMMOPlayer.getToolPreparationMode(ToolType.PICKAXE) && ItemUtils.isPickaxe(heldItem) && BlockUtils.affectedBySuperBreaker(blockState) && Permissions.superBreaker(player)) {
+            else if (ItemUtils.isPickaxe(heldItem) && BlockUtils.affectedBySuperBreaker(blockState)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.MINING);
             }
-            else if (mcMMOPlayer.getToolPreparationMode(ToolType.SHOVEL) && ItemUtils.isShovel(heldItem) && BlockUtils.affectedByGigaDrillBreaker(blockState) && Permissions.gigaDrillBreaker(player)) {
+            else if (ItemUtils.isShovel(heldItem) && BlockUtils.affectedByGigaDrillBreaker(blockState)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.EXCAVATION);
             }
-            else if (mcMMOPlayer.getToolPreparationMode(ToolType.FISTS) && heldItem.getType() == Material.AIR && (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW || BlockUtils.affectedByBlockCracker(blockState) && Permissions.berserk(player))) {
+            else if (heldItem.getType() == Material.AIR && (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW || BlockUtils.affectedByBlockCracker(blockState))) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.UNARMED);
             }
         }
@@ -334,7 +329,7 @@ public class BlockListener implements Listener {
          * We don't need to check permissions here because they've already been checked for the ability to even activate.
          */
         if (mcMMOPlayer.getAbilityMode(AbilityType.GREEN_TERRA) && BlockUtils.canMakeMossy(blockState)) {
-            if (mcMMOPlayer.getHerbalismManager().processGreenTerra(blockState)) {
+            if (mcMMOPlayer.getHerbalismManager().greenTerra(blockState)) {
                 blockState.update(true);
             }
         }

src/main/java/com/gmail/nossr50/listeners/EntityListener.java

@@ -40,7 +40,6 @@ import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
 import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
-import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
 import com.gmail.nossr50.skills.archery.Archery;
 import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.herbalism.Herbalism;
@@ -75,7 +74,7 @@ public class EntityListener implements Listener {
         }
 
         projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, Math.min(event.getForce() * AdvancedConfig.getInstance().getForceMultiplier(), 1.0)));
-        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, projectile.getLocation()));
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -87,7 +86,7 @@ public class EntityListener implements Listener {
         }
 
         projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, 1.0));
-        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, projectile.getLocation()));
     }
 
     /**
@@ -236,16 +235,8 @@ public class EntityListener implements Listener {
                         return;
                     }
 
-                    AcrobaticsManager acrobaticsManager = mcMMOPlayer.getAcrobaticsManager();
-
-                    if (acrobaticsManager.canRoll()) {
-                        event.setDamage(acrobaticsManager.rollCheck(event.getDamage()));
-
-                        if (event.getDamage() == 0) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
+                    event.setDamage(mcMMOPlayer.getAcrobaticsManager().roll(event.getDamage()));
+                    event.setCancelled(event.getDamage() == 0);
                     break;
 
                 case BLOCK_EXPLOSION:
@@ -531,13 +522,13 @@ public class EntityListener implements Listener {
 
             case COOKED_FISH: /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
                 if (Permissions.fishermansDiet(player)) {
-                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().fishermansDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
                 }
                 return;
 
             case RAW_FISH:    /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
                 if (Permissions.fishermansDiet(player)) {
-                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().fishermansDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
                 }
                 return;
 

src/main/java/com/gmail/nossr50/listeners/PlayerListener.java

@@ -7,7 +7,6 @@ import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Item;
-import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -212,24 +211,15 @@ public class PlayerListener implements Listener {
 
         switch (event.getState()) {
             case FISHING:
-                if (!Permissions.krakenBypass(player)) {
-                    event.setCancelled(fishingManager.exploitPrevention());
-                }
+                event.setCancelled(fishingManager.exploitPrevention());
                 return;
 
             case CAUGHT_FISH:
-                if (Permissions.vanillaXpBoost(player, SkillType.FISHING)) {
-                    event.setExpToDrop(fishingManager.handleVanillaXpBoost(event.getExpToDrop()));
-                }
+                event.setExpToDrop(fishingManager.vanillaXpBoost(event.getExpToDrop()));
                 return;
 
             case IN_GROUND:
-                Block block = player.getTargetBlock(null, 100);
-
-                if (fishingManager.canIceFish(block)) {
-                    event.setCancelled(true);
-                    fishingManager.iceFishing(event.getHook(), block);
-                }
+                event.setCancelled(fishingManager.iceFishing(event.getHook(), player.getTargetBlock(null, 100)));
                 return;
 
             default:
@@ -258,9 +248,7 @@ public class PlayerListener implements Listener {
 
         switch (event.getState()) {
             case FISHING:
-                if (fishingManager.canMasterAngler()) {
-                    fishingManager.masterAngler(event.getHook());
-                }
+                fishingManager.masterAngler(event.getHook());
                 return;
 
             case CAUGHT_FISH:
@@ -268,9 +256,7 @@ public class PlayerListener implements Listener {
                 return;
 
             case CAUGHT_ENTITY:
-                if (fishingManager.canShake(caught)) {
-                    fishingManager.shakeCheck((LivingEntity) caught);
-                }
+                fishingManager.shake(event.getHook(), caught);
                 return;
 
             default:
@@ -439,7 +425,6 @@ public class PlayerListener implements Listener {
                         // Make sure the player knows what he's doing when trying to salvage an enchanted item
                         if (!(heldItem.getEnchantments().size() > 0) || repairManager.checkConfirmation(type, true)) {
                             repairManager.handleSalvage(block.getLocation(), heldItem);
-                            player.updateInventory();
                         }
                     }
                 }
@@ -530,12 +515,8 @@ public class PlayerListener implements Listener {
                 /* GREEN THUMB CHECK */
                 HerbalismManager herbalismManager = mcMMOPlayer.getHerbalismManager();
 
-                if (herbalismManager.canGreenThumbBlock(blockState)) {
-                    player.setItemInHand(new ItemStack(Material.SEEDS, heldItem.getAmount() - 1));
-
-                    if (herbalismManager.processGreenThumbBlocks(blockState) && EventUtils.simulateBlockBreak(block, player, false)) {
-                        blockState.update(true);
-                    }
+                if (herbalismManager.greenThumbBlocks(blockState) && EventUtils.simulateBlockBreak(block, player, false)) {
+                    blockState.update(true);
                 }
 
                 /* SHROOM THUMB CHECK */

src/main/java/com/gmail/nossr50/listeners/ScoreboardsListener.java

@@ -6,9 +6,9 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
-import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
-import com.gmail.nossr50.events.experience.McMMOPlayerXpGainEvent;
-import com.gmail.nossr50.events.skills.abilities.McMMOPlayerAbilityActivateEvent;
+import com.gmail.nossr50.events.abilities.McMMOPlayerAbilityActivateEvent;
+import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.events.experience.xp.McMMOPlayerXpGainEvent;
 import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 
 public class ScoreboardsListener implements Listener {

src/main/java/com/gmail/nossr50/listeners/SelfListener.java

@@ -5,7 +5,7 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelUpEvent;
 
 public class SelfListener implements Listener {
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)

src/main/java/com/gmail/nossr50/runnables/skills/AbilityDisableTask.java

@@ -9,7 +9,6 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
-import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.PerksUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
@@ -46,18 +45,11 @@ public class AbilityDisableTask extends BukkitRunnable {
                 break;
         }
 
-        EventUtils.callAbilityDeactivateEvent(player, ability);
+        EventUtils.handleAbilityDeactivateEvent(player, ability);
 
         mcMMOPlayer.setAbilityMode(ability, false);
         mcMMOPlayer.setAbilityInformed(ability, false);
 
-        ParticleEffectUtils.playAbilityDisabledEffect(player);
-
-        if (mcMMOPlayer.useChatNotifications()) {
-            player.sendMessage(ability.getAbilityOff());
-        }
-
-        SkillUtils.sendSkillMessage(player, ability.getAbilityPlayerOff(player));
         new AbilityCooldownTask(mcMMOPlayer, ability).runTaskLaterAsynchronously(mcMMO.p, PerksUtils.handleCooldownPerks(player, ability.getCooldown()) * Misc.TICK_CONVERSION_FACTOR);
     }
 }

src/main/java/com/gmail/nossr50/skills/acrobatics/Acrobatics.java

@@ -27,11 +27,11 @@ public final class Acrobatics {
 
     private Acrobatics() {};
 
-    protected static double calculateModifiedDodgeDamage(double damage, double damageModifier) {
-        return Math.max(damage / damageModifier, 1.0);
+    protected static double calculateModifiedDodgeDamage(double damage) {
+        return Math.max(damage / dodgeDamageModifier, 1.0);
     }
 
-    protected static double calculateModifiedRollDamage(double damage, double damageThreshold) {
-        return Math.max(damage - damageThreshold, 0.0);
+    protected static double calculateModifiedRollDamage(double damage, boolean isGraceful) {
+        return Math.max(damage - (isGraceful ? gracefulRollThreshold : rollThreshold), 0.0);
     }
 }

src/main/java/com/gmail/nossr50/skills/acrobatics/AcrobaticsManager.java

@@ -8,9 +8,12 @@ import org.bukkit.entity.LightningStrike;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.acrobatics.McMMOPlayerDodgeEvent;
+import com.gmail.nossr50.events.skills.acrobatics.McMMOPlayerRollEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
@@ -30,44 +33,8 @@ public class AcrobaticsManager extends SkillManager {
         return !exploitPrevention() && Permissions.roll(getPlayer());
     }
 
-    public boolean canDodge(Entity damager) {
-        if (Permissions.dodge(getPlayer())) {
-            if (damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) {
-                return false;
-            }
-
-            return skill.shouldProcess(damager);
-        }
-
-        return false;
-    }
-
-    /**
-     * Handle the damage reduction and XP gain from the Dodge ability
-     *
-     * @param damage The amount of damage initially dealt by the event
-     * @return the modified event damage if the ability was successful, the original event damage otherwise
-     */
-    public double dodgeCheck(double damage) {
-        double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage, Acrobatics.dodgeDamageModifier);
-        Player player = getPlayer();
-
-        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Acrobatics.dodgeMaxChance, Acrobatics.dodgeMaxBonusLevel)) {
-            ParticleEffectUtils.playDodgeEffect(player);
-
-            if (mcMMOPlayer.useChatNotifications()) {
-                player.sendMessage(LocaleLoader.getString("Acrobatics.Combat.Proc"));
-            }
-
-            // Why do we check respawn cooldown here?
-            if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
-                applyXpGain((float) (damage * Acrobatics.dodgeXpModifier));
-            }
-
-            return modifiedDamage;
-        }
-
-        return damage;
+    private boolean canDodge(Entity damager, double modifiedDamage) {
+        return (Permissions.dodge(getPlayer()) && !(damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) && skill.shouldProcess(damager) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Acrobatics.dodgeMaxChance, Acrobatics.dodgeMaxBonusLevel) && !isFatal(modifiedDamage));
     }
 
     /**
@@ -76,47 +43,28 @@ public class AcrobaticsManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      * @return the modified event damage if the ability was successful, the original event damage otherwise
      */
-    public double rollCheck(double damage) {
+    public double roll(double damage) {
+        if (!canRoll()) {
+            return damage;
+        }
+
         Player player = getPlayer();
+        boolean isGraceful = player.isSneaking() && Permissions.gracefulRoll(player);
+        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, isGraceful);
 
-        if (player.isSneaking() && Permissions.gracefulRoll(player)) {
-            return gracefulRollCheck(damage);
-        }
+        if (!isFatal(modifiedDamage) && isSuccessfulRoll(isGraceful)) {
+            McMMOPlayerRollEvent event = new McMMOPlayerRollEvent(player, modifiedDamage, calculateRollXP(damage, true), isGraceful);
+            mcMMO.p.getServer().getPluginManager().callEvent(event);
 
-        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.rollThreshold);
+            if (event.isCancelled()) {
+                return damage;
+            }
 
-        if (!isFatal(modifiedDamage) && isSuccessfulRoll(Acrobatics.rollMaxChance, Acrobatics.rollMaxBonusLevel)) {
-            player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
-            applyXpGain(calculateRollXP(damage, true));
-
-            return modifiedDamage;
-        }
-        else if (!isFatal(damage)) {
-            applyXpGain(calculateRollXP(damage, false));
-        }
-
-        lastFallLocation = player.getLocation();
-
-        return damage;
-    }
-
-    /**
-     * Handle the damage reduction and XP gain from the Graceful Roll ability
-     *
-     * @param damage The amount of damage initially dealt by the event
-     * @return the modified event damage if the ability was successful, the original event damage otherwise
-     */
-    private double gracefulRollCheck(double damage) {
-        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.gracefulRollThreshold);
-
-        if (!isFatal(modifiedDamage) && isSuccessfulRoll(Acrobatics.gracefulRollMaxChance, Acrobatics.gracefulRollMaxBonusLevel)) {
-            getPlayer().sendMessage(LocaleLoader.getString("Acrobatics.Ability.Proc"));
-            applyXpGain(calculateRollXP(damage, true));
-
-            return modifiedDamage;
+            return event.getDamageTaken();
         }
         else if (!isFatal(damage)) {
             applyXpGain(calculateRollXP(damage, false));
+            lastFallLocation = player.getLocation();
         }
 
         return damage;
@@ -149,12 +97,47 @@ public class AcrobaticsManager extends SkillManager {
         return fallTries > Config.getInstance().getAcrobaticsAFKMaxTries();
     }
 
-    private boolean isSuccessfulRoll(double maxChance, int maxLevel) {
-        return (maxChance / maxLevel) * Math.min(getSkillLevel(), maxLevel) > Misc.getRandom().nextInt(activationChance);
+    /**
+     * Handle the damage reduction and XP gain from the Dodge ability
+     *
+     * @param damager The entity that dealt the damage
+     * @param damage The amount of damage initially dealt by the event
+     * @return the modified event damage if the ability was successful, the original event damage otherwise
+     */
+    public double dodge(Entity damager, double damage) {
+        double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage);
+
+        if (!canDodge(damager, modifiedDamage)) {
+            return damage;
+        }
+
+        Player player = getPlayer();
+
+        McMMOPlayerDodgeEvent event = new McMMOPlayerDodgeEvent(player, modifiedDamage, (float) (damage * Acrobatics.dodgeXpModifier));
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return damage;
+        }
+
+        ParticleEffectUtils.playDodgeEffect(player);
+
+        if (mcMMOPlayer.useChatNotifications()) {
+            player.sendMessage(LocaleLoader.getString("Acrobatics.Combat.Proc"));
+        }
+
+        if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
+            applyXpGain(event.getXpGained());
+        }
+
+        return event.getDamageTaken();
     }
 
-    private boolean isFatal(double damage) {
-        return getPlayer().getHealth() - damage < 1;
+    private boolean isSuccessfulRoll(boolean isGraceful) {
+        double maxChance = isGraceful ? Acrobatics.gracefulRollMaxChance : Acrobatics.rollMaxChance;
+        int maxLevel = isGraceful ? Acrobatics.gracefulRollMaxBonusLevel : Acrobatics.rollMaxBonusLevel;
+
+        return (maxChance / maxLevel) * Math.min(getSkillLevel(), maxLevel) > Misc.getRandom().nextInt(activationChance);
     }
 
     private float calculateRollXP(double damage, boolean isRoll) {
@@ -167,4 +150,8 @@ public class AcrobaticsManager extends SkillManager {
 
         return xp;
     }
+
+    private boolean isFatal(double damage) {
+        return getPlayer().getHealth() - damage < 1;
+    }
 }

src/main/java/com/gmail/nossr50/skills/archery/Archery.java

@@ -1,20 +1,18 @@
 package com.gmail.nossr50.skills.archery;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
 
-import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.inventory.ItemStack;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.util.Misc;
 
 public class Archery {
-    private static List<TrackedEntity> trackedEntities = new ArrayList<TrackedEntity>();
+    private static Map<UUID, TrackedEntity> trackedEntities = new HashMap<UUID, TrackedEntity>();
 
     public static int    retrieveMaxBonusLevel = AdvancedConfig.getInstance().getRetrieveMaxBonusLevel();
     public static double retrieveMaxChance     = AdvancedConfig.getInstance().getRetrieveChanceMax();
@@ -31,11 +29,11 @@ public class Archery {
     public static final double DISTANCE_XP_MULTIPLIER = 0.025;
 
     protected static void incrementTrackerValue(LivingEntity livingEntity) {
-        for (TrackedEntity trackedEntity : trackedEntities) {
-            if (trackedEntity.getLivingEntity().getEntityId() == livingEntity.getEntityId()) {
-                trackedEntity.incrementArrowCount();
-                return;
-            }
+        TrackedEntity trackedEntity = trackedEntities.get(livingEntity.getUniqueId());
+
+        if (trackedEntity != null) {
+            trackedEntity.incrementArrowCount();
+            return;
         }
 
         addToTracker(livingEntity); // If the entity isn't tracked yet
@@ -45,11 +43,11 @@ public class Archery {
         TrackedEntity trackedEntity = new TrackedEntity(livingEntity);
 
         trackedEntity.incrementArrowCount();
-        trackedEntities.add(trackedEntity);
+        trackedEntities.put(livingEntity.getUniqueId(), trackedEntity);
     }
 
-    protected static void removeFromTracker(TrackedEntity trackedEntity) {
-        trackedEntities.remove(trackedEntity);
+    protected static void removeFromTracker(UUID id) {
+        trackedEntities.remove(id);
     }
 
     /**
@@ -58,24 +56,14 @@ public class Archery {
      * @param livingEntity The entity hit by the arrows
      */
     public static void arrowRetrievalCheck(LivingEntity livingEntity) {
-        for (Iterator<TrackedEntity> entityIterator = trackedEntities.iterator(); entityIterator.hasNext();) {
-            TrackedEntity trackedEntity = entityIterator.next();
+        UUID id = livingEntity.getUniqueId();
+        TrackedEntity trackedEntity = trackedEntities.get(id);
 
-            if (trackedEntity.getID() == livingEntity.getUniqueId()) {
-                Misc.dropItems(livingEntity.getLocation(), new ItemStack(Material.ARROW), trackedEntity.getArrowCount());
-                entityIterator.remove();
-                return;
-            }
+        if (trackedEntity == null) {
+            return;
         }
-    }
 
-    public static Location stringToLocation(String location) {
-        String[] values = location.split(",");
-
-        return new Location(mcMMO.p.getServer().getWorld(values[0]), Double.parseDouble(values[1]), Double.parseDouble(values[2]), Double.parseDouble(values[3]), Float.parseFloat(values[4]), Float.parseFloat(values[5]));
-    }
-
-    public static String locationToString(Location location) {
-        return location.getWorld().getName() + "," + location.getX() + "," + location.getY() + "," + location.getZ() + "," + location.getYaw() + "," + location.getPitch();
+        Misc.dropItems(livingEntity.getLocation(), new ItemStack(Material.ARROW), trackedEntity.getArrowCount());
+        removeFromTracker(id);
     }
 }

src/main/java/com/gmail/nossr50/skills/archery/ArcheryManager.java

@@ -5,19 +5,19 @@ import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.archery.McMMOPlayerDazeEvent;
+import com.gmail.nossr50.events.skills.archery.McMMOPlayerSkillShotEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
-import com.gmail.nossr50.util.skills.CombatUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class ArcheryManager extends SkillManager {
@@ -25,26 +25,14 @@ public class ArcheryManager extends SkillManager {
         super(mcMMOPlayer, SkillType.ARCHERY);
     }
 
-    public boolean canDaze(LivingEntity target) {
-        return target instanceof Player && Permissions.daze(getPlayer());
-    }
-
-    public boolean canSkillShot() {
-        return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.bonusDamage(getPlayer(), skill);
-    }
-
-    public boolean canTrackArrows() {
-        return Permissions.arrowRetrieval(getPlayer());
-    }
-
     /**
      * Calculate bonus XP awarded for Archery when hitting a far-away target.
      *
      * @param target The {@link LivingEntity} damaged by the arrow
      * @param damager The {@link Entity} who shot the arrow
      */
-    public void distanceXpBonus(LivingEntity target, Entity damager) {
-        Location firedLocation = Archery.stringToLocation(damager.getMetadata(mcMMO.arrowDistanceKey).get(0).asString());
+    public void awardDistanceXpBonus(LivingEntity target, Entity damager) {
+        Location firedLocation = (Location) damager.getMetadata(mcMMO.arrowDistanceKey).get(0).value();
         Location targetLocation = target.getLocation();
 
         if (firedLocation.getWorld() != targetLocation.getWorld()) {
@@ -58,39 +46,52 @@ public class ArcheryManager extends SkillManager {
      * Track arrows fired for later retrieval.
      *
      * @param target The {@link LivingEntity} damaged by the arrow
+     * @param arrow The {@link Arrow} that damaged the target
      */
-    public void trackArrows(LivingEntity target) {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.retrieveMaxChance, Archery.retrieveMaxBonusLevel)) {
-            Archery.incrementTrackerValue(target);
+    public void trackArrow(LivingEntity target, Arrow arrow) {
+        if (!canTrackArrows(target, arrow)) {
+            return;
         }
+
+        Archery.incrementTrackerValue(target);
     }
 
     /**
      * Handle the effects of the Daze ability
      *
-     * @param defender The {@link Player} being affected by the ability
+     * @param target The {@link LivingEntity} being affected by the ability
      * @param arrow The {@link Arrow} that was fired
      */
-    public double daze(Player defender, Arrow arrow) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.dazeMaxBonus, Archery.dazeMaxBonusLevel)) {
+    public double daze(LivingEntity target, Arrow arrow) {
+        if (!canDaze(target)) {
             return 0;
         }
 
+        Player attacker = getPlayer();
+
+        McMMOPlayerDazeEvent event = new McMMOPlayerDazeEvent(attacker, arrow, target);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return 0;
+        }
+
+        Player defender = (Player) target;
         Location dazedLocation = defender.getLocation();
         dazedLocation.setPitch(90 - Misc.getRandom().nextInt(181));
 
         defender.teleport(dazedLocation);
-        defender.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, 20 * 10, 10));
+        defender.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, Misc.TICK_CONVERSION_FACTOR * 10, 10));
 
         if (UserManager.getPlayer(defender).useChatNotifications()) {
             defender.sendMessage(LocaleLoader.getString("Combat.TouchedFuzzy"));
         }
 
         if (mcMMOPlayer.useChatNotifications()) {
-            getPlayer().sendMessage(LocaleLoader.getString("Combat.TargetDazed"));
+            attacker.sendMessage(LocaleLoader.getString("Combat.TargetDazed"));
         }
 
-        return CombatUtils.callFakeDamageEvent(arrow, defender, DamageCause.PROJECTILE, Archery.dazeModifier);
+        return event.getDamage();
     }
 
     /**
@@ -101,9 +102,36 @@ public class ArcheryManager extends SkillManager {
      * @param arrow The {@link Arrow} that was fired
      */
     public double skillShot(LivingEntity target, double damage, Arrow arrow) {
+        if (!canUseSkillShot(target)) {
+            return 0;
+        }
+
+        McMMOPlayerSkillShotEvent event = new McMMOPlayerSkillShotEvent(getPlayer(), arrow, target, calculateSkillShotBonus(damage));
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return 0;
+        }
+
+        return event.getDamage();
+    }
+
+    private double calculateSkillShotBonus(double damage) {
         double damageBonusPercent = Math.min(((getSkillLevel() / Archery.skillShotIncreaseLevel) * Archery.skillShotIncreasePercentage), Archery.skillShotMaxBonusPercentage);
         double archeryBonus = Math.min(damage * damageBonusPercent, Archery.skillShotMaxBonusDamage);
 
-        return CombatUtils.callFakeDamageEvent(arrow, target, DamageCause.PROJECTILE, archeryBonus);
+        return archeryBonus;
+    }
+
+    private boolean canDaze(LivingEntity target) {
+        return target.isValid() && target instanceof Player && Permissions.daze(getPlayer()) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.dazeMaxBonus, Archery.dazeMaxBonusLevel);
+    }
+
+    private boolean canUseSkillShot(LivingEntity target) {
+        return target.isValid() && getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.bonusDamage(getPlayer(), skill);
+    }
+
+    private boolean canTrackArrows(LivingEntity target, Arrow arrow) {
+        return target.isValid() && Permissions.arrowRetrieval(getPlayer()) && !arrow.hasMetadata(mcMMO.infiniteArrowKey) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.retrieveMaxChance, Archery.retrieveMaxBonusLevel);
     }
 }

src/main/java/com/gmail/nossr50/skills/archery/TrackedEntity.java

@@ -22,15 +22,11 @@ public class TrackedEntity extends BukkitRunnable {
     @Override
     public void run() {
         if (!livingEntity.isValid()) {
-            Archery.removeFromTracker(this);
+            Archery.removeFromTracker(id);
             this.cancel();
         }
     }
 
-    protected LivingEntity getLivingEntity() {
-        return livingEntity;
-    }
-
     protected UUID getID() {
         return id;
     }

src/main/java/com/gmail/nossr50/skills/axes/AxesManager.java

@@ -4,10 +4,13 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
-import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.datatypes.skills.ToolType;
+import com.gmail.nossr50.events.skills.axes.McMMOPlayerAxeMasteryEvent;
+import com.gmail.nossr50.events.skills.axes.McMMOPlayerCriticalHitEvent;
+import com.gmail.nossr50.events.skills.axes.McMMOPlayerGreaterImpactEvent;
+import com.gmail.nossr50.events.skills.axes.McMMOPlayerImpactEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.ItemUtils;
@@ -23,39 +26,24 @@ public class AxesManager extends SkillManager {
         super(mcMMOPlayer, SkillType.AXES);
     }
 
-    public boolean canUseAxeMastery() {
-        return Permissions.bonusDamage(getPlayer(), skill);
-    }
-
-    public boolean canCriticalHit(LivingEntity target) {
-        return target.isValid() && Permissions.criticalStrikes(getPlayer());
-    }
-
-    public boolean canImpact(LivingEntity target) {
-        return target.isValid() && Permissions.armorImpact(getPlayer()) && Axes.hasArmor(target);
-    }
-
-    public boolean canGreaterImpact(LivingEntity target) {
-        return target.isValid() && Permissions.greaterImpact(getPlayer()) && !Axes.hasArmor(target);
-    }
-
-    public boolean canUseSkullSplitter(LivingEntity target) {
-        return target.isValid() && mcMMOPlayer.getAbilityMode(AbilityType.SKULL_SPLITTER) && Permissions.skullSplitter(getPlayer());
-    }
-
-    public boolean canActivateAbility() {
-        return mcMMOPlayer.getToolPreparationMode(ToolType.AXE) && Permissions.skullSplitter(getPlayer());
-    }
-
     /**
      * Handle the effects of the Axe Mastery ability
      *
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double axeMastery(LivingEntity target) {
-        double axeBonus = Math.min(getSkillLevel() / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
+        if (!canUseAxeMastery(target)) {
+            return 0;
+        }
 
-        return CombatUtils.callFakeDamageEvent(getPlayer(), target, axeBonus);
+        McMMOPlayerAxeMasteryEvent event = new McMMOPlayerAxeMasteryEvent(getPlayer(), target, calculateAxeMasteryBonus());
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return 0;
+        }
+
+        return event.getDamage();
     }
 
     /**
@@ -65,24 +53,27 @@ public class AxesManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      */
     public double criticalHit(LivingEntity target, double damage) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Axes.criticalHitMaxChance, Axes.criticalHitMaxBonusLevel)) {
+        if (!canCriticalHit(target)) {
             return 0;
         }
 
         Player player = getPlayer();
-
         player.sendMessage(LocaleLoader.getString("Axes.Combat.CriticalHit"));
 
-        if (target instanceof Player) {
+        boolean targetIsPlayer = target instanceof Player;
+
+        if (targetIsPlayer) {
             ((Player) target).sendMessage(LocaleLoader.getString("Axes.Combat.CritStruck"));
-
-            damage = (damage * Axes.criticalHitPVPModifier) - damage;
-        }
-        else {
-            damage = (damage * Axes.criticalHitPVEModifier) - damage;
         }
 
-        return CombatUtils.callFakeDamageEvent(player, target, damage);
+        McMMOPlayerCriticalHitEvent event = new McMMOPlayerCriticalHitEvent(player, target, calculateCriticalHitBonus(damage, targetIsPlayer));
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return 0;
+        }
+
+        return event.getDamage();
     }
 
     /**
@@ -90,12 +81,25 @@ public class AxesManager extends SkillManager {
      *
      * @param target The {@link LivingEntity} being affected by Impact
      */
-    public void impactCheck(LivingEntity target) {
+    public void impact(LivingEntity target) {
+        if (!canImpact(target)) {
+            return;
+        }
+
+        Player player = getPlayer();
         int durabilityDamage = 1 + (getSkillLevel() / Axes.impactIncreaseLevel);
+        McMMOPlayerImpactEvent event;
 
         for (ItemStack armor : target.getEquipment().getArmorContents()) {
             if (ItemUtils.isArmor(armor) && Axes.impactChance > Misc.getRandom().nextInt(getActivationChance())) {
                 SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
+
+                event = new McMMOPlayerImpactEvent(player, armor);
+                mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+                if (event.isCancelled()) {
+                    continue;
+                }
             }
         }
     }
@@ -106,14 +110,21 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double greaterImpact(LivingEntity target) {
-        if (!(Axes.greaterImpactChance > Misc.getRandom().nextInt(getActivationChance()))) {
+        if (!canUseGreaterImpact(target)) {
             return 0;
         }
 
         Player player = getPlayer();
 
+        McMMOPlayerGreaterImpactEvent event = new McMMOPlayerGreaterImpactEvent(player, target, Axes.greaterImpactBonusDamage, player.getLocation().getDirection().normalize().multiply(Axes.greaterImpactKnockbackMultiplier));
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return 0;
+        }
+
         ParticleEffectUtils.playGreaterImpactEffect(target);
-        target.setVelocity(player.getLocation().getDirection().normalize().multiply(Axes.greaterImpactKnockbackMultiplier));
+        target.setVelocity(event.getKnockbackVelocity());
 
         if (mcMMOPlayer.useChatNotifications()) {
             player.sendMessage(LocaleLoader.getString("Axes.Combat.GI.Proc"));
@@ -127,7 +138,7 @@ public class AxesManager extends SkillManager {
             }
         }
 
-        return CombatUtils.callFakeDamageEvent(player, target, Axes.greaterImpactBonusDamage);
+        return event.getDamage();
     }
 
     /**
@@ -136,7 +147,31 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      * @param damage The amount of damage initially dealt by the event
      */
-    public void skullSplitterCheck(LivingEntity target, double damage) {
+    public void skullSplitter(LivingEntity target, double damage) {
         CombatUtils.applyAbilityAoE(getPlayer(), target, damage / Axes.skullSplitterModifier, skill);
     }
+
+    private double calculateAxeMasteryBonus() {
+        return Math.min(getSkillLevel() / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
+    }
+
+    private double calculateCriticalHitBonus(double damage, boolean isPlayer) {
+        return (damage * (isPlayer ? Axes.criticalHitPVPModifier : Axes.criticalHitPVEModifier)) - damage;
+    }
+
+    private boolean canUseAxeMastery(LivingEntity target) {
+        return target.isValid() && Permissions.bonusDamage(getPlayer(), skill);
+    }
+
+    private boolean canCriticalHit(LivingEntity target) {
+        return target.isValid() && Permissions.criticalStrikes(getPlayer()) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Axes.criticalHitMaxChance, Axes.criticalHitMaxBonusLevel);
+    }
+
+    private boolean canImpact(LivingEntity target) {
+        return target.isValid() && Axes.hasArmor(target) && Permissions.armorImpact(getPlayer());
+    }
+
+    private boolean canUseGreaterImpact(LivingEntity target) {
+        return target.isValid() && !Axes.hasArmor(target) && Permissions.greaterImpact(getPlayer()) && (Axes.greaterImpactChance > Misc.getRandom().nextInt(getActivationChance()));
+    }
 }

src/main/java/com/gmail/nossr50/skills/excavation/ExcavationManager.java

@@ -3,12 +3,16 @@ package com.gmail.nossr50.skills.excavation;
 import java.util.List;
 
 import org.bukkit.Location;
+import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
+import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
+import com.gmail.nossr50.events.skills.excavation.McMMOPlayerExcavationTreasureEvent;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
@@ -24,7 +28,7 @@ public class ExcavationManager extends SkillManager {
      *
      * @param blockState The {@link BlockState} to check ability activation for
      */
-    public void excavationBlockCheck(BlockState blockState) {
+    public void blockBreak(BlockState blockState) {
         int xp = Excavation.getBlockXP(blockState);
 
         if (Permissions.excavationTreasureHunter(getPlayer())) {
@@ -34,10 +38,20 @@ public class ExcavationManager extends SkillManager {
                 int skillLevel = getSkillLevel();
                 Location location = blockState.getLocation();
 
+                Player player = getPlayer();
+                Block block = blockState.getBlock();
+
                 for (ExcavationTreasure treasure : treasures) {
                     if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(treasure.getDropChance(), activationChance)) {
-                        xp += treasure.getXp();
-                        Misc.dropItem(location, treasure.getDrop());
+                        McMMOPlayerExcavationTreasureEvent event = new McMMOPlayerExcavationTreasureEvent(player, treasure.getDrop(), treasure.getXp(), block);
+                        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+                        if (event.isCancelled()) {
+                            continue;
+                        }
+
+                        xp += event.getXpGained();
+                        Misc.dropItem(location, event.getTreasure());
                     }
                 }
             }
@@ -52,8 +66,8 @@ public class ExcavationManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      */
     public void gigaDrillBreaker(BlockState blockState) {
-        excavationBlockCheck(blockState);
-        excavationBlockCheck(blockState);
+        blockBreak(blockState);
+        blockBreak(blockState);
 
         SkillUtils.handleDurabilityChange(getPlayer().getItemInHand(), Config.getInstance().getAbilityToolDamage());
     }

src/main/java/com/gmail/nossr50/skills/fishing/FishingManager.java

@@ -73,14 +73,6 @@ public class FishingManager extends SkillManager {
         super(mcMMOPlayer, SkillType.FISHING);
     }
 
-    public boolean canShake(Entity target) {
-        return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.shake(getPlayer());
-    }
-
-    public boolean canMasterAngler() {
-        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.masterAngler(getPlayer());
-    }
-
     public boolean unleashTheKraken() {
         return unleashTheKraken(true);
     }
@@ -161,11 +153,13 @@ public class FishingManager extends SkillManager {
     }
 
     public boolean exploitPrevention() {
-        if (!AdvancedConfig.getInstance().getKrakenEnabled()) {
+        Player player = getPlayer();
+
+        if (Permissions.krakenBypass(player) || !AdvancedConfig.getInstance().getKrakenEnabled()) {
             return false;
         }
 
-        Block targetBlock = getPlayer().getTargetBlock(BlockUtils.getTransparentBlocks(), 100);
+        Block targetBlock = player.getTargetBlock(BlockUtils.getTransparentBlocks(), 100);
 
         if (!targetBlock.isLiquid()) {
             return false;
@@ -186,66 +180,6 @@ public class FishingManager extends SkillManager {
         return unleashTheKraken(false);
     }
 
-    public boolean canIceFish(Block block) {
-        if (getSkillLevel() < AdvancedConfig.getInstance().getIceFishingUnlockLevel()) {
-            return false;
-        }
-
-        if (block.getType() != Material.ICE) {
-            return false;
-        }
-
-        // Make sure this is a body of water, not just a block of ice.
-        Biome biome = block.getBiome();
-        boolean isFrozenBiome = (biome == Biome.FROZEN_OCEAN || biome == Biome.FROZEN_RIVER || biome == Biome.TAIGA || biome == Biome.TAIGA_HILLS || biome == Biome.ICE_PLAINS || biome == Biome.ICE_MOUNTAINS);
-
-        if (!isFrozenBiome && (block.getRelative(BlockFace.DOWN, 3).getType() != Material.STATIONARY_WATER)) {
-            return false;
-        }
-
-        Player player = getPlayer();
-
-        if (!Permissions.iceFishing(player)) {
-            return false;
-        }
-
-        return EventUtils.simulateBlockBreak(block, player, false);
-    }
-
-    /**
-     * Gets the loot tier
-     *
-     * @return the loot tier
-     */
-    public int getLootTier() {
-        int skillLevel = getSkillLevel();
-
-        for (Tier tier : Tier.values()) {
-            if (skillLevel >= tier.getLevel()) {
-                return tier.toNumerical();
-            }
-        }
-
-        return 0;
-    }
-
-    /**
-     * Gets the Shake Mob probability
-     *
-     * @return Shake Mob probability
-     */
-    public double getShakeProbability() {
-        int skillLevel = getSkillLevel();
-
-        for (Tier tier : Tier.values()) {
-            if (skillLevel >= tier.getLevel()) {
-                return tier.getShakeChance();
-            }
-        }
-
-        return 0.0;
-    }
-
     /**
      * Handle the Fisherman's Diet ability
      *
@@ -254,29 +188,35 @@ public class FishingManager extends SkillManager {
      *
      * @return the modified change in hunger for the event
      */
-    public int handleFishermanDiet(int rankChange, int eventFoodLevel) {
+    public int fishermansDiet(int rankChange, int eventFoodLevel) {
         return SkillUtils.handleFoodSkills(getPlayer(), skill, eventFoodLevel, Fishing.fishermansDietRankLevel1, Fishing.fishermansDietMaxLevel, rankChange);
     }
 
-    public void iceFishing(Fish hook, Block block) {
+    public boolean iceFishing(Fish hook, Block block) {
+        if (!canIceFish(block)) {
+            return false;
+        }
+
         // Make a hole
         block.setType(Material.STATIONARY_WATER);
 
-        for (int x = -1; x <= 1; x++) {
-            for (int z = -1; z <= 1; z++) {
-                Block relative = block.getRelative(x, 0, z);
+        for (BlockFace face : BlockFace.values()) {
+            Block relative = block.getRelative(face);
 
-                if (relative.getType() == Material.ICE) {
-                    relative.setType(Material.STATIONARY_WATER);
-                }
+            if (relative.getType() == Material.ICE) {
+                relative.setType(Material.STATIONARY_WATER);
             }
         }
 
         // Recast in the new spot
-        EventUtils.callFakeFishEvent(getPlayer(), hook);
+        return !EventUtils.callFakeFishEvent(getPlayer(), hook).isCancelled();
     }
 
     public void masterAngler(Fish hook) {
+        if (!canUseMasterAngler()) {
+            return;
+        }
+
         Player player = getPlayer();
         Location location = hook.getLocation();
         Biome biome = location.getBlock().getBiome();
@@ -325,7 +265,7 @@ public class FishingManager extends SkillManager {
 
             if (!event.isCancelled()) {
                 treasureDrop = event.getTreasure();
-                treasureXp = event.getXp();
+                treasureXp = event.getXpGained();
             }
             else {
                 treasureDrop = null;
@@ -357,10 +297,10 @@ public class FishingManager extends SkillManager {
      *
      * @param experience The amount of experience initially awarded by the event
      *
-     * @return the modified event damage
+     * @return the modified event experience
      */
-    public int handleVanillaXpBoost(int experience) {
-        return experience * getVanillaXpMultiplier();
+    public int vanillaXpBoost(int experience) {
+        return experience * (Permissions.vanillaXpBoost(getPlayer(), skill) ? getVanillaXpMultiplier() : 1);
     }
 
     public Location getHookLocation() {
@@ -370,73 +310,101 @@ public class FishingManager extends SkillManager {
     /**
      * Handle the Shake ability
      *
-     * @param target The {@link LivingEntity} affected by the ability
+     * @param entity The {@link Entity} affected by the ability
      */
-    public void shakeCheck(LivingEntity target) {
+    public void shake(Fish hook, Entity entity) {
+        if (!canShake(entity)) {
+            return;
+        }
+
         fishingTries--; // Because autoclicking to shake is OK.
 
-        if (getShakeProbability() > Misc.getRandom().nextInt(getActivationChance())) {
-            List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);
+        LivingEntity target = (LivingEntity) entity;
+        List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);
 
-            if (possibleDrops == null || possibleDrops.isEmpty()) {
-                return;
-            }
-
-            ItemStack drop = Fishing.chooseDrop(possibleDrops);
-
-            // It's possible that chooseDrop returns null if the sum of probability in possibleDrops is inferior than 100
-            if (drop == null) {
-                return;
-            }
-
-            // Extra processing depending on the mob and drop type
-            switch (target.getType()) {
-                case SHEEP:
-                    Sheep sheep = (Sheep) target;
-
-                    if (drop.getType() == Material.WOOL) {
-                        if (sheep.isSheared()) {
-                            return;
-                        }
-
-                        drop = new Wool(sheep.getColor()).toItemStack(drop.getAmount());
-                        sheep.setSheared(true);
-                    }
-                    break;
-
-                case SKELETON:
-                    if (((Skeleton) target).getSkeletonType() == SkeletonType.WITHER) {
-                        switch (drop.getType()) {
-                            case SKULL_ITEM:
-                                drop.setDurability((short) 1);
-                                break;
-
-                            case ARROW:
-                                drop.setType(Material.COAL);
-                                break;
-
-                            default:
-                                break;
-                        }
-                    }
-                    break;
-
-                default:
-                    break;
-            }
-
-            McMMOPlayerShakeEvent event = new McMMOPlayerShakeEvent(getPlayer(), drop);
-
-            drop = event.getDrop();
-
-            if (event.isCancelled() || drop == null) {
-                return;
-            }
-
-            Misc.dropItem(target.getLocation(), drop);
-            CombatUtils.dealDamage(target, Math.max(target.getMaxHealth() / 4, 1)); // Make it so you can shake a mob no more than 4 times.
-            applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP());
+        if (possibleDrops == null || possibleDrops.isEmpty()) {
+            return;
         }
+
+        ItemStack drop = Fishing.chooseDrop(possibleDrops);
+
+        // It's possible that chooseDrop returns null if the sum of probability in possibleDrops is inferior than 100
+        if (drop == null) {
+            return;
+        }
+
+        // Extra processing depending on the mob and drop type
+        switch (target.getType()) {
+            case SHEEP:
+                Sheep sheep = (Sheep) target;
+                drop = new Wool(sheep.getColor()).toItemStack(drop.getAmount());
+                sheep.setSheared(true);
+
+            case SKELETON:
+                if (((Skeleton) target).getSkeletonType() == SkeletonType.WITHER) {
+                    switch (drop.getType()) {
+                        case SKULL_ITEM:
+                            drop.setDurability((short) 1);
+                            break;
+
+                        case ARROW:
+                            drop.setType(Material.COAL);
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+                break;
+
+            default:
+                break;
+        }
+
+        McMMOPlayerShakeEvent event = new McMMOPlayerShakeEvent(getPlayer(), hook, drop, target, Math.max(target.getMaxHealth() / 4, 1)); // TODO: Config option for shake damage
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+
+        Misc.dropItem(target.getLocation(), event.getDrop());
+        CombatUtils.dealDamage(target, event.getDamage());
+        applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP());
+    }
+
+    /**
+     * Gets the loot tier
+     *
+     * @return the loot tier
+     */
+    public int getLootTier() {
+        int skillLevel = getSkillLevel();
+
+        for (Tier tier : Tier.values()) {
+            if (skillLevel >= tier.getLevel()) {
+                return tier.toNumerical();
+            }
+        }
+
+        return 0;
+    }
+
+    /**
+     * Gets the Shake Mob probability
+     *
+     * @return Shake Mob probability
+     */
+    public double getShakeProbability() {
+        int skillLevel = getSkillLevel();
+
+        for (Tier tier : Tier.values()) {
+            if (skillLevel >= tier.getLevel()) {
+                return tier.getShakeChance();
+            }
+        }
+
+        return 0.0;
     }
 
     /**
@@ -616,4 +584,34 @@ public class FishingManager extends SkillManager {
 
         return 0;
     }
+
+    private boolean canShake(Entity target) {
+        return target.isValid() && target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.shake(getPlayer()) && getShakeProbability() > Misc.getRandom().nextInt(getActivationChance());
+    }
+
+    private boolean canUseMasterAngler() {
+        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.masterAngler(getPlayer());
+    }
+
+    private boolean canIceFish(Block block) {
+        if (getSkillLevel() < AdvancedConfig.getInstance().getIceFishingUnlockLevel() || block.getType() != Material.ICE) {
+            return false;
+        }
+
+        // Make sure this is a body of water, not just a block of ice.
+        Biome biome = block.getBiome();
+        boolean isFrozenBiome = (biome == Biome.FROZEN_OCEAN || biome == Biome.FROZEN_RIVER || biome == Biome.TAIGA || biome == Biome.TAIGA_HILLS || biome == Biome.ICE_PLAINS || biome == Biome.ICE_MOUNTAINS);
+
+        if (!isFrozenBiome || (block.getRelative(BlockFace.DOWN, 3).getType() != Material.STATIONARY_WATER)) {
+            return false;
+        }
+
+        Player player = getPlayer();
+
+        if (!Permissions.iceFishing(player)) {
+            return false;
+        }
+
+        return EventUtils.simulateBlockBreak(block, player, false);
+    }
 }

src/main/java/com/gmail/nossr50/skills/herbalism/HerbalismManager.java

@@ -92,7 +92,7 @@ public class HerbalismManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      * @return true if the ability was successful, false otherwise
      */
-    public boolean processGreenTerra(BlockState blockState) {
+    public boolean greenTerra(BlockState blockState) {
         Player player = getPlayer();
 
         if (!Permissions.greenThumbBlock(player, blockState.getType())) {
@@ -100,34 +100,29 @@ public class HerbalismManager extends SkillManager {
         }
 
         PlayerInventory playerInventory = player.getInventory();
-        ItemStack seed = new ItemStack(Material.SEEDS);
 
-        if (!playerInventory.containsAtLeast(seed, 1)) {
+        if (!playerInventory.contains(Material.SEEDS)) {
             player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTe.NeedMore"));
             return false;
         }
 
-        playerInventory.removeItem(seed);
-        player.updateInventory(); // Needed until replacement available
+        playerInventory.removeItem(new ItemStack(Material.SEEDS));
+        player.updateInventory();
 
         return Herbalism.convertGreenTerraBlocks(blockState);
     }
 
     /**
-     * 
+     * Process double drops & XP gain for Herbalism.
      *
      * @param blockState The {@link BlockState} to check ability activation for
      */
-    public void herbalismBlockCheck(BlockState blockState) {
+    public void blockBreak(BlockState blockState) {
         Player player = getPlayer();
         Material material = blockState.getType();
         boolean oneBlockPlant = !(material == Material.CACTUS || material == Material.SUGAR_CANE_BLOCK);
 
-        if (oneBlockPlant && mcMMO.getPlaceStore().isTrue(blockState)) {
-            return;
-        }
-
-        if (!canBlockCheck()) {
+        if (!canBlockCheck() || (oneBlockPlant && mcMMO.getPlaceStore().isTrue(blockState))) {
             return;
         }
 
@@ -182,7 +177,14 @@ public class HerbalismManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      * @return true if the ability was successful, false otherwise
      */
-    public boolean processGreenThumbBlocks(BlockState blockState) {
+    public boolean greenThumbBlocks(BlockState blockState) {
+        if (!canGreenThumbBlock(blockState)) {
+            return false;
+        }
+
+        ItemStack heldItem = getPlayer().getItemInHand();
+        heldItem.setAmount(heldItem.getAmount() - 1);
+
         if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) {
             getPlayer().sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Fail"));
             return false;
@@ -283,43 +285,35 @@ public class HerbalismManager extends SkillManager {
     private void processGreenThumbPlants(BlockState blockState, boolean greenTerra) {
         Player player = getPlayer();
         PlayerInventory playerInventory = player.getInventory();
-        ItemStack seed = null;
+        Material seed = null;
 
         switch (blockState.getType()) {
             case CARROT:
-                seed = new ItemStack(Material.CARROT_ITEM);
+                seed = Material.CARROT_ITEM;
                 break;
 
             case CROPS:
-                seed = new ItemStack(Material.SEEDS);
+                seed = Material.SEEDS;
                 break;
 
             case NETHER_WARTS:
-                seed = new ItemStack(Material.NETHER_STALK);
+                seed = Material.NETHER_STALK;
                 break;
 
             case POTATO:
-                seed = new ItemStack(Material.POTATO_ITEM);
+                seed = Material.POTATO_ITEM;
                 break;
 
             default:
                 break;
         }
 
-        if (!playerInventory.containsAtLeast(seed, 1)) {
+        if (!playerInventory.contains(seed) || (!greenTerra && !SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) || !handleBlockState(blockState, greenTerra)) {
             return;
         }
 
-        if (!greenTerra && !SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) {
-            return;
-        }
-
-        if (!handleBlockState(blockState, greenTerra)) {
-            return;
-        }
-
-        playerInventory.removeItem(seed);
-        player.updateInventory(); // Needed until replacement available
+        playerInventory.removeItem(new ItemStack(seed));
+        player.updateInventory();
         new HerbalismBlockUpdaterTask(blockState).runTaskLater(mcMMO.p, 0);
     }
 

src/main/java/com/gmail/nossr50/skills/repair/RepairManager.java

@@ -167,7 +167,7 @@ public class RepairManager extends SkillManager {
         }
 
         if (item.getDurability() == 0) {
-            player.setItemInHand(new ItemStack(Material.AIR));
+            player.setItemInHand(null);
             location.setY(location.getY() + 1);
 
             Misc.dropItems(location, new ItemStack(Repair.getRepairAndSalvageItem(item)), Repair.getRepairAndSalvageQuantities(item) * item.getAmount());

src/main/java/com/gmail/nossr50/skills/swords/SwordsManager.java

@@ -5,9 +5,7 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
-import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -21,10 +19,6 @@ public class SwordsManager extends SkillManager {
         super(mcMMOPlayer, SkillType.SWORDS);
     }
 
-    public boolean canActivateAbility() {
-        return mcMMOPlayer.getToolPreparationMode(ToolType.SWORD) && Permissions.serratedStrikes(getPlayer());
-    }
-
     public boolean canUseBleed() {
         return Permissions.bleed(getPlayer());
     }
@@ -33,10 +27,6 @@ public class SwordsManager extends SkillManager {
         return target instanceof LivingEntity && Permissions.counterAttack(getPlayer());
     }
 
-    public boolean canUseSerratedStrike() {
-        return mcMMOPlayer.getAbilityMode(AbilityType.SERRATED_STRIKES) && Permissions.serratedStrikes(getPlayer());
-    }
-
     /**
      * Check for Bleed effect.
      *

src/main/java/com/gmail/nossr50/skills/taming/TamingManager.java

@@ -255,7 +255,7 @@ public class TamingManager extends SkillManager {
             }
         }
 
-        player.setItemInHand(new ItemStack(heldItem.getType(), heldItemAmount - summonAmount));
+        heldItem.setAmount(heldItemAmount - summonAmount);
         player.sendMessage(LocaleLoader.getString("Taming.Summon.Complete"));
     }
 

src/main/java/com/gmail/nossr50/skills/unarmed/Unarmed.java

@@ -80,7 +80,8 @@ public class Unarmed {
 
                 nextSlot++;
             }
-        } else if (firstEmpty != -1) {
+        }
+        else if (firstEmpty != -1) {
             drop.remove();
             dropStack.setAmount(dropAmount);
             inventory.setItem(firstEmpty, dropStack);

src/main/java/com/gmail/nossr50/skills/unarmed/UnarmedManager.java

@@ -4,17 +4,18 @@ import org.bukkit.Material;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
 import org.bukkit.material.MaterialData;
 import org.bukkit.material.SmoothBrick;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.skills.ToolType;
+import com.gmail.nossr50.events.skills.unarmed.McMMOPlayerDeflectEvent;
+import com.gmail.nossr50.events.skills.unarmed.McMMOPlayerDisarmEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
-import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.skills.CombatUtils;
@@ -37,14 +38,20 @@ public class UnarmedManager extends SkillManager {
         return mcMMOPlayer.getAbilityMode(AbilityType.BERSERK) && Permissions.berserk(getPlayer());
     }
 
-    public boolean canDisarm(LivingEntity target) {
-        return target instanceof Player && ((Player) target).getItemInHand().getType() != Material.AIR && Permissions.disarm(getPlayer());
+    private boolean canDisarm(LivingEntity target) {
+        if (target instanceof Player) {
+            Player defender = (Player) target;
+
+            return defender.getItemInHand().getType() != Material.AIR && Permissions.disarm(getPlayer()) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.disarmMaxChance, Unarmed.disarmMaxBonusLevel) && !hasIronGrip(defender);
+        }
+
+        return false;
     }
 
-    public boolean canDeflect() {
+    private boolean canDeflect() {
         Player player = getPlayer();
 
-        return player.getItemInHand().getType() == Material.AIR && Permissions.arrowDeflect(player);
+        return skill.getPVPEnabled() && player.getItemInHand().getType() == Material.AIR && Permissions.arrowDeflect(player) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.deflectMaxChance, Unarmed.deflectMaxBonusLevel);
     }
 
     public boolean canUseBlockCracker() {
@@ -78,31 +85,47 @@ public class UnarmedManager extends SkillManager {
     /**
      * Check for disarm.
      *
-     * @param defender The defending player
+     * @param target The defending {@link LivingEntity}
      */
-    public void disarmCheck(Player defender) {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.disarmMaxChance, Unarmed.disarmMaxBonusLevel) && !hasIronGrip(defender)) {
-            if (EventUtils.callDisarmEvent(defender).isCancelled()) {
-                return;
-            }
-
-            Misc.dropItem(defender.getLocation(), defender.getItemInHand());
-
-            defender.setItemInHand(new ItemStack(Material.AIR));
-            defender.sendMessage(LocaleLoader.getString("Skills.Disarmed"));
+    public void disarm(LivingEntity target) {
+        if (!canDisarm(target)) {
+            return;
         }
+
+        Player defender = (Player) target;
+
+        McMMOPlayerDisarmEvent event = new McMMOPlayerDisarmEvent(getPlayer(), defender);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+
+        Misc.dropItem(defender.getLocation(), event.getDroppedItem());
+
+        defender.setItemInHand(null);
+        defender.sendMessage(LocaleLoader.getString("Skills.Disarmed"));
     }
 
     /**
      * Check for arrow deflection.
      */
-    public boolean deflectCheck() {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.deflectMaxChance, Unarmed.deflectMaxBonusLevel)) {
-            getPlayer().sendMessage(LocaleLoader.getString("Combat.ArrowDeflect"));
-            return true;
+    public boolean deflect() {
+        if (!canDeflect()) {
+            return false;
         }
 
-        return false;
+        Player player = getPlayer();
+
+        McMMOPlayerDeflectEvent event = new McMMOPlayerDeflectEvent(player);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return false;
+        }
+
+        player.sendMessage(LocaleLoader.getString("Combat.ArrowDeflect"));
+        return true;
     }
 
     /**

src/main/java/com/gmail/nossr50/util/ChimaeraWing.java

@@ -91,9 +91,8 @@ public final class ChimaeraWing {
 
         if (Config.getInstance().getChimaeraPreventUseUnderground()) {
             if (location.getY() < player.getWorld().getHighestBlockYAt(location)) {
-                player.setItemInHand(new ItemStack(getChimaeraWing(amount - Config.getInstance().getChimaeraUseCost())));
+                inHand.setAmount(amount - Config.getInstance().getChimaeraUseCost());
                 player.sendMessage(LocaleLoader.getString("Item.ChimaeraWing.Fail"));
-                player.updateInventory();
                 player.setVelocity(new Vector(0, 0.5D, 0));
                 CombatUtils.dealDamage(player, Misc.getRandom().nextInt((int) (player.getHealth() - 10)));
                 mcMMOPlayer.actualizeChimeraWingLastUse();
@@ -107,7 +106,7 @@ public final class ChimaeraWing {
 
         if (warmup > 0) {
             player.sendMessage(LocaleLoader.getString("Teleport.Commencing", warmup));
-            new ChimaeraWingWarmup(mcMMOPlayer).runTaskLater(mcMMO.p, 20 * warmup);
+            new ChimaeraWingWarmup(mcMMOPlayer).runTaskLater(mcMMO.p, Misc.TICK_CONVERSION_FACTOR * warmup);
         }
         else {
             chimaeraExecuteTeleport();
@@ -130,8 +129,8 @@ public final class ChimaeraWing {
             }
         }
 
-        player.setItemInHand(new ItemStack(getChimaeraWing(player.getItemInHand().getAmount() - Config.getInstance().getChimaeraUseCost())));
-        player.updateInventory();
+        ItemStack inHand = player.getItemInHand();
+        inHand.setAmount(inHand.getAmount() - Config.getInstance().getChimaeraUseCost());
         mcMMOPlayer.actualizeChimeraWingLastUse();
         mcMMOPlayer.setTeleportCommenceLocation(null);
 

src/main/java/com/gmail/nossr50/util/EventUtils.java

@@ -15,31 +15,48 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.experience.McMMOPlayerLevelChangeEvent;
-import com.gmail.nossr50.events.experience.McMMOPlayerLevelDownEvent;
-import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
-import com.gmail.nossr50.events.experience.McMMOPlayerXpGainEvent;
+import com.gmail.nossr50.events.abilities.McMMOPlayerAbilityActivateEvent;
+import com.gmail.nossr50.events.abilities.McMMOPlayerAbilityDeactivateEvent;
+import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelChangeEvent;
+import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelDownEvent;
+import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.events.experience.xp.McMMOPlayerXpChangeEvent;
+import com.gmail.nossr50.events.experience.xp.McMMOPlayerXpGainEvent;
+import com.gmail.nossr50.events.experience.xp.McMMOPlayerXpLossEvent;
 import com.gmail.nossr50.events.fake.FakeBlockBreakEvent;
 import com.gmail.nossr50.events.fake.FakeBlockDamageEvent;
 import com.gmail.nossr50.events.fake.FakePlayerAnimationEvent;
 import com.gmail.nossr50.events.fake.FakePlayerFishEvent;
 import com.gmail.nossr50.events.hardcore.McMMOPlayerDeathPenaltyEvent;
 import com.gmail.nossr50.events.party.McMMOPartyTeleportEvent;
-import com.gmail.nossr50.events.skills.abilities.McMMOPlayerAbilityActivateEvent;
-import com.gmail.nossr50.events.skills.abilities.McMMOPlayerAbilityDeactivateEvent;
 import com.gmail.nossr50.events.skills.fishing.McMMOPlayerFishingTreasureEvent;
 import com.gmail.nossr50.events.skills.fishing.McMMOPlayerMagicHunterEvent;
 import com.gmail.nossr50.events.skills.repair.McMMOPlayerRepairCheckEvent;
-import com.gmail.nossr50.events.skills.unarmed.McMMOPlayerDisarmEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.ParticleEffectUtils;
+import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class EventUtils {
-    public static McMMOPlayerAbilityActivateEvent callPlayerAbilityActivateEvent(Player player, SkillType skill) {
-        McMMOPlayerAbilityActivateEvent event = new McMMOPlayerAbilityActivateEvent(player, skill);
+    public static boolean handlePlayerAbilityActivateEvent(Player player, AbilityType ability) {
+        McMMOPlayerAbilityActivateEvent event = new McMMOPlayerAbilityActivateEvent(player, ability);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
-        return event;
+        boolean isCancelled = event.isCancelled();
+
+        if (!isCancelled) {
+            if (event.useParticleEffects()) {
+                ParticleEffectUtils.playAbilityEnabledEffect(player);
+            }
+
+            if (UserManager.getPlayer(player).useChatNotifications()) {
+                player.sendMessage(ability.getAbilityOn());
+            }
+
+            SkillUtils.sendSkillMessage(player, ability.getAbilityPlayer(player));
+        }
+
+        return !isCancelled;
     }
 
     public static FakePlayerAnimationEvent callFakeArmSwingEvent(Player player) {
@@ -108,24 +125,33 @@ public class EventUtils {
         mcMMOPlayer.getPartyTeleportRecord().actualizeLastUse();
     }
 
-    public static boolean handleXpGainEvent(Player player, SkillType skill, float xpGained) {
-        McMMOPlayerXpGainEvent event = new McMMOPlayerXpGainEvent(player, skill, xpGained);
+    public static boolean handleXpChangeEvent(Player player, SkillType skill, float xpChanged, boolean isXpGain) {
+        McMMOPlayerXpChangeEvent event = isXpGain ? new McMMOPlayerXpGainEvent(player, skill, xpChanged) : new McMMOPlayerXpLossEvent(player, skill, xpChanged);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
         boolean isCancelled = event.isCancelled();
 
         if (!isCancelled) {
-            UserManager.getPlayer(player).addXp(skill, event.getRawXpGained());
+            PlayerProfile profile = UserManager.getPlayer(player).getProfile();
+            profile.setSkillXpLevel(skill, profile.getSkillXpLevelRaw(skill) + (isXpGain ? ((McMMOPlayerXpGainEvent) event).getRawXpGained() : -((McMMOPlayerXpLossEvent) event).getRawXpLost()));
         }
 
         return !isCancelled;
     }
 
-    public static McMMOPlayerAbilityDeactivateEvent callAbilityDeactivateEvent(Player player, AbilityType ability) {
-        McMMOPlayerAbilityDeactivateEvent event = new McMMOPlayerAbilityDeactivateEvent(player, SkillType.byAbility(ability));
+    public static void handleAbilityDeactivateEvent(Player player, AbilityType ability) {
+        McMMOPlayerAbilityDeactivateEvent event = new McMMOPlayerAbilityDeactivateEvent(player, ability);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
-        return event;
+        if (event.useParticleEffects()) {
+            ParticleEffectUtils.playAbilityDisabledEffect(player);
+        }
+
+        if (UserManager.getPlayer(player).useChatNotifications()) {
+            player.sendMessage(ability.getAbilityOff());
+        }
+
+        SkillUtils.sendSkillMessage(player, ability.getAbilityPlayerOff(player));
     }
 
     public static McMMOPlayerFishingTreasureEvent callFishingTreasureEvent(Player player, ItemStack treasureDrop, int treasureXp, Map<Enchantment, Integer> enchants) {
@@ -155,11 +181,4 @@ public class EventUtils {
 
         return event;
     }
-
-    public static McMMOPlayerDisarmEvent callDisarmEvent(Player defender) {
-        McMMOPlayerDisarmEvent event = new McMMOPlayerDisarmEvent(defender);
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        return event;
-    }
 }

src/main/java/com/gmail/nossr50/util/HardcoreManager.java

@@ -35,8 +35,11 @@ public final class HardcoreManager {
 
             totalLevelsLost += levelsLost;
 
+            float xpRemoved = playerProfile.getSkillXpLevelRaw(skillType);
             playerProfile.modifySkill(skillType, playerSkillLevel - levelsLost);
             playerProfile.removeXp(skillType, xpLost);
+
+            EventUtils.handleLevelChangeEvent(player, skillType, levelsLost, xpLost + xpRemoved, false);
         }
 
         player.sendMessage(LocaleLoader.getString("Hardcore.DeathStatLoss.PlayerDeath", totalLevelsLost));
@@ -69,11 +72,17 @@ public final class HardcoreManager {
 
             totalLevelsStolen += levelsStolen;
 
+            float killerXpRemoved = killerProfile.getSkillXpLevelRaw(skillType);
             killerProfile.modifySkill(skillType, killerSkillLevel + levelsStolen);
-            killerProfile.addXp(skillType, xpStolen);
+            EventUtils.handleLevelChangeEvent(killer, skillType, levelsStolen, killerXpRemoved, true);
 
+            killerProfile.addXp(skillType, xpStolen);
+            EventUtils.handleXpChangeEvent(killer, skillType, xpStolen, true);
+
+            float victimXpRemoved = killerProfile.getSkillXpLevelRaw(skillType);
             victimProfile.modifySkill(skillType, victimSkillLevel - levelsStolen);
-            victimProfile.removeXp(skillType, xpStolen);
+            EventUtils.handleLevelChangeEvent(victim, skillType, levelsStolen, victimXpRemoved, false);
+            EventUtils.handleXpChangeEvent(killer, skillType, xpStolen, false);
         }
 
         if (totalLevelsStolen > 0) {

src/main/java/com/gmail/nossr50/util/Misc.java

@@ -174,7 +174,7 @@ public final class Misc {
      * @param itemStack The item to drop
      */
     public static void dropItem(Location location, ItemStack itemStack) {
-        if (itemStack.getType() == Material.AIR) {
+        if (itemStack == null || itemStack.getType() == Material.AIR) {
             return;
         }
 

src/main/java/com/gmail/nossr50/util/skills/CombatUtils.java

@@ -18,9 +18,9 @@ import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
 import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
@@ -28,7 +28,6 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.runnables.skills.AwardCombatXpTask;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
-import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
 import com.gmail.nossr50.skills.archery.ArcheryManager;
 import com.gmail.nossr50.skills.axes.AxesManager;
 import com.gmail.nossr50.skills.swords.Swords;
@@ -50,52 +49,34 @@ public final class CombatUtils {
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
         SwordsManager swordsManager = mcMMOPlayer.getSwordsManager();
 
-        if (swordsManager.canActivateAbility()) {
-            mcMMOPlayer.checkAbilityActivation(SkillType.SWORDS);
-        }
+        mcMMOPlayer.checkAbilityActivation(SkillType.SWORDS);
 
         if (swordsManager.canUseBleed()) {
             swordsManager.bleedCheck(target);
         }
 
-        if (swordsManager.canUseSerratedStrike()) {
-            swordsManager.serratedStrikes(target, damage);
-        }
+        swordsManager.serratedStrikes(target, damage);
 
         startGainXp(mcMMOPlayer, target, SkillType.SWORDS);
     }
 
     private static void processAxeCombat(LivingEntity target, Player player, EntityDamageByEntityEvent event) {
         double initialDamage = event.getDamage();
-        double finalDamage = initialDamage;
+        double bonusDamage = 0;
 
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
         AxesManager axesManager = mcMMOPlayer.getAxesManager();
 
-        if (axesManager.canActivateAbility()) {
-            mcMMOPlayer.checkAbilityActivation(SkillType.AXES);
-        }
+        mcMMOPlayer.checkAbilityActivation(SkillType.AXES);
 
-        if (axesManager.canUseAxeMastery()) {
-            finalDamage += axesManager.axeMastery(target);
-        }
+        bonusDamage += axesManager.axeMastery(target);
+        bonusDamage += axesManager.criticalHit(target, initialDamage);
+        bonusDamage += axesManager.greaterImpact(target);
 
-        if (axesManager.canCriticalHit(target)) {
-            finalDamage += axesManager.criticalHit(target, initialDamage);
-        }
+        axesManager.impact(target);
+        axesManager.skullSplitter(target, initialDamage);
 
-        if (axesManager.canImpact(target)) {
-            axesManager.impactCheck(target);
-        }
-        else if (axesManager.canGreaterImpact(target)) {
-            finalDamage += axesManager.greaterImpact(target);
-        }
-
-        if (axesManager.canUseSkullSplitter(target)) {
-            axesManager.skullSplitterCheck(target, initialDamage);
-        }
-
-        event.setDamage(finalDamage);
+        event.setDamage(initialDamage + bonusDamage);
         startGainXp(mcMMOPlayer, target, SkillType.AXES);
     }
 
@@ -106,9 +87,7 @@ public final class CombatUtils {
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
         UnarmedManager unarmedManager = mcMMOPlayer.getUnarmedManager();
 
-        if (unarmedManager.canActivateAbility()) {
-            mcMMOPlayer.checkAbilityActivation(SkillType.UNARMED);
-        }
+        mcMMOPlayer.checkAbilityActivation(SkillType.UNARMED);
 
         if (unarmedManager.canUseIronArm()) {
             finalDamage += unarmedManager.ironArm(target);
@@ -118,9 +97,7 @@ public final class CombatUtils {
             finalDamage += unarmedManager.berserkDamage(target, initialDamage);
         }
 
-        if (unarmedManager.canDisarm(target)) {
-            unarmedManager.disarmCheck((Player) target);
-        }
+        unarmedManager.disarm(target);
 
         event.setDamage(finalDamage);
         startGainXp(mcMMOPlayer, target, SkillType.UNARMED);
@@ -150,39 +127,28 @@ public final class CombatUtils {
     }
 
     private static void processArcheryCombat(LivingEntity target, Player player, EntityDamageByEntityEvent event, Arrow arrow) {
+        if (target instanceof Player) {
+            UnarmedManager unarmedManager = UserManager.getPlayer((Player) target).getUnarmedManager();
+            event.setCancelled(unarmedManager.deflect());
+
+            if (event.isCancelled()) {
+                return;
+            }
+        }
+
         double initialDamage = event.getDamage();
-        double finalDamage = initialDamage;
+        double bonusDamage = 0;
 
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
         ArcheryManager archeryManager = mcMMOPlayer.getArcheryManager();
 
-        if (target instanceof Player && SkillType.UNARMED.getPVPEnabled()) {
-            UnarmedManager unarmedManager = UserManager.getPlayer((Player) target).getUnarmedManager();
+        bonusDamage += archeryManager.skillShot(target, initialDamage, arrow);
+        bonusDamage += archeryManager.daze(target, arrow);
 
-            if (unarmedManager.canDeflect()) {
-                event.setCancelled(unarmedManager.deflectCheck());
+        archeryManager.trackArrow(target, arrow);
+        archeryManager.awardDistanceXpBonus(target, arrow);
 
-                if (event.isCancelled()) {
-                    return;
-                }
-            }
-        }
-
-        if (archeryManager.canSkillShot()) {
-            finalDamage += archeryManager.skillShot(target, initialDamage, arrow);
-        }
-
-        if (archeryManager.canDaze(target)) {
-            finalDamage += archeryManager.daze((Player) target, arrow);
-        }
-
-        if (!arrow.hasMetadata(mcMMO.infiniteArrowKey) && archeryManager.canTrackArrows()) {
-            archeryManager.trackArrows(target);
-        }
-
-        archeryManager.distanceXpBonus(target, arrow);
-
-        event.setDamage(finalDamage);
+        event.setDamage(initialDamage + bonusDamage);
         startGainXp(mcMMOPlayer, target, SkillType.ARCHERY, arrow.getMetadata(mcMMO.bowForceKey).get(0).asDouble());
     }
 
@@ -281,11 +247,8 @@ public final class CombatUtils {
 
             Player player = (Player) target;
             McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
-            AcrobaticsManager acrobaticsManager = mcMMOPlayer.getAcrobaticsManager();
 
-            if (acrobaticsManager.canDodge(damager)) {
-                event.setDamage(acrobaticsManager.dodgeCheck(event.getDamage()));
-            }
+            event.setDamage(mcMMOPlayer.getAcrobaticsManager().dodge(damager, event.getDamage()));
 
             if (ItemUtils.isSword(player.getItemInHand())) {
                 if (!SkillType.SWORDS.shouldProcess(target)) {
@@ -352,9 +315,15 @@ public final class CombatUtils {
      * @param attacker The attacking player
      * @param target The defending entity
      * @param damage The initial damage amount
-     * @param type The type of skill being used
+     * @param skill The type of skill being used
      */
-    public static void applyAbilityAoE(Player attacker, LivingEntity target, double damage, SkillType type) {
+    public static void applyAbilityAoE(Player attacker, LivingEntity target, double damage, SkillType skill) {
+        AbilityType ability = skill.getAbility();
+
+        if (!target.isValid() || !UserManager.getPlayer(attacker).getAbilityMode(ability) || !ability.getPermissions(attacker)) {
+            return;
+        }
+
         int numberOfTargets = Misc.getTier(attacker.getItemInHand()); // The higher the weapon tier, the more targets you hit
         double damageAmount = Math.max(damage, 1);
 
@@ -370,7 +339,7 @@ public final class CombatUtils {
             LivingEntity livingEntity = (LivingEntity) entity;
             EventUtils.callFakeArmSwingEvent(attacker);
 
-            switch (type) {
+            switch (skill) {
                 case SWORDS:
                     if (entity instanceof Player) {
                         ((Player) entity).sendMessage(LocaleLoader.getString("Swords.Combat.SS.Struck"));
@@ -568,17 +537,13 @@ public final class CombatUtils {
     }
 
     public static double callFakeDamageEvent(Entity attacker, Entity target, DamageCause cause, double damage) {
-        if (Config.getInstance().getEventCallbackEnabled()) {
-            EntityDamageEvent damageEvent = attacker == null ? new FakeEntityDamageEvent(target, cause, damage) : new FakeEntityDamageByEntityEvent(attacker, target, cause, damage);
-            mcMMO.p.getServer().getPluginManager().callEvent(damageEvent);
+        EntityDamageEvent damageEvent = attacker == null ? new FakeEntityDamageEvent(target, cause, damage) : new FakeEntityDamageByEntityEvent(attacker, target, cause, damage);
+        mcMMO.p.getServer().getPluginManager().callEvent(damageEvent);
 
-            if (damageEvent.isCancelled()) {
-                return 0;
-            }
-
-            damage = damageEvent.getDamage();
+        if (damageEvent.isCancelled()) {
+            return 0;
         }
 
-        return damage;
+        return damageEvent.getDamage();
     }
 }

src/main/resources/config.yml

@@ -17,8 +17,6 @@ General:
     # Allow mcMMO to check if a new version is available
     Update_Check: true
     Prefer_Beta: false
-    # Allow mcMMO to inform other plugins of damage being dealt
-    Event_Callback: true
     Power_Level_Cap: 0
     # Should mcMMO print out debug messages?
     Verbose_Logging: false
@@ -402,4 +400,4 @@ Particles:
     # These settings determine if fireworks should get launched when a player levels-up,
     # this will happen by default for every 100 levels.
     LevelUp_Enabled: true
-    LevelUp_Tier: 100
+    LevelUp_Tier: 100