Applied protection to all pets

src/main/java/eu/endermite/togglepvp/TogglePvp.java

@@ -21,6 +21,7 @@ public final class TogglePvp extends JavaPlugin {
     private ConfigCache configCache;
     private PlayerManager playerManager;
     private DatabaseSQLite sqLite;
+    private SmartCache smartCache;
 
     @Override
     public void onEnable() {
@@ -36,8 +37,8 @@ public final class TogglePvp extends JavaPlugin {
             return;
         }
         playerManager = new PlayerManager();
-
+        smartCache = new SmartCache();
-        SmartCache.runSmartCache();
+        smartCache.runSmartCache();
 
         // Register listeners
         Reflections reflections = new Reflections(new String[]{"eu.endermite.togglepvp"});
@@ -81,4 +82,7 @@ public final class TogglePvp extends JavaPlugin {
 
     public DatabaseSQLite getSqLite() {return sqLite;}
 
+    public SmartCache getSmartCache() {
+        return smartCache;
+    }
 }

src/main/java/eu/endermite/togglepvp/TogglePvpAPI.java

@@ -1,6 +1,5 @@
 package eu.endermite.togglepvp;
 
-import eu.endermite.togglepvp.players.SmartCache;
 import java.util.UUID;
 
 public class TogglePvpAPI {
@@ -11,7 +10,7 @@ public class TogglePvpAPI {
      * @param newState State to set
      */
     public static void setPvpEnabled(UUID uuid, boolean newState) {
-        SmartCache.setPlayerPvpState(uuid, newState);
+        TogglePvp.getPlugin().getSmartCache().setPlayerPvpState(uuid, newState);
     }
 
     /**
@@ -20,7 +19,7 @@ public class TogglePvpAPI {
      * @return true if enabled, false if disabled
      */
     public static boolean getPvpEnabled(UUID uuid) {
-        return SmartCache.getPlayerData(uuid).isPvpEnabled();
+        return TogglePvp.getPlugin().getSmartCache().getPlayerData(uuid).isPvpEnabled();
     }
 
 

src/main/java/eu/endermite/togglepvp/listeners/pets/PetHitByExplosionListener.java

@@ -0,0 +1,54 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.players.SmartCache;
+import eu.endermite.togglepvp.util.CombatTimer;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import java.util.UUID;
+
+@eu.endermite.togglepvp.util.Listener
+public class PetHitByExplosionListener implements Listener {
+
+    /**
+     * Cancels explosion damage for pets with pvp off that is caused by players
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerHitByExplosion(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Tameable))
+            return;
+
+        if (!event.getCause().equals(EntityDamageEvent.DamageCause.ENTITY_EXPLOSION))
+            return;
+
+        Tameable victim = (Tameable) event.getEntity();
+        if (victim.getOwner() == null)
+            return;
+
+        try {
+            UUID damageruuid = UUID.fromString(event.getDamager().getMetadata("PLAYEREXPLODED").get(0).asString());
+            if (victim.getOwner().getUniqueId() == damageruuid) {
+                return;
+            }
+            ConfigCache config = TogglePvp.getPlugin().getConfigCache();
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+            if (!smartCache.getPlayerData(damageruuid).isPvpEnabled()) {
+                PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_pets_attacker());
+                event.setCancelled(true);
+                return;
+            }
+            if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
+                PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_pets_victim());
+                event.setCancelled(true);
+                return;
+            }
+            CombatTimer.refreshPlayersCombatTime(damageruuid, victim.getOwner().getUniqueId());
+        } catch (NullPointerException | IndexOutOfBoundsException ignored) {}
+
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PetHitByFireworkListener.java

@@ -0,0 +1,44 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.players.SmartCache;
+import eu.endermite.togglepvp.util.CombatTimer;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PetHitByFireworkListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onFireworkDamage(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof Firework && event.getEntity() instanceof Tameable) {
+            Tameable victim = (Tameable) event.getEntity();
+            if (victim.getOwner() == null)
+                return;
+            Firework firework = (Firework) event.getDamager();
+            if (!(firework.getShooter() instanceof Player))
+                return;
+            Player damager = (Player) firework.getShooter();
+            if (victim.getOwner() == damager)
+                return;
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+            if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager.getUniqueId(), TogglePvp.getPlugin().getConfigCache().getCannot_attack_pets_attacker());
+                return;
+            }
+            if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager.getUniqueId(), TogglePvp.getPlugin().getConfigCache().getCannot_attack_pets_victim());
+                return;
+            }
+            CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
+
+        }
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PetHitBySplashPotionListener.java

@@ -1,4 +1,4 @@
-package eu.endermite.togglepvp.listeners.wolf;
+package eu.endermite.togglepvp.listeners.pets;
 
 import eu.endermite.togglepvp.TogglePvp;
 import eu.endermite.togglepvp.config.ConfigCache;
@@ -7,7 +7,7 @@ import eu.endermite.togglepvp.util.CombatTimer;
 import eu.endermite.togglepvp.util.PluginMessages;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -15,7 +15,7 @@ import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
 @eu.endermite.togglepvp.util.Listener
-public class WolfHitBySplashPotionListener implements Listener {
+public class PetHitBySplashPotionListener implements Listener {
 
     /**
      * If thrown potion applies negative effects and it's thrown by a player
@@ -45,21 +45,21 @@ public class WolfHitBySplashPotionListener implements Listener {
         if (!harmful)
             return;
         for (Entity entity : event.getAffectedEntities()) {
-            if (entity instanceof Wolf) {
+            if (entity instanceof Tameable) {
                 Player damager = (Player) event.getEntity().getShooter();
-                Wolf victim = (Wolf) entity;
+                Tameable victim = (Tameable) entity;
                 if (victim.getOwner() == null || victim.getOwner() == damager)
                     continue;
 
                 ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-                if (!damagerPvpEnabled) {
+
+                if (!TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId())) {
                     event.setIntensity(victim, 0);
                     PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                     continue;
                 }
-                boolean victimPvpEnabled = (boolean) SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-                if (!victimPvpEnabled) {
                     event.setIntensity(victim, 0);
                     PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
                     continue;

src/main/java/eu/endermite/togglepvp/listeners/pets/PetLeashListener.java

@@ -1,38 +1,37 @@
-package eu.endermite.togglepvp.listeners.wolf;
+package eu.endermite.togglepvp.listeners.pets;
 
 import eu.endermite.togglepvp.TogglePvp;
 import eu.endermite.togglepvp.config.ConfigCache;
 import eu.endermite.togglepvp.players.SmartCache;
 import eu.endermite.togglepvp.util.PluginMessages;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 
 @eu.endermite.togglepvp.util.Listener
-public class WolfLeashListener implements Listener {
+public class PetLeashListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onWolfLeash(org.bukkit.event.entity.PlayerLeashEntityEvent event) {
+    public void onPetLeash(org.bukkit.event.entity.PlayerLeashEntityEvent event) {
-        if (event.getEntity() instanceof Wolf) {
+        if (event.getEntity() instanceof Tameable) {
-            Wolf victim = (Wolf) event.getEntity();
+            Tameable victim = (Tameable) event.getEntity();
-            if (victim.getOwner() == null) {
+            if (victim.getOwner() == null)
                 return;
-            }
+
             Player damager = event.getPlayer();
-            if (victim.getOwner() == damager) {
+            if (victim.getOwner() == damager)
                 return;
-            }
+
             ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-            boolean damagerPvpEnabled = SmartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled();
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-            if (!damagerPvpEnabled) {
+            if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                 event.setCancelled(true);
                 return;
             }
-            boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+            if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-            if (!victimPvpEnabled) {
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
                 event.setCancelled(true);
             }

src/main/java/eu/endermite/togglepvp/listeners/pets/PetTargettingPetListener.java

@@ -0,0 +1,36 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.players.SmartCache;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Wolf;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PetTargettingPetListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onWolfAttackWolf(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof Tameable && event.getEntity() instanceof Tameable) {
+            Tameable damager = (Tameable) event.getDamager();
+            Tameable victim = (Tameable) event.getEntity();
+            if (damager.getOwner() == null || victim.getOwner() == null)
+                return;
+
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+
+            boolean damagerPvpEnabled = smartCache.getPlayerData(damager.getOwner().getUniqueId()).isPvpEnabled();
+            boolean victimPvpEnabled = smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+            if (!victimPvpEnabled || !damagerPvpEnabled) {
+                if (damager instanceof Wolf) {
+                    Wolf wolf = (Wolf) damager;
+                    wolf.setAngry(false);
+                }
+                event.setCancelled(true);
+            }
+        }
+    }
+
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PetTargettingPlayerListener.java

@@ -0,0 +1,33 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PetTargettingPlayerListener implements Listener {
+    /**
+     * Stops pets with owners targetting players with pvp off
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onWolfTarget(org.bukkit.event.entity.EntityTargetEvent event) {
+        if (!(event.getEntity() instanceof Tameable))
+            return;
+
+        Tameable entity = (Tameable) event.getEntity();
+        if (entity.getOwner() == null)
+            return;
+
+        if (event.getTarget() instanceof Player) {
+            boolean attackerPvPEnabled = TogglePvp.getPlugin().getSmartCache().getPlayerData(entity.getOwner().getUniqueId()).isPvpEnabled();
+            Player victim = (Player) event.getTarget();
+            boolean victimPvpEnabled = TogglePvp.getPlugin().getSmartCache().getPlayerData(victim.getUniqueId()).isPvpEnabled();
+            if (!attackerPvPEnabled || !victimPvpEnabled) {
+                event.setCancelled(true);
+            }
+        }
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PlayerAttackPetListener.java

@@ -0,0 +1,48 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.players.SmartCache;
+import eu.endermite.togglepvp.util.CombatTimer;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PlayerAttackPetListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerAttacktameable(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+
+        if (event.getDamager() instanceof Player && event.getEntity() instanceof Tameable) {
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+            Tameable tameable = (Tameable) event.getEntity();
+            if (tameable.getOwner() == null)
+                return;
+
+            Player damager = (Player) event.getDamager();
+
+            if (damager.getUniqueId() == tameable.getOwner().getUniqueId())
+                return;
+
+            ConfigCache config = TogglePvp.getPlugin().getConfigCache();
+            boolean damagerPvpState = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+
+            if (!damagerPvpState) {
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
+                event.setCancelled(true);
+                return;
+            }
+            if (!smartCache.getPlayerData(tameable.getOwner().getUniqueId()).isPvpEnabled()) {
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
+                event.setCancelled(true);
+                return;
+            }
+            CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), tameable.getOwner().getUniqueId());
+
+        }
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PlayerHitPetWithProjectile.java

@@ -0,0 +1,49 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.players.SmartCache;
+import eu.endermite.togglepvp.util.CombatTimer;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PlayerHitPetWithProjectile implements Listener {
+
+     /**
+     * Cancels damage done by projectiles to pets of players with pvp off
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerHitWolfWithProjectile(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (event.getEntity() instanceof Tameable && event.getDamager() instanceof Projectile) {
+            Projectile projectile = (Projectile) event.getDamager();
+            if (!(projectile.getShooter() instanceof Player))
+                return;
+
+            Tameable victim = (Tameable) event.getEntity();
+            Player damager = (Player) projectile.getShooter();
+            if (victim.getOwner() == null || victim.getOwner() == damager)
+                return;
+
+            ConfigCache config = TogglePvp.getPlugin().getConfigCache();
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+            if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
+                return;
+            }
+            if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
+                return;
+            }
+            CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
+
+        }
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/pets/PlayerInteractWithPetListener.java

@@ -1,4 +1,4 @@
-package eu.endermite.togglepvp.listeners.wolf;
+package eu.endermite.togglepvp.listeners.pets;
 
 import eu.endermite.togglepvp.TogglePvp;
 import org.bukkit.entity.Tameable;
@@ -12,6 +12,9 @@ public class PlayerInteractWithPetListener implements Listener {
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPlayerInteractWithPet(org.bukkit.event.player.PlayerInteractEntityEvent event) {
 
+        if (!TogglePvp.getPlugin().getConfigCache().isOnly_owner_can_interact_with_pet())
+            return;
+
         if (!(event.getRightClicked() instanceof Tameable))
             return;
 
@@ -19,9 +22,6 @@ public class PlayerInteractWithPetListener implements Listener {
         if (tameable.getOwner() == null)
             return;
 
-        if (!TogglePvp.getPlugin().getConfigCache().isOnly_owner_can_interact_with_pet())
-            return;
-
         if (tameable.getOwner().getUniqueId().equals(event.getPlayer().getUniqueId()))
             return;
 

src/main/java/eu/endermite/togglepvp/listeners/player/PetAttackPlayerListener.java

@@ -0,0 +1,43 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.util.CombatTimer;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Wolf;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+@eu.endermite.togglepvp.util.Listener
+public class PetAttackPlayerListener implements Listener {
+
+    /**
+     * Pets stop following player with pvp off after trying to hit them
+     * This is to fix any inconsistancy with pet behavior
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onWolfAttack(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Tameable))
+            return;
+
+        Tameable entity = (Tameable) event.getDamager();
+        if (entity.getOwner() != null && event.getEntity() instanceof Player) {
+
+            boolean damagerPvpEnabled = TogglePvp.getPlugin().getSmartCache().getPlayerData(entity.getOwner().getUniqueId()).isPvpEnabled();
+            Player victim = (Player) event.getEntity();
+            boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+            if (!victimPvpEnabled || !damagerPvpEnabled) {
+                if (entity instanceof Wolf) {
+                    Wolf wolf = (Wolf) entity;
+                    wolf.setAngry(false);
+                }
+                event.setCancelled(true);
+                return;
+            }
+            CombatTimer.refreshPlayersCombatTime(entity.getOwner().getUniqueId(), victim.getUniqueId());
+        }
+
+    }
+
+}

src/main/java/eu/endermite/togglepvp/listeners/player/WolfAttackPlayerListener.java

@@ -1,39 +0,0 @@
-package eu.endermite.togglepvp.listeners.player;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.players.SmartCache;
-import eu.endermite.togglepvp.util.CombatTimer;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class WolfAttackPlayerListener implements Listener {
-
-    /**
-     * Wolves stop following player with pvp off after trying to hit them
-     * This is to fix any inconsistancy with wolf behaviour
-     */
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onWolfAttack(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-        if (event.getDamager() instanceof Wolf) {
-            Wolf wolf = (Wolf) event.getDamager();
-            if (wolf.getOwner() != null && event.getEntity() instanceof Player) {
-                try {
-                    boolean damagerPvpEnabled = SmartCache.getPlayerData(wolf.getOwner().getUniqueId()).isPvpEnabled();
-                    Player victim = (Player) event.getEntity();
-                    boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
-                    if (!victimPvpEnabled || !damagerPvpEnabled) {
-                        wolf.setAngry(false);
-                        event.setCancelled(true);
-                        return;
-                    }
-                    CombatTimer.refreshPlayersCombatTime(wolf.getOwner().getUniqueId(), victim.getUniqueId());
-                } catch (NullPointerException ignored) {}
-            }
-        }
-    }
-
-}

src/main/java/eu/endermite/togglepvp/listeners/unspecific/AreaEffectCloudApplyListener.java

@@ -7,7 +7,7 @@ import eu.endermite.togglepvp.util.CombatTimer;
 import eu.endermite.togglepvp.util.PluginMessages;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
@@ -36,6 +36,8 @@ public class AreaEffectCloudApplyListener implements Listener {
                     potionEffectType.equals(PotionEffectType.SLOW) ||
                     potionEffectType.equals(PotionEffectType.WITHER)) {
 
+                SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+
                 Iterator<LivingEntity> it = event.getAffectedEntities().iterator();
                 Player damager = (Player) event.getEntity().getSource();
                 while(it.hasNext()) {
@@ -47,33 +49,29 @@ public class AreaEffectCloudApplyListener implements Listener {
                             continue;
 
                         ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                        boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                        if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                        if (!damagerPvpEnabled) {
                             it.remove();
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
                             continue;
                         }
-                        boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+                        if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                        if (!victimPvpEnabled) {
                             it.remove();
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
                             continue;
                         }
                         CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
-                    } else if (entity instanceof Wolf) {
+                    } else if (entity instanceof Tameable) {
-                        Wolf victim = (Wolf) entity;
+                        Tameable victim = (Tameable) entity;
                         if (victim.getOwner() == null || victim.getOwner() == damager) {
                             return;
                         }
                         ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                        boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                        if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                        if (!damagerPvpEnabled) {
                             it.remove();
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                             continue;
                         }
-                        boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                        if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                        if (!victimPvpEnabled) {
                             it.remove();
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
                             continue;

src/main/java/eu/endermite/togglepvp/listeners/unspecific/EntityHitByLightningListener.java

@@ -1,10 +1,9 @@
 package eu.endermite.togglepvp.listeners.unspecific;
 
 import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.players.SmartCache;
 import org.bukkit.entity.LightningStrike;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -26,14 +25,12 @@ public class EntityHitByLightningListener implements Listener {
         if (event.getDamager() instanceof LightningStrike && event.getDamager().getMetadata("TRIDENT").size() >= 1) {
             if (event.getEntity() instanceof Player) {
                 Player victim = (Player) event.getEntity();
-                boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+                if (!TogglePvp.getPlugin().getSmartCache().getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                if (!victimPvpEnabled) {
                     event.setCancelled(true);
                 }
-            } else if (event.getEntity() instanceof Wolf) {
+            } else if (event.getEntity() instanceof Tameable) {
-                Wolf victim = (Wolf) event.getEntity();
+                Tameable victim = (Tameable) event.getEntity();
-                boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                if (victim.getOwner() != null && !TogglePvp.getPlugin().getSmartCache().getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-                if (!victimPvpEnabled) {
                     event.setCancelled(true);
                 }
             }

src/main/java/eu/endermite/togglepvp/listeners/unspecific/FishingListener.java

@@ -6,7 +6,7 @@ import eu.endermite.togglepvp.players.SmartCache;
 import eu.endermite.togglepvp.util.CombatTimer;
 import eu.endermite.togglepvp.util.PluginMessages;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -27,33 +27,31 @@ public class FishingListener implements Listener {
             if (damager == victim) {
                 return;
             }
-            boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-            if (!damagerPvpEnabled) {
+            if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
                 event.setCancelled(true);
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
                 return;
             }
-            boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+            if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-            if (!victimPvpEnabled) {
                 event.setCancelled(true);
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
                 return;
             }
             CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
-        } else if (event.getCaught() instanceof Wolf) {
+        } else if (event.getCaught() instanceof Tameable) {
-            Wolf victim = (Wolf) event.getCaught();
+            Tameable victim = (Tameable) event.getCaught();
             Player damager = event.getPlayer();
             if (victim.getOwner() == null || victim.getOwner() == damager) {
                 return;
             }
-            boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-            if (!damagerPvpEnabled) {
+            if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
                 event.setCancelled(true);
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
                 return;
             }
-            boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+            if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-            if (!victimPvpEnabled) {
                 event.setCancelled(true);
                 PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
                 return;

src/main/java/eu/endermite/togglepvp/listeners/unspecific/LavaDumpAndIgniteListener.java

@@ -10,7 +10,7 @@ import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -35,45 +35,43 @@ public class LavaDumpAndIgniteListener implements Listener {
             Location location = event.getBlockClicked().getLocation();
             Player damager = event.getPlayer();
             double radius = config.getLava_and_fire_stopper_radius();
+            SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
             BoundingBox boundingBox = BoundingBoxUtil.getBoundingBox(location, radius);
             for (Entity entity : location.getWorld().getNearbyEntities(boundingBox)) {
                 if (entity instanceof Player) {
                     Player victim = (Player) entity;
                     if (victim != damager) {
-                        boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                        if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                        if (!damagerPvpEnabled) {
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
                             event.setCancelled(true);
                             return;
                         }
-                        boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+                        if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                        if (!victimPvpEnabled) {
                             PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
                             event.setCancelled(true);
                             return;
                         }
                         CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
                     }
-                } else if (entity instanceof Wolf) {
+                } else if (entity instanceof Tameable) {
-                    Wolf victim = (Wolf) entity;
+                    Tameable victim = (Tameable) entity;
                     if (victim.getOwner() == null) {
                         return;
                     }
-                    boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                    if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                    if (!damagerPvpEnabled) {
                         PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                         event.setCancelled(true);
                         return;
                     }
-                    try {
+
-                        boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                    boolean victimPvpEnabled = smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
-                        if (!victimPvpEnabled) {
+                    if (!victimPvpEnabled) {
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
-                            event.setCancelled(true);
+                        event.setCancelled(true);
-                            return;
+                        return;
-                        }
+                    }
-                        CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
+                    CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
-                    } catch (NullPointerException ignored) {}
+
                 }
             }
         }
@@ -88,51 +86,48 @@ public class LavaDumpAndIgniteListener implements Listener {
         if (!TogglePvp.getPlugin().getConfigCache().isLava_and_fire_stopper_enabled())
             return;
 
-        if (event.getPlayer() !=null) {
+        if (event.getPlayer() == null)
-            Location location = event.getBlock().getLocation();
+            return;
-            Player damager = event.getPlayer();
+
-            double radius = config.getLava_and_fire_stopper_radius();
+        Location location = event.getBlock().getLocation();
-            BoundingBox boundingBox = BoundingBoxUtil.getBoundingBox(location, radius);
+        Player damager = event.getPlayer();
-            for (Entity entity : location.getWorld().getNearbyEntities(boundingBox)) {
+        double radius = config.getLava_and_fire_stopper_radius();
-                if (entity instanceof Player) {
+        BoundingBox boundingBox = BoundingBoxUtil.getBoundingBox(location, radius);
-                    Player victim = (Player) entity;
+        SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-                    if (victim != damager) {
+        for (Entity entity : location.getWorld().getNearbyEntities(boundingBox)) {
-                        boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+            if (entity instanceof Player) {
-                        if (!damagerPvpEnabled) {
+                Player victim = (Player) entity;
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                if (victim != damager) {
-                            event.setCancelled(true);
+                    if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                            return;
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
-                        }
-                        boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
-                        if (!victimPvpEnabled) {
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
-                            event.setCancelled(true);
-                            return;
-                        }
-                        CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
-                    }
-                } else if (entity instanceof Wolf) {
-                    Wolf victim = (Wolf) entity;
-                    if (victim.getOwner() == null || victim.getOwner() == damager) {
-                        return;
-                    }
-                    boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
-                    if (!damagerPvpEnabled) {
-                        PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                         event.setCancelled(true);
                         return;
                     }
-                    try {
+                    if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                        boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
-                        if (!victimPvpEnabled) {
+                        event.setCancelled(true);
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
+                        return;
-                            event.setCancelled(true);
+                    }
-                            return;
+                    CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
-                        }
-                        CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
-                    } catch (NullPointerException ignored) {}
                 }
+            } else if (entity instanceof Tameable) {
+                Tameable victim = (Tameable) entity;
+                if (victim.getOwner() == null || victim.getOwner() == damager) {
+                    return;
+                }
+                if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
+                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
+                    event.setCancelled(true);
+                    return;
+                }
+                if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
+                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
+                    event.setCancelled(true);
+                    return;
+                }
+                CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
             }
         }
+
     }
 }

src/main/java/eu/endermite/togglepvp/listeners/unspecific/LightningBlockIgniteListener.java

@@ -1,11 +1,7 @@
 package eu.endermite.togglepvp.listeners.unspecific;
 
 import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.players.SmartCache;
+import org.bukkit.entity.*;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.LightningStrike;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -25,16 +21,16 @@ public class LightningBlockIgniteListener implements Listener {
             for (Entity entity : lightningStrike.getNearbyEntities(2,2,2)) {
                 if (entity instanceof Player) {
                     Player victim = (Player) entity;
-                    if (!TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId())) {
+                    if (!TogglePvp.getPlugin().getSmartCache().getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
                         event.setCancelled(true);
                         return;
                     }
-                } else if (entity instanceof Wolf) {
+                } else if (entity instanceof Tameable) {
-                    Wolf victim = (Wolf) entity;
+                    Tameable victim = (Tameable) entity;
                     if (victim.getOwner() == null) {
                         return;
                     }
-                    if (!SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
+                    if (!TogglePvp.getPlugin().getSmartCache().getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
                         event.setCancelled(true);
                         return;
                     }

src/main/java/eu/endermite/togglepvp/listeners/unspecific/PlaceWitherRoseListener.java

@@ -10,7 +10,7 @@ import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -19,14 +19,16 @@ import org.bukkit.util.BoundingBox;
 @eu.endermite.togglepvp.util.Listener
 public class PlaceWitherRoseListener implements Listener {
 
-    private ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPlayerWitherRosePlace(org.bukkit.event.block.BlockPlaceEvent event) {
-        if (!TogglePvp.getPlugin().getConfigCache().isLava_and_fire_stopper_enabled())
+
+        ConfigCache config = TogglePvp.getPlugin().getConfigCache();
+        SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
+
+        if (!config.isLava_and_fire_stopper_enabled())
             return;
 
-        if(event.getBlock().getType().equals(Material.WITHER_ROSE)) {
+        if (event.getBlock().getType().equals(Material.WITHER_ROSE)) {
             Location location = event.getBlockPlaced().getLocation();
             double radius = config.getLava_and_fire_stopper_radius();
             BoundingBox boundingBox = BoundingBoxUtil.getBoundingBox(location, radius);
@@ -34,35 +36,31 @@ public class PlaceWitherRoseListener implements Listener {
                 if (entity instanceof Player) {
                     Player damager = event.getPlayer();
                     Player victim = (Player) entity;
-                    if (victim != damager) {
+                    if (victim == damager)
-                        boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                        return;
-                        if (!damagerPvpEnabled) {
+                    if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
-                            event.setCancelled(true);
+                        event.setCancelled(true);
-                            return;
+                        return;
-                        }
-                        boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
-                        if (!victimPvpEnabled) {
-                            PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
-                            event.setCancelled(true);
-                            return;
-                        }
-                        CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
                     }
-                } else if (entity instanceof Wolf) {
+                    if (!smartCache.getPlayerData(victim.getUniqueId()).isPvpEnabled()) {
-                    Wolf victim = (Wolf) entity;
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+                        event.setCancelled(true);
+                        return;
+                    }
+                    CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getUniqueId());
+                } else if (entity instanceof Tameable) {
+                    Tameable victim = (Tameable) entity;
                     Player damager = event.getPlayer();
                     if (victim.getOwner() == null || victim.getOwner() == damager) {
                         return;
                     }
-                    boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
+                    if (!smartCache.getPlayerData(damager.getUniqueId()).isPvpEnabled()) {
-                    if (!damagerPvpEnabled) {
                         PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
                         event.setCancelled(true);
                         return;
                     }
-                    boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
+                    if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-                    if (!victimPvpEnabled) {
                         PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
                         event.setCancelled(true);
                         return;

src/main/java/eu/endermite/togglepvp/listeners/wolf/PlayerAttackWolfListener.java

@@ -1,47 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.config.ConfigCache;
-import eu.endermite.togglepvp.players.SmartCache;
-import eu.endermite.togglepvp.util.CombatTimer;
-import eu.endermite.togglepvp.util.PluginMessages;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class PlayerAttackWolfListener implements Listener {
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onPlayerAttackWolf(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-
-        if (event.getDamager() instanceof Player && event.getEntity() instanceof Wolf) {
-            Wolf wolf = (Wolf) event.getEntity();
-            if (wolf.getOwner() != null) {
-                Player damager = (Player) event.getDamager();
-
-                if (damager.getUniqueId() == wolf.getOwner().getUniqueId()) {
-                    return;
-                }
-
-                ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                boolean damagerPvpState = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
-
-                if (!damagerPvpState) {
-                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
-                    event.setCancelled(true);
-                    return;
-                }
-                boolean victimPvpEnabled = SmartCache.getPlayerData(wolf.getOwner().getUniqueId()).isPvpEnabled();
-                if (!victimPvpEnabled) {
-                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
-                    event.setCancelled(true);
-                    return;
-                }
-                CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), wolf.getOwner().getUniqueId());
-            }
-        }
-    }
-}

src/main/java/eu/endermite/togglepvp/listeners/wolf/PlayerHitWolfWithProjectile.java

@@ -1,48 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.config.ConfigCache;
-import eu.endermite.togglepvp.players.SmartCache;
-import eu.endermite.togglepvp.util.CombatTimer;
-import eu.endermite.togglepvp.util.PluginMessages;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class PlayerHitWolfWithProjectile implements Listener {
-
-    /**
-     * Cancels damage done by projectiles to pets of players with pvp off
-     */
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onPlayerHitWolfWithProjectile(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-        if (event.getEntity() instanceof Wolf && event.getDamager() instanceof Projectile) {
-            Projectile projectile = (Projectile) event.getDamager();
-            if (projectile.getShooter() instanceof Player) {
-                Wolf victim = (Wolf) event.getEntity();
-                Player damager = (Player) projectile.getShooter();
-                if (victim.getOwner() == null || victim.getOwner() == damager) {
-                    return;
-                }
-                ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(damager.getUniqueId());
-                boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
-                if (!damagerPvpEnabled) {
-                    event.setCancelled(true);
-                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_attacker());
-                    return;
-                }
-                if (!victimPvpEnabled) {
-                    event.setCancelled(true);
-                    PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
-                    return;
-                }
-                CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
-            }
-        }
-    }
-}

src/main/java/eu/endermite/togglepvp/listeners/wolf/WolfHitByExplosionListener.java

@@ -1,53 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.config.ConfigCache;
-import eu.endermite.togglepvp.players.SmartCache;
-import eu.endermite.togglepvp.util.CombatTimer;
-import eu.endermite.togglepvp.util.PluginMessages;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageEvent;
-import java.util.UUID;
-
-@eu.endermite.togglepvp.util.Listener
-public class WolfHitByExplosionListener implements Listener {
-
-    /**
-     * Cancels explosion damage for wolves with pvp off that is caused by players
-     */
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onPlayerHitByExplosion(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-        if (event.getEntity() instanceof Wolf) {
-            if (!event.getCause().equals(EntityDamageEvent.DamageCause.ENTITY_EXPLOSION)) {
-                return;
-            }
-            Wolf victim = (Wolf) event.getEntity();
-            if (victim.getOwner() == null) {
-                return;
-            }
-            try {
-                UUID damageruuid = UUID.fromString(event.getDamager().getMetadata("PLAYEREXPLODED").get(0).asString());
-                if (victim.getOwner().getUniqueId() == damageruuid) {
-                    return;
-                }
-                ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                boolean damagerPvpEnabled = SmartCache.getPlayerData(damageruuid).isPvpEnabled();
-                if (!damagerPvpEnabled) {
-                    PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_pets_attacker());
-                    event.setCancelled(true);
-                    return;
-                }
-                boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
-                if (!victimPvpEnabled) {
-                    PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_pets_victim());
-                    event.setCancelled(true);
-                    return;
-                }
-                CombatTimer.refreshPlayersCombatTime(damageruuid, victim.getOwner().getUniqueId());
-            } catch (NullPointerException | IndexOutOfBoundsException ignored) {}
-        }
-    }
-}

src/main/java/eu/endermite/togglepvp/listeners/wolf/WolfHitByFireworkListener.java

@@ -1,43 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.util.CombatTimer;
-import eu.endermite.togglepvp.util.PluginMessages;
-import org.bukkit.entity.Firework;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class WolfHitByFireworkListener implements Listener {
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onFireworkDamage(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-        if (event.getDamager() instanceof Firework && event.getEntity() instanceof Wolf) {
-            Wolf victim = (Wolf) event.getEntity();
-            if (victim.getOwner() == null)
-                return;
-            Firework firework = (Firework) event.getDamager();
-            if (firework.getShooter() instanceof Player) {
-                Player damager = (Player) firework.getShooter();
-                if (victim.getOwner() == damager)
-                    return;
-                boolean damagerPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getOwner().getUniqueId());
-                if (!damagerPvpEnabled) {
-                    event.setCancelled(true);
-                    PluginMessages.sendActionBar(damager.getUniqueId(), TogglePvp.getPlugin().getConfigCache().getCannot_attack_pets_attacker());
-                    return;
-                }
-                boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
-                if (!victimPvpEnabled) {
-                    event.setCancelled(true);
-                    PluginMessages.sendActionBar(damager.getUniqueId(), TogglePvp.getPlugin().getConfigCache().getCannot_attack_pets_victim());
-                    return;
-                }
-                CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
-            }
-        }
-    }
-}

src/main/java/eu/endermite/togglepvp/listeners/wolf/WolfTargettingPlayerListener.java

@@ -1,32 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.players.SmartCache;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class WolfTargettingPlayerListener implements Listener {
-    /**
-     * Stops wolves with owners targetting players with pvp off
-     */
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onWolfTarget(org.bukkit.event.entity.EntityTargetEvent event) {
-        if (event.getEntity() instanceof Wolf) {
-            Wolf wolf = (Wolf) event.getEntity();
-            if (wolf.getOwner() != null) {
-                if (event.getTarget() instanceof Player) {
-                    boolean attackerPvPEnabled = SmartCache.getPlayerData(wolf.getOwner().getUniqueId()).isPvpEnabled();
-                    Player victim = (Player) event.getTarget();
-                    boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
-                    if (!attackerPvPEnabled || !victimPvpEnabled) {
-                        event.setCancelled(true);
-                    }
-                }
-            }
-        }
-    }
-}

src/main/java/eu/endermite/togglepvp/listeners/wolf/WolfTargettingWolfListener.java

@@ -1,32 +0,0 @@
-package eu.endermite.togglepvp.listeners.wolf;
-
-import eu.endermite.togglepvp.players.SmartCache;
-import org.bukkit.entity.Wolf;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-@eu.endermite.togglepvp.util.Listener
-public class WolfTargettingWolfListener implements Listener {
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onWolfAttackWolf(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
-        if (event.getDamager() instanceof Wolf && event.getEntity() instanceof Wolf) {
-            Wolf damager = (Wolf) event.getDamager();
-            Wolf victim = (Wolf) event.getEntity();
-            if (damager.getOwner() != null && damager.getOwner() != null) {
-                try {
-                    boolean damagerPvpEnabled = SmartCache.getPlayerData(damager.getOwner().getUniqueId()).isPvpEnabled();
-                    boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
-                    if (!victimPvpEnabled || !damagerPvpEnabled) {
-                        damager.setAngry(false);
-                        event.setCancelled(true);
-                    }
-                } catch (NullPointerException e) {
-                    return;
-                }
-            }
-        }
-    }
-
-}

src/main/java/eu/endermite/togglepvp/players/SmartCache.java

@@ -9,7 +9,7 @@ import java.util.UUID;
 
 public class SmartCache {
 
-    public static void runSmartCache() {
+    public void runSmartCache() {
         Bukkit.getScheduler().runTaskTimerAsynchronously(TogglePvp.getPlugin(), () -> {
             // Refresh cache timer if player is online
             for (Map.Entry<UUID, PlayerData> e : TogglePvp.getPlugin().getPlayerManager().getPlayerList().entrySet()) {
@@ -29,7 +29,7 @@ public class SmartCache {
         }, 100, 100);
     }
 
-    public static PlayerData getPlayerData(UUID uuid) {
+    public PlayerData getPlayerData(UUID uuid) {
         // Try to get data from cache and refresh it
         try {
             TogglePvp.getPlugin().getPlayerManager().refreshPlayersCacheTime(uuid);
@@ -47,7 +47,7 @@ public class SmartCache {
         }
     }
 
-    public static void setPlayerPvpState(UUID uuid, boolean state) {
+    public void setPlayerPvpState(UUID uuid, boolean state) {
         // If player is in cache update that
         if (TogglePvp.getPlugin().getPlayerManager().getPlayer(uuid) != null) {
             TogglePvp.getPlugin().getPlayerManager().getPlayer(uuid).setPvpEnabled(state);