Merge remote-tracking branch 'origin/master'

pom.xml

@@ -68,7 +68,7 @@
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
-            <version>1.16.2-R0.1-SNAPSHOT</version>
+            <version>1.16.5-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
         <dependency>

readme.md

@@ -1,23 +1,21 @@
 <h2>TogglePvP ⚔</h2>
 
-Plugin is under heavy development and things will change often.
-
 Use Issues section to report bugs or submit suggestions.
 
 <h3>Commands</h3>
-Permission: <code>togglepvp.command</code> (given by default) :
+Permission: <code>togglepvp.command</code> (given by default to everyone) :
 <ul>
 <li>/pvp help- displays help message</li>
 </ul>
 
-Permission: <code>togglepvp.command.toggle</code> (given by default) :
+Permission: <code>togglepvp.command.toggle</code> (given by default to everyone) :
 <ul>
 <li>/pvp toggle - toggles PvP</li>
 <li>/pvp on - enables PvP (aliases: enable)</li>
 <li>/pvp off - disables PvP (aliases: disable)</li>
 </ul>
 
-Permission: <code>togglepvp.command.toggle.others</code> (given by default) :
+Permission: <code>togglepvp.command.toggle.others</code> (given by default to ops) :
 <ul>
 <li>/pvp toggle [player] - toggles other player's PvP</li>
 <li>/pvp on [player] - enables other player's PvP (aliases: enable)</li>
@@ -37,11 +35,9 @@ There is also a feature that disallows pouring lava or using
 flint and steel nearby players with disabled pvp. You can
 either disable it in config or set its radius.
 
-Tamed wolves will not attack players with pvp off.
+All the protections are extended to tameable entities (pets) that set player's uuid as their owner on tame.
+
+Pets will not attack players with pvp off or if their owner has pvp off.
 
-<h3>TODO</h3>
-<ul>
-<li>combat timer - deny players changing pvp state mid combat</li>
-</ul>
 
 

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() {
@@ -33,10 +34,11 @@ public final class TogglePvp extends JavaPlugin {
             getLogger().severe("Error with accessing database. Check if server has write rights.");
             getLogger().severe("Plugin will now disable.");
             getServer().getPluginManager().disablePlugin(this);
+            return;
         }
         playerManager = new PlayerManager();
-
+        smartCache = new SmartCache();
-        SmartCache.runSmartCache();
+        smartCache.runSmartCache();
 
         // Register listeners
         Reflections reflections = new Reflections(new String[]{"eu.endermite.togglepvp"});
@@ -80,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/commands/HelpCommand.java

@@ -4,7 +4,6 @@ import eu.endermite.togglepvp.TogglePvp;
 import eu.endermite.togglepvp.util.PluginMessages;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
-
 import java.util.ArrayList;
 import java.util.List;
 

src/main/java/eu/endermite/togglepvp/commands/MainCommand.java

@@ -2,14 +2,30 @@ package eu.endermite.togglepvp.commands;
 
 import eu.endermite.togglepvp.TogglePvp;
 import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class MainCommand implements TabExecutor {
 
+    private final HashMap<String, String> subCommands = new HashMap<>();
+
+    public MainCommand() {
+        subCommands.put("help", "togglepvp.command");
+        subCommands.put("toggle", "togglepvp.command.toggle");
+        subCommands.put("on", "togglepvp.command.toggle");
+        subCommands.put("enable", "togglepvp.command.toggle");
+        subCommands.put("off", "togglepvp.command.toggle");
+        subCommands.put("disable", "togglepvp.command.toggle");
+        subCommands.put("reload", "togglepvp.command.reload");
+    }
+
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (sender.hasPermission("togglepvp.command")) {
@@ -48,39 +64,29 @@ public class MainCommand implements TabExecutor {
     @Override
     public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
         List<String> commands = new ArrayList<>();
-        String arg1 = args[0].toLowerCase();
-
-        List<String> noPerm = new ArrayList<>();
-        noPerm.add("help");
-
-        List<String> reloadPerm = new ArrayList<>();
-        reloadPerm.add("reload");
-
-        List<String> togglePerm = new ArrayList<>();
-        togglePerm.add("toggle");
-        togglePerm.add("on");
-        togglePerm.add("enable");
-        togglePerm.add("off");
-        togglePerm.add("disable");
-
         if (args.length == 1) {
-            for (String noPermCmd : noPerm) {
+            String arg1 = args[0].toLowerCase();
-                if (noPermCmd.startsWith(arg1))
+            for (Map.Entry<String, String> entry : subCommands.entrySet()) {
-                    commands.add(noPermCmd);
+                if (entry.getKey().toLowerCase().startsWith(arg1) && sender.hasPermission(entry.getValue()))
-            }
+                    commands.add(entry.getKey());
-            if (sender.hasPermission("togglepvp.command.toggle")) {
-                for (String togglePermCmd : togglePerm) {
-                    if (togglePermCmd.startsWith(arg1))
-                        commands.add(togglePermCmd);
-                }
-            }
-            if (sender.hasPermission("togglepvp.command.reload")) {
-                for (String reloadPermCmd : reloadPerm) {
-                    if (reloadPermCmd.startsWith(arg1))
-                        commands.add(reloadPermCmd);
             }
+            return commands;
+        } else if (args.length == 2 && sender.hasPermission("togglepvp.command.toggle")) {
+            switch (args[0].toLowerCase()) {
+                default:
+                    break;
+                case "toggle":
+                case "on":
+                case "enable":
+                case "off":
+                case "disable":
+                    for (Player player : Bukkit.getOnlinePlayers()) {
+                        commands.add(player.getName());
                     }
+                    break;
             }
             return commands;
         }
+        return null;
+    }
 }

src/main/java/eu/endermite/togglepvp/commands/PvpToggleCommand.java

@@ -3,10 +3,8 @@ package eu.endermite.togglepvp.commands;
 import eu.endermite.togglepvp.TogglePvp;
 import eu.endermite.togglepvp.util.CombatTimer;
 import eu.endermite.togglepvp.util.PluginMessages;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
@@ -17,9 +15,8 @@ public class PvpToggleCommand {
         Bukkit.getScheduler().runTaskAsynchronously(TogglePvp.getPlugin(), () -> {
 
             if (!sender.hasPermission("togglepvp.command.toggle")) {
-                String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+                String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                sender.sendMessage(message);
-                sender.spigot().sendMessage(component);
                 return;
             }
 
@@ -40,16 +37,14 @@ public class PvpToggleCommand {
                     } else {
                         message = PluginMessages.parseMessage(TogglePvp.getPlugin().getConfigCache().getPvp_disabled());
                     }
-                    BaseComponent[] component = TextComponent.fromLegacyText(message);
+                    player.sendMessage(message);
-                    player.spigot().sendMessage(ChatMessageType.CHAT, component);
                 } else {
                     sender.sendMessage("Try /pvp toggle <player>");
                 }
             } else if (args.length == 2) {
                 if (!sender.hasPermission("togglepvp.command.toggle.others")) {
-                    String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+                    String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-                    BaseComponent[] component = TextComponent.fromLegacyText(message);
+                    sender.sendMessage(message);
-                    sender.spigot().sendMessage(component);
                     return;
                 }
 
@@ -86,9 +81,8 @@ public class PvpToggleCommand {
 
     public static void enable(CommandSender sender, String[] args) {
         if (!sender.hasPermission("togglepvp.command.toggle")) {
-            String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+            String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-            BaseComponent[] component = TextComponent.fromLegacyText(message);
+            sender.sendMessage(message);
-            sender.spigot().sendMessage(component);
             return;
         }
         if (args.length == 1) {
@@ -100,16 +94,14 @@ public class PvpToggleCommand {
                 }
                 TogglePvp.getPlugin().getPlayerManager().setPlayerPvpState(player.getUniqueId(), true);
                 String message = PluginMessages.parseMessage(TogglePvp.getPlugin().getConfigCache().getPvp_enabled());
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                player.sendMessage(message);
-                player.spigot().sendMessage(ChatMessageType.CHAT, component);
             } else {
                 sender.sendMessage("Try /pvp enable <player>");
             }
         } else if (args.length == 2) {
             if (!sender.hasPermission("togglepvp.command.toggle.others")) {
-                String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+                String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                sender.sendMessage(message);
-                sender.spigot().sendMessage(component);
                 return;
             }
             if (sender instanceof Player) {
@@ -138,9 +130,8 @@ public class PvpToggleCommand {
 
     public static void disable(CommandSender sender, String[] args) {
         if (!sender.hasPermission("togglepvp.command.toggle")) {
-            String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+            String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-            BaseComponent[] component = TextComponent.fromLegacyText(message);
+            sender.sendMessage(message);
-            sender.spigot().sendMessage(component);
             return;
         }
         if (args.length == 1) {
@@ -152,16 +143,14 @@ public class PvpToggleCommand {
                 }
                 TogglePvp.getPlugin().getPlayerManager().setPlayerPvpState(player.getUniqueId(), false);
                 String message = PluginMessages.parseMessage(TogglePvp.getPlugin().getConfigCache().getPvp_disabled());
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                player.sendMessage(message);
-                player.spigot().sendMessage(ChatMessageType.CHAT, component);
             } else {
                 sender.sendMessage("Try /pvp disable <player>");
             }
         } else if (args.length == 2) {
             if (!sender.hasPermission("togglepvp.command.toggle.others")) {
                 String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                sender.sendMessage(message);
-                sender.spigot().sendMessage(component);
                 return;
             }
             if (sender instanceof Player) {

src/main/java/eu/endermite/togglepvp/commands/ReloadCommand.java

@@ -1,9 +1,8 @@
 package eu.endermite.togglepvp.commands;
 
 import eu.endermite.togglepvp.TogglePvp;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 
 public class ReloadCommand {
@@ -12,9 +11,8 @@ public class ReloadCommand {
 
         Bukkit.getScheduler().runTaskAsynchronously(TogglePvp.getPlugin(), () -> {
             if (!sender.hasPermission("togglepvp.command.reload")) {
-                String message = TogglePvp.getPlugin().getConfigCache().getNo_permission();
+                String message = ChatColor.translateAlternateColorCodes('&', TogglePvp.getPlugin().getConfigCache().getNo_permission());
-                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                sender.sendMessage(message);
-                sender.spigot().sendMessage(component);
                 return;
             }
             TogglePvp.getPlugin().reloadPluginConfig(sender);

src/main/java/eu/endermite/togglepvp/config/ConfigCache.java

@@ -28,6 +28,7 @@ public class ConfigCache {
     @Getter private final String entering_combat;
     @Getter private final String leaving_combat;
     @Getter final String cant_do_that_during_combat;
+    @Getter final boolean only_owner_can_interact_with_pet;
 
     public ConfigCache() {
 
@@ -45,7 +46,7 @@ public class ConfigCache {
         this.punish_for_combat_logout = config.getBoolean("settings.punish_for_combat_logout.enabled", true);
         this.punish_for_combat_logout_announce = config.getBoolean("settings.punish_for_combat_logout.announce", true);
         this.punish_for_combat_logout_message = config.getString("settings.punish_for_combat_logout.message", "&f%player% logged out while in combat. What a loser.");
-
+        this.only_owner_can_interact_with_pet = config.getBoolean("settings.only_owner_can_interact_with_pet", false);
         this.cache_time = config.getLong("settings.cache_time", 30L);
 
         // Messages
@@ -62,6 +63,5 @@ public class ConfigCache {
         this.entering_combat = config.getString("messages.entering_combat", "&cEntering combat");
         this.leaving_combat = config.getString("messages.leaving_combat", "&cLeaving combat");
         this.cant_do_that_during_combat = config.getString("messages.cant_do_that_during_combat", "&cYou can't do that while in combat!");
-
     }
 }

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

@@ -0,0 +1,31 @@
+package eu.endermite.togglepvp.listeners.pets;
+
+import eu.endermite.togglepvp.TogglePvp;
+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 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;
+
+        Tameable tameable = (Tameable) event.getRightClicked();
+        if (tameable.getOwner() == null)
+            return;
+
+        if (tameable.getOwner().getUniqueId().equals(event.getPlayer().getUniqueId()))
+            return;
+
+        event.setCancelled(true);
+
+    }
+}

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/PlayerHitByExplosionListener.java

@@ -2,10 +2,13 @@ package eu.endermite.togglepvp.listeners.player;
 
 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.*;
+import org.bukkit.entity.EnderCrystal;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.EntityType;
 import org.bukkit.entity.minecart.ExplosiveMinecart;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -29,23 +32,24 @@ public class PlayerHitByExplosionListener implements Listener {
             Player victim = (Player) event.getEntity();
             try {
                 UUID damageruuid = UUID.fromString(event.getDamager().getMetadata("PLAYEREXPLODED").get(0).asString());
-                if (!victim.getUniqueId().equals(damageruuid)) {
+                if (victim.getUniqueId().equals(damageruuid))
+                    return;
+
                 ConfigCache config = TogglePvp.getPlugin().getConfigCache();
-                    boolean damagerPvpEnabled = SmartCache.getPlayerData(damageruuid).isPvpEnabled();
+                if (!TogglePvp.getPlugin().getSmartCache().getPlayerData(damageruuid).isPvpEnabled()) {
-                    if (!damagerPvpEnabled) {
                     PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_attacker());
                     event.setCancelled(true);
                     return;
                 }
-                    boolean victimPvpEnabled = TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId());
+                if (!TogglePvp.getPlugin().getPlayerManager().getPlayerPvPState(victim.getUniqueId())) {
-                    if (!victimPvpEnabled) {
                     PluginMessages.sendActionBar(damageruuid, config.getCannot_attack_victim());
                     event.setCancelled(true);
                     return;
                 }
                 CombatTimer.refreshPlayersCombatTime(damageruuid, victim.getUniqueId());
+
+            } catch (NullPointerException | IndexOutOfBoundsException ignored) {
             }
-            } catch (NullPointerException | IndexOutOfBoundsException ignored) {}
         }
     }
 
@@ -78,13 +82,14 @@ public class PlayerHitByExplosionListener implements Listener {
             TNTPrimed tntPrimed = (TNTPrimed) event.getEntity();
             if (tntPrimed.getSource() instanceof Player) {
                 Player damager = (Player) tntPrimed.getSource();
-                tntPrimed.setMetadata("PLAYEREXPLODED",new FixedMetadataValue( TogglePvp.getPlugin(), damager.getUniqueId().toString()));
+                tntPrimed.setMetadata("PLAYEREXPLODED", new FixedMetadataValue(TogglePvp.getPlugin(), damager.getUniqueId().toString()));
             } else if (tntPrimed.getSource() instanceof TNTPrimed) {
                 try {
                     TNTPrimed sourceTnt = (TNTPrimed) tntPrimed.getSource();
                     String damagerUuid = sourceTnt.getMetadata("PLAYEREXPLODED").get(0).asString();
-                    tntPrimed.setMetadata("PLAYEREXPLODED", new FixedMetadataValue( TogglePvp.getPlugin(), damagerUuid));
+                    tntPrimed.setMetadata("PLAYEREXPLODED", new FixedMetadataValue(TogglePvp.getPlugin(), damagerUuid));
-                }catch (NullPointerException ignored) {}
+                } catch (NullPointerException ignored) {
+                }
             }
         }
     }
@@ -97,7 +102,7 @@ public class PlayerHitByExplosionListener implements Listener {
     public void onPlayerPlacedTntMinecart(org.bukkit.event.entity.EntityPlaceEvent event) {
         if (event.getEntityType().equals(EntityType.MINECART_TNT)) {
             if (event.getPlayer() != null) {
-                event.getEntity().setMetadata("PLAYEREXPLODED", new FixedMetadataValue( TogglePvp.getPlugin(), event.getPlayer().getUniqueId().toString()));
+                event.getEntity().setMetadata("PLAYEREXPLODED", new FixedMetadataValue(TogglePvp.getPlugin(), event.getPlayer().getUniqueId().toString()));
             }
         }
     }
@@ -109,7 +114,7 @@ public class PlayerHitByExplosionListener implements Listener {
     public void onPlayerNudgedTntMinecart(org.bukkit.event.vehicle.VehicleEntityCollisionEvent event) {
         if (event.getVehicle() instanceof ExplosiveMinecart && event.getEntity() instanceof Player) {
             Player damager = (Player) event.getEntity();
-            event.getVehicle().setMetadata("PLAYEREXPLODED", new FixedMetadataValue( TogglePvp.getPlugin(), damager.getUniqueId().toString()));
+            event.getVehicle().setMetadata("PLAYEREXPLODED", new FixedMetadataValue(TogglePvp.getPlugin(), damager.getUniqueId().toString()));
         }
     }
 

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

@@ -18,6 +18,7 @@ public class PlayerJoinAndLeaveListener implements Listener {
         Player player = event.getPlayer();
 
         PlayerData playerData = TogglePvp.getPlugin().getSqLite().getPlayerInfo(player.getUniqueId());
+
         TogglePvp.getPlugin().getPlayerManager().addPlayer(player.getUniqueId(), playerData);
     }
     /**

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) {
                         PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
                         event.setCancelled(true);
                         return;
                     }
                     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)
+            return;
+
         Location location = event.getBlock().getLocation();
         Player damager = event.getPlayer();
         double radius = config.getLava_and_fire_stopper_radius();
         BoundingBox boundingBox = BoundingBoxUtil.getBoundingBox(location, radius);
+        SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
         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 || 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;
                 }
-                    try {
+                if (!smartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled()) {
-                        boolean victimPvpEnabled = SmartCache.getPlayerData(victim.getOwner().getUniqueId()).isPvpEnabled();
-                        if (!victimPvpEnabled) {
                     PluginMessages.sendActionBar(damager, config.getCannot_attack_pets_victim());
                     event.setCancelled(true);
                     return;
                 }
                 CombatTimer.refreshPlayersCombatTime(damager.getUniqueId(), victim.getOwner().getUniqueId());
-                    } catch (NullPointerException ignored) {}
-                }
             }
         }
+
     }
 }

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());
                         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 Tameable) {
-                } else if (entity instanceof Wolf) {
+                    Tameable victim = (Tameable) entity;
-                    Wolf victim = (Wolf) 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/PlayerData.java

@@ -8,10 +8,12 @@ public class PlayerData {
 
     private long cachetime, combattime;
     private boolean pvpEnabled;
+    private boolean lastCombatCheck;
 
     public PlayerData(boolean pvpEnabled) {
         this.pvpEnabled = pvpEnabled;
         this.combattime = Instant.now().getEpochSecond()-1;
+
         refreshCachetime();
     }
 
@@ -42,4 +44,12 @@ public class PlayerData {
     public void refreshCombatTime() {
         this.combattime = Instant.now().getEpochSecond()+ TogglePvp.getPlugin().getConfigCache().getCombat_time();
     }
+
+    public boolean getLastCombatCheck() {
+        return lastCombatCheck;
+    }
+
+    public void setLastCombatCheck(boolean bool) {
+        lastCombatCheck = bool;
+    }
 }

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

@@ -1,21 +1,42 @@
 package eu.endermite.togglepvp.players;
 
 import eu.endermite.togglepvp.TogglePvp;
+import eu.endermite.togglepvp.util.CombatTimer;
+import eu.endermite.togglepvp.util.PluginMessages;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitTask;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.UUID;
 
 public class PlayerManager {
 
-    @Getter HashMap<UUID, PlayerData> playerList = new HashMap<>();
+    @Getter
+    HashMap<UUID, PlayerData> playerList = new HashMap<>();
+
+    public final BukkitTask combatTrackerTask;
 
     public PlayerManager() {
         for (Player p : Bukkit.getOnlinePlayers()) {
             PlayerData playerData = TogglePvp.getPlugin().getSqLite().getPlayerInfo(p.getUniqueId());
             playerList.put(p.getUniqueId(), playerData);
         }
+
+        combatTrackerTask = Bukkit.getScheduler().runTaskTimerAsynchronously(TogglePvp.getPlugin(), () -> {
+            for (Map.Entry<UUID, PlayerData> set : playerList.entrySet()) {
+                UUID uuid = set.getKey();
+                if (!CombatTimer.isInCombat(uuid)) {
+                    if (set.getValue().getLastCombatCheck()) {
+                        set.getValue().setLastCombatCheck(false);
+                        PluginMessages.sendActionBar(uuid, TogglePvp.getPlugin().getConfigCache().getLeaving_combat());
+                    }
+                } else {
+                    set.getValue().setLastCombatCheck(true);
+                }
+            }
+        }, 20, 20);
     }
 
     public void refreshPlayersCacheTime(UUID uuid) {
@@ -25,7 +46,7 @@ public class PlayerManager {
     public void refreshPlayersCombatTime(UUID uuid) {
         try {
             playerList.get(uuid).refreshCombatTime();
-        } catch (Exception ignored) {}
+        } catch (Exception ignored) { }
     }
 
     public PlayerData getPlayer(UUID uuid) {
@@ -36,25 +57,21 @@ public class PlayerManager {
         playerList.put(uuid, data);
     }
 
-    public void removePlayer(UUID uuid) {
-        playerList.remove(uuid);
-    }
-
     public boolean getPlayerPvPState(UUID uuid) {
-        return playerList.get(uuid).isPvpEnabled();
+        return TogglePvp.getPlugin().getSmartCache().getPlayerData(uuid).isPvpEnabled();
     }
 
     public void setPlayerPvpState(UUID uuid, boolean state) {
-        playerList.get(uuid).setPvpEnabled(state);
+        TogglePvp.getPlugin().getSmartCache().getPlayerData(uuid).setPvpEnabled(state);
     }
 
     public boolean togglePlayerPvpState(UUID uuid) {
-        boolean currentState = playerList.get(uuid).isPvpEnabled();
+        SmartCache smartCache = TogglePvp.getPlugin().getSmartCache();
-        if (currentState) {
+        if (smartCache.getPlayerData(uuid).isPvpEnabled()) {
-            playerList.get(uuid).setPvpEnabled(false);
+            smartCache.getPlayerData(uuid).setPvpEnabled(false);
             return false;
         } else {
-            playerList.get(uuid).setPvpEnabled(true);
+            smartCache.getPlayerData(uuid).setPvpEnabled(true);
             return true;
         }
     }

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);

src/main/java/eu/endermite/togglepvp/util/CombatTimer.java

@@ -1,7 +1,6 @@
 package eu.endermite.togglepvp.util;
 
 import eu.endermite.togglepvp.TogglePvp;
-import eu.endermite.togglepvp.players.SmartCache;
 import java.time.Instant;
 import java.util.UUID;
 
@@ -10,7 +9,7 @@ public class CombatTimer {
     public static void refreshPlayersCombatTime(UUID uuid) {
         try {
             long now = Instant.now().getEpochSecond();
-            long combattime = SmartCache.getPlayerData(uuid).getCombattime();
+            long combattime = TogglePvp.getPlugin().getSmartCache().getPlayerData(uuid).getCombattime();
             if (combattime < now) {
                 PluginMessages.sendActionBar(uuid, TogglePvp.getPlugin().getConfigCache().getEntering_combat());
             }
@@ -25,7 +24,7 @@ public class CombatTimer {
 
     public static boolean isInCombat(UUID uuid) {
         try {
-            long combattimer = SmartCache.getPlayerData(uuid).getCombattime();
+            long combattimer = TogglePvp.getPlugin().getSmartCache().getPlayerData(uuid).getCombattime();
             long now = Instant.now().getEpochSecond();
             return combattimer > now;
         } catch (Exception e) {

src/main/java/eu/endermite/togglepvp/util/DatabaseSQLite.java

@@ -41,16 +41,12 @@ public class DatabaseSQLite {
         try {
             conn = DriverManager.getConnection(url);
             System.out.println("Connection to SQLite has been established.");
-        } catch (SQLException e) {
-            System.out.println(e.getMessage());
-        } finally {
-            try {
             if (conn != null) {
                 conn.close();
+                return true;
             }
-            } catch (SQLException ex) {
+        } catch (SQLException e) {
-                System.out.println(ex.getMessage());
+            System.out.println(e.getMessage());
-            }
         }
         return false;
     }
@@ -72,8 +68,9 @@ public class DatabaseSQLite {
             String sql = "SELECT * FROM `players` WHERE `player_uuid` = '" + uuid.toString() + "';";
             statement.execute(sql);
             ResultSet result = statement.getResultSet();
+            boolean state = result.getBoolean("pvpenabled");
             conn.close();
-            return new PlayerData(result.getBoolean("pvpenabled"));
+            return new PlayerData(state);
         } catch (SQLException throwables) {
             throwables.printStackTrace();
         }

src/main/resources/config.yml

@@ -11,6 +11,10 @@ settings:
   # You may want to keep it disabled because players with pvp off can use it to attack players with pvp on
   channeling_enchant_disabled: false
 
+  # Makes it so only pet owner can interact with it.
+  # Useful if you don't want people renaming other people's pets.
+  only_owner_can_interact_with_pet: false
+
   # Time (in seconds) to keep player in combat
   combat_time: 25
 

src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
 name: TogglePvP
 version: ${project.version}
-main: eu.endermite.togglepvp.TogglePvP
+main: eu.endermite.togglepvp.TogglePvp
 authors: [YouHaveTrouble]
 api-version: 1.13
 description: PvP toggle plugin