Initial commit

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

@@ -0,0 +1,73 @@
+package eu.endermite.togglepvp;
+
+import eu.endermite.togglepvp.commands.MainCommand;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.listeners.*;
+import eu.endermite.togglepvp.listeners.player.*;
+import eu.endermite.togglepvp.players.PlayerManager;
+import eu.endermite.togglepvp.util.DatabaseSQLite;
+import lombok.Getter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+
+public final class TogglePvP extends JavaPlugin {
+
+    @Getter private static TogglePvP plugin;
+    private ConfigCache configCache;
+    private PlayerManager playerManager;
+    private DatabaseSQLite sqLite;
+
+    @Override
+    public void onEnable() {
+        plugin = this;
+        reloadPluginConfig();
+        File dbFile = new File("plugins/TogglePvP");
+        sqLite = new DatabaseSQLite("jdbc:sqlite:plugins/TogglePvP/TogglePvP.db", dbFile);
+        sqLite.createDatabaseFile();
+        sqLite.testConnection();
+        playerManager = new PlayerManager();
+
+        getServer().getPluginManager().registerEvents(new PlayerJoinAndLeaveListener(), this);
+        getServer().getPluginManager().registerEvents(new PlayerAttackListener(), this);
+        getServer().getPluginManager().registerEvents(new PlayerHitByProjectileListener(), this);
+        getServer().getPluginManager().registerEvents(new AreaEffectCloudApplyListener(), this);
+        getServer().getPluginManager().registerEvents(new PlayerHitByLightningListener(), this);
+        getServer().getPluginManager().registerEvents(new LightningBlockIgniteListener(), this);
+        getServer().getPluginManager().registerEvents(new PlayerHitByFireworkListener(), this);
+        getServer().getPluginManager().registerEvents(new FishingListener(), this);
+        getServer().getPluginManager().registerEvents(new LavaDumpAndIgniteListener(), this);
+        getServer().getPluginManager().registerEvents(new WolfTargettingListener(), this);
+
+        getCommand("pvp").setExecutor(new MainCommand());
+        getCommand("pvp").setTabCompleter(new MainCommand());
+    }
+
+    public void reloadPluginConfig() {
+        saveDefaultConfig();
+        reloadConfig();
+        configCache = new ConfigCache();
+    }
+
+    public void reloadPluginConfig(CommandSender commandSender) {
+        getServer().getScheduler().runTaskAsynchronously(this, () -> {
+            reloadPluginConfig();
+            commandSender.sendMessage("TogglePvP configuration reloaded.");
+        });
+    }
+
+    public ConfigCache getConfigCache() {
+        return configCache;
+    }
+
+    public PlayerManager getPlayerManager() {
+        return playerManager;
+    }
+
+    public DatabaseSQLite getSqLite() {return sqLite;}
+
+
+
+
+}

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

@@ -0,0 +1,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.CommandSender;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class HelpCommand {
+
+    public static void help(CommandSender sender, String[] args) {
+        Bukkit.getScheduler().runTaskAsynchronously(TogglePvP.getPlugin(), () -> {
+
+            List<String> helpPage = new ArrayList<>();
+
+            helpPage.add(PluginMessages.parseMessage("&b&m        &bTogglePvP Help&b&m        "));
+            helpPage.add(PluginMessages.parseMessage("&9/pvp &b&lhelp &f- shows this message"));
+            if (sender.hasPermission("togglepvp.command.toggle")) {
+                helpPage.add(PluginMessages.parseMessage("&9/pvp &b&l[on/off] &f- enables or disables PvP"));
+                helpPage.add(PluginMessages.parseMessage("&9/pvp &b&ltoggle &f- toggles PvP status"));
+            }
+            String[] helpReady = helpPage.toArray(new String[0]);
+            sender.sendMessage(helpReady);
+
+        });
+    }
+
+}

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

@@ -0,0 +1,73 @@
+package eu.endermite.togglepvp.commands;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        if (sender.hasPermission("togglepvp.command"))
+            if (args.length >= 1) {
+                switch (args[0].toLowerCase()) {
+                    case "help":
+                        HelpCommand.help(sender, args);
+                        break;
+                    case "toggle":
+                        PvpToggleCommand.toggle(sender, args);
+                        break;
+                    case "on":
+                    case "enable":
+                        PvpToggleCommand.enable(sender, args);
+                        break;
+                    case "off":
+                    case "disable":
+                        PvpToggleCommand.disable(sender, args);
+                        break;
+                    default:
+                        sender.sendMessage(PluginMessages.parseMessage(TogglePvP.getPlugin().getConfigCache().getNo_such_command()));
+                        break;
+                }
+            }
+
+        return true;
+    }
+
+    @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> togglePerm = new ArrayList<>();
+        togglePerm.add("toggle");
+        togglePerm.add("on");
+        togglePerm.add("enable");
+        togglePerm.add("off");
+        togglePerm.add("disable");
+
+        if (args.length == 1) {
+            if (sender.hasPermission("togglepvp.command.toggle")) {
+                for (String noPermCmd : noPerm) {
+                    if (noPermCmd.startsWith(arg1))
+                        commands.add(noPermCmd);
+                }
+                for (String togglePermCmd : togglePerm) {
+                    if (togglePermCmd.startsWith(arg1))
+                        commands.add(togglePermCmd);
+                }
+            }
+        }
+
+        return commands;
+    }
+}

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

@@ -0,0 +1,86 @@
+package eu.endermite.togglepvp.commands;
+
+import eu.endermite.togglepvp.TogglePvP;
+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.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PvpToggleCommand {
+
+    public static void toggle(CommandSender sender, String[] args) {
+
+        Bukkit.getScheduler().runTaskAsynchronously(TogglePvP.getPlugin(), () -> {
+
+            if (!sender.hasPermission("togglepvp.command.toggle")) {
+                String message = TogglePvP.getPlugin().getConfigCache().getNo_permission();
+                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                sender.spigot().sendMessage(component);
+                return;
+            }
+
+            if (args.length == 1) {
+                if (sender instanceof Player) {
+                    Player player = (Player) sender;
+                    boolean currentState = TogglePvP.getPlugin().getPlayerManager().togglePlayerPvpState(player);
+
+                    String message = "";
+                    if (currentState) {
+                        message = PluginMessages.parseMessage(TogglePvP.getPlugin().getConfigCache().getPvp_enabled());
+                    } else {
+                        message = PluginMessages.parseMessage(TogglePvP.getPlugin().getConfigCache().getPvp_disabled());
+                    }
+                    BaseComponent[] component = TextComponent.fromLegacyText(message);
+                    player.spigot().sendMessage(ChatMessageType.CHAT, component);
+                } else {
+                    sender.sendMessage("Try /pvp toggle <player>");
+                }
+            }
+
+        });
+    }
+
+    public static void enable(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("togglepvp.command.toggle")) {
+            String message = TogglePvP.getPlugin().getConfigCache().getNo_permission();
+            BaseComponent[] component = TextComponent.fromLegacyText(message);
+            sender.spigot().sendMessage(component);
+            return;
+        }
+        if (args.length == 1) {
+            if (sender instanceof Player) {
+                Player player = (Player) sender;
+                TogglePvP.getPlugin().getPlayerManager().setPlayerPvpState(player, true);
+                String message = PluginMessages.parseMessage(TogglePvP.getPlugin().getConfigCache().getPvp_enabled());
+                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                player.spigot().sendMessage(ChatMessageType.CHAT, component);
+            } else {
+                sender.sendMessage("Try /pvp enable <player>");
+            }
+        }
+    }
+
+    public static void disable(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("togglepvp.command.toggle")) {
+            String message = TogglePvP.getPlugin().getConfigCache().getNo_permission();
+            BaseComponent[] component = TextComponent.fromLegacyText(message);
+            sender.spigot().sendMessage(component);
+            return;
+        }
+        if (args.length == 1) {
+            if (sender instanceof Player) {
+                Player player = (Player) sender;
+                TogglePvP.getPlugin().getPlayerManager().setPlayerPvpState(player, false);
+                String message = PluginMessages.parseMessage(TogglePvP.getPlugin().getConfigCache().getPvp_disabled());
+                BaseComponent[] component = TextComponent.fromLegacyText(message);
+                player.spigot().sendMessage(ChatMessageType.CHAT, component);
+            } else {
+                sender.sendMessage("Try /pvp disable <player>");
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package eu.endermite.togglepvp.config;
+
+import eu.endermite.togglepvp.TogglePvP;
+import lombok.Getter;
+import org.bukkit.configuration.Configuration;
+
+public class ConfigCache {
+
+    @Getter private final boolean pvp_enabled_by_default, lava_and_fire_stopper_enabled;
+    @Getter private final String pvp_enabled, pvp_disabled, cannot_attack_victim, cannot_attack_attacker, no_permission, no_such_command;
+    @Getter private final double lava_and_fire_stopper_radius;
+
+    public ConfigCache() {
+
+        Configuration config = TogglePvP.getPlugin().getConfig();
+
+        // Settings
+        this.pvp_enabled_by_default = config.getBoolean("settings.pvp_enabled_by_default", false);
+
+        this.lava_and_fire_stopper_enabled = config.getBoolean("settings.lava_and_fire_stopper.enabled", true);
+        this.lava_and_fire_stopper_radius = config.getDouble("settings.lava_and_fire_stopper.radius", 2.5);
+
+        // Messages
+        this.pvp_enabled = config.getString("messages.pvp_enabled", "&cYou enabled PvP!");
+        this.pvp_disabled = config.getString("messages.pvp_disabled", "&cYou disabled PvP!");
+        this.cannot_attack_victim = config.getString("messages.cannot_attack_victim", "&cYou can't attack players that have PvP turned off!");
+        this.cannot_attack_attacker = config.getString("messages.cannot_attack_attacker", "&cYou can't attack players while you have PvP turned off!");
+        this.no_permission = config.getString("messages.no_permission", "&cYou don't have permission to use that.");
+        this.no_such_command = config.getString("messages.no_such_command", "&cNo such command.");
+    }
+}

src/main/java/eu/endermite/togglepvp/listeners/WolfTargettingListener.java

@@ -0,0 +1,39 @@
+package eu.endermite.togglepvp.listeners;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.Fox;
+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;
+
+public class WolfTargettingListener implements Listener {
+
+    @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) {
+                    Player victim = (Player) event.getTarget();
+                    boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                    if (!victimPvpEnabled) {
+                        event.setCancelled(true);
+                    }
+                }
+            }
+        } else if (event.getEntity() instanceof Fox) {
+            Fox fox = (Fox) event.getEntity();
+            if (fox.getFirstTrustedPlayer() != null) {
+                if (event.getTarget() instanceof Player) {
+                    Player victim = (Player) event.getTarget();
+                    boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                    if (!victimPvpEnabled) {
+                        event.setCancelled(true);
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.Iterator;
+
+public class AreaEffectCloudApplyListener implements Listener {
+
+    @EventHandler(ignoreCancelled = true)
+    public void onCloudEffects(AreaEffectCloudApplyEvent event) {
+
+        PotionEffectType potionEffectType = event.getEntity().getBasePotionData().getType().getEffectType();
+
+        if (potionEffectType == null)
+            return;
+
+        if(event.getEntity().getSource() instanceof Player) {
+            if (potionEffectType.equals(PotionEffectType.BLINDNESS) ||
+                    potionEffectType.equals(PotionEffectType.CONFUSION) ||
+                    potionEffectType.equals(PotionEffectType.HARM) ||
+                    potionEffectType.equals(PotionEffectType.HUNGER) ||
+                    potionEffectType.equals(PotionEffectType.POISON) ||
+                    potionEffectType.equals(PotionEffectType.SLOW_DIGGING) ||
+                    potionEffectType.equals(PotionEffectType.WEAKNESS) ||
+                    potionEffectType.equals(PotionEffectType.WITHER)) {
+
+                Iterator<LivingEntity> it = event.getAffectedEntities().iterator();
+                while(it.hasNext()) {
+                    LivingEntity entity = it.next();
+                    if(entity instanceof Player) {
+                        Player damager = (Player) event.getEntity().getSource();
+                        Player victim = (Player) entity;
+
+                        ConfigCache config = TogglePvP.getPlugin().getConfigCache();
+
+                        boolean damagerPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(damager);
+
+                        if (!damagerPvpEnabled) {
+                            it.remove();
+                            PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                            return;
+                        }
+                        boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                        if (!victimPvpEnabled) {
+                            it.remove();
+                            PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,37 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class FishingListener implements Listener {
+
+    /**
+     * Prevents hooking players with disabled pvp with fishing rod
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onFish(org.bukkit.event.player.PlayerFishEvent event) {
+        if (event.getCaught() instanceof Player) {
+            Player damager = event.getPlayer();
+            Player victim = (Player) event.getCaught();
+
+            ConfigCache config = TogglePvP.getPlugin().getConfigCache();
+            boolean damagerPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(damager);
+            boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+            if (!damagerPvpEnabled) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                return;
+            }
+            if (!victimPvpEnabled) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,99 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.util.BoundingBox;
+
+public class LavaDumpAndIgniteListener implements Listener {
+
+    private ConfigCache config = TogglePvP.getPlugin().getConfigCache();
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onLavaDump(org.bukkit.event.player.PlayerBucketEmptyEvent event) {
+
+        if (!TogglePvP.getPlugin().getConfigCache().isLava_and_fire_stopper_enabled())
+            return;
+
+        Location location = event.getBlockClicked().getLocation();
+        Player damager = event.getPlayer();
+        double radius = config.getLava_and_fire_stopper_radius();
+        BoundingBox boundingBox = 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);
+                    if (!damagerPvpEnabled) {
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                        event.setCancelled(true);
+                        return;
+                    }
+                    boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                    if (!victimPvpEnabled) {
+                        PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onIgnite(org.bukkit.event.block.BlockIgniteEvent event) {
+
+        if (!TogglePvP.getPlugin().getConfigCache().isLava_and_fire_stopper_enabled())
+            return;
+
+        if (event.getPlayer() !=null) {
+            Location location = event.getBlock().getLocation();
+            Player damager = event.getPlayer();
+            double radius = config.getLava_and_fire_stopper_radius();
+            BoundingBox boundingBox = 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);
+                        if (!damagerPvpEnabled) {
+                            PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                            event.setCancelled(true);
+                            return;
+                        }
+                        boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                        if (!victimPvpEnabled) {
+                            PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+                            event.setCancelled(true);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+
+    }
+
+
+    private BoundingBox getBoundingBox(Location location, double radius) {
+
+        double x1 = location.getX()+radius;
+        double y1 = location.getY()+radius;
+        double z1 = location.getZ()+radius;
+
+        double x2 = location.getX()-radius;
+        double y2 = location.getY()-radius;
+        double z2 = location.getZ()-radius;
+
+        return new BoundingBox(x1, y1, z1, x2, y2, z2);
+
+    }
+
+}

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

@@ -0,0 +1,36 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LightningStrike;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class LightningBlockIgniteListener implements Listener {
+
+    /**
+     * Lightning strikes from channeling enchant won't ignite blocks if player with pvp off is in radius
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockIgnite(org.bukkit.event.block.BlockIgniteEvent event) {
+
+        if (event.getIgnitingEntity() instanceof LightningStrike && event.getIgnitingEntity().getMetadata("TRIDENT").size() >= 1) {
+            LightningStrike lightningStrike = (LightningStrike) event.getIgnitingEntity();
+
+            for (Entity entity : lightningStrike.getNearbyEntities(2,2,2)) {
+                if (entity instanceof Player) {
+                    Player player = (Player) entity;
+
+                    if (!TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(player)) {
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,43 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class PlayerAttackListener implements Listener {
+
+    /**
+     * Cancels basic attacks done to player with pvp off
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerAttack(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        Entity damagerEntity = event.getDamager();
+        Entity victimEntity = event.getEntity();
+
+        if (damagerEntity instanceof Player && victimEntity instanceof Player) {
+            Player damager = (Player) damagerEntity;
+            Player victim = (Player) victimEntity;
+
+            ConfigCache config = TogglePvP.getPlugin().getConfigCache();
+
+            boolean damagerPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(damager);
+            boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+
+            if (!damagerPvpEnabled) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                return;
+            }
+            if (!victimPvpEnabled) {
+                event.setCancelled(true);
+                PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class PlayerHitByFireworkListener 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 Player) {
+            Player victim = (Player) event.getEntity();
+            Firework firework = (Firework) event.getDamager();
+            if (firework.getShooter() instanceof Player) {
+                Player damager = (Player) firework.getShooter();
+                if (damager == victim) {
+                    return;
+                }
+                boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+                if (!victimPvpEnabled) {
+                    event.setCancelled(true);
+                }
+
+            }
+
+        }
+    }
+
+
+}

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

@@ -0,0 +1,41 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.LightningStrike;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.weather.LightningStrikeEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+
+/**
+ * Listen for lightning strikes and tag the trident spawned ones.
+ * Idea from aasmus' PvPToggle plugin
+ */
+public class PlayerHitByLightningListener implements Listener {
+
+    /**
+     * Cancels damage from lightning strike caused by channeling for players with pvp off
+     */
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerLightningDamage(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof LightningStrike && event.getDamager().getMetadata("TRIDENT").size() >= 1 && event.getEntity() instanceof Player) {
+            Player victim = (Player) event.getEntity();
+            boolean victimPvpEnabled = TogglePvP.getPlugin().getPlayerManager().getPlayerPvPState(victim);
+            if (!victimPvpEnabled) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    /**
+     * Tags the lightning strike
+     */
+    @EventHandler(ignoreCancelled = true)
+    public void onLightningStrike(LightningStrikeEvent event){
+        if(event.getCause() == LightningStrikeEvent.Cause.TRIDENT){
+            event.getLightning().setMetadata("TRIDENT", new FixedMetadataValue(TogglePvP.getPlugin(), event.getLightning().getLocation()));
+        }
+    }
+
+}

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

@@ -0,0 +1,51 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import eu.endermite.togglepvp.config.ConfigCache;
+import eu.endermite.togglepvp.util.PluginMessages;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class PlayerHitByProjectileListener implements Listener {
+
+    /**
+     * Cancels damage done by projectiles to player with pvp off
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerHitProjectile(org.bukkit.event.entity.EntityDamageByEntityEvent event) {
+
+        if (event.getEntity() instanceof Player && event.getDamager() instanceof Projectile) {
+            Projectile projectile = (Projectile) event.getDamager();
+            if (projectile.getShooter() instanceof Player) {
+                Player damager = (Player) projectile.getShooter();
+                Player victim = (Player) event.getEntity();
+
+                // Ender pearls and other self-damage
+                if (damager == victim) {
+                    return;
+                }
+
+                ConfigCache config = TogglePvP.getPlugin().getConfigCache();
+
+                boolean damagerPvpEnabled = (boolean) TogglePvP.getPlugin().getPlayerManager().getPlayer(damager).get("pvpenabled");
+                boolean victimPvpEnabled = (boolean) TogglePvP.getPlugin().getPlayerManager().getPlayer(victim).get("pvpenabled");
+
+                if (!damagerPvpEnabled) {
+                    event.setCancelled(true);
+                    PluginMessages.sendActionBar(damager, config.getCannot_attack_attacker());
+                    return;
+                }
+                if (!victimPvpEnabled) {
+                    event.setCancelled(true);
+                    PluginMessages.sendActionBar(damager, config.getCannot_attack_victim());
+                }
+
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,34 @@
+package eu.endermite.togglepvp.listeners.player;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+import java.util.HashMap;
+
+public class PlayerJoinAndLeaveListener implements Listener {
+
+    /**
+     * This event is here to get players saved options on join
+     */
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerJoin(org.bukkit.event.player.PlayerJoinEvent event) {
+
+        Player player = event.getPlayer();
+        HashMap<String, Object> playerData;
+        playerData = TogglePvP.getPlugin().getSqLite().getPlayerInfo(player);
+        TogglePvP.getPlugin().getPlayerManager().addPlayer(player, playerData);
+
+    }
+    /**
+     * This event is here to dump player's saved options from memory
+     */
+    @EventHandler
+    public void onPlayerLeave(org.bukkit.event.player.PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        TogglePvP.getPlugin().getSqLite().updatePlayerInfo(player, TogglePvP.getPlugin().getPlayerManager().getPlayer(player));
+        TogglePvP.getPlugin().getPlayerManager().removePlayer(player);
+    }
+
+}

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

@@ -0,0 +1,51 @@
+package eu.endermite.togglepvp.players;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+
+public class PlayerManager {
+
+    HashMap<Player, HashMap<String, Object>> playerList = new HashMap<>();
+
+    public PlayerManager() {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            HashMap<String, Object> playerData;
+            playerData = TogglePvP.getPlugin().getSqLite().getPlayerInfo(p);
+            playerList.put(p, playerData);
+        }
+    }
+
+    public HashMap<String, Object> getPlayer(Player p) {
+        return playerList.get(p);
+    }
+
+    public void addPlayer(Player player, HashMap<String,Object> data) {
+        playerList.put(player, data);
+    }
+
+    public void removePlayer(Player player) {
+        playerList.remove(player);
+    }
+
+    public boolean getPlayerPvPState(Player p) {
+        return (boolean) playerList.get(p).get("pvpenabled");
+    }
+
+    public void setPlayerPvpState(Player player, boolean state) {
+        playerList.get(player).replace("pvpenabled", state);
+    }
+
+    public boolean togglePlayerPvpState(Player player) {
+        boolean currentState = (boolean) playerList.get(player).get("pvpenabled");
+        if (currentState) {
+            playerList.get(player).replace("pvpenabled", false);
+            return false;
+        } else {
+            playerList.get(player).replace("pvpenabled", true);
+            return true;
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+package eu.endermite.togglepvp.util;
+
+import eu.endermite.togglepvp.TogglePvP;
+import org.bukkit.entity.Player;
+
+import java.io.File;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class DatabaseSQLite {
+
+    private String url;
+    private File folder;
+
+    public DatabaseSQLite(String url, File folder) {
+        this.url = url;
+        this.folder = folder;
+
+    }
+
+    public boolean createDatabaseFile() {
+        this.folder.mkdir();
+        try (Connection conn = DriverManager.getConnection(url)) {
+            if (conn != null) {
+                DatabaseMetaData meta = conn.getMetaData();
+                System.out.println("The driver name is " + meta.getDriverName());
+                Statement statement = conn.createStatement();
+                String sql = "CREATE TABLE IF NOT EXISTS `players` (`player_uuid` varchar(36) UNIQUE PRIMARY KEY, `pvpenabled` boolean);";
+                statement.execute(sql);
+                conn.close();
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+    public void testConnection() {
+        Connection conn = null;
+        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();
+                }
+            } catch (SQLException ex) {
+                System.out.println(ex.getMessage());
+            }
+        }
+    }
+
+    public HashMap<String, Object> getPlayerInfo(Player p) {
+        HashMap<String, Object> dataHashMap = new HashMap<>();
+
+        try {
+            Connection conn = DriverManager.getConnection(url);
+            Statement insertnewuser = conn.createStatement();
+            try {
+                String newuserdata = "INSERT OR IGNORE INTO `players` (player_uuid, pvpenabled) VALUES ('" + p.getUniqueId().toString() + "', " + TogglePvP.getPlugin().getConfigCache().isPvp_enabled_by_default() + ")";
+                insertnewuser.execute(newuserdata);
+            } catch (SQLException e) {
+                if (e.getErrorCode() != 19) {
+                    e.printStackTrace();
+                }
+            }
+            Statement statement = conn.createStatement();
+            String sql = "SELECT * FROM `players` WHERE `player_uuid` = '" + p.getUniqueId().toString() + "';";
+            statement.execute(sql);
+            ResultSet result = statement.getResultSet();
+            dataHashMap.put("pvpenabled", result.getBoolean("pvpenabled"));
+
+            conn.close();
+            return dataHashMap;
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+        return null;
+    }
+
+    public void updatePlayerInfo(Player p, HashMap<String, Object> data) {
+
+        try {
+            Connection conn = DriverManager.getConnection(url);
+            Statement insertnewuser = conn.createStatement();
+            try {
+                String newuserdata = "UPDATE `players` SET pvpenabled = "+data.get("pvpenabled")+" WHERE `player_uuid` = '"+p.getUniqueId().toString()+"';";
+                insertnewuser.execute(newuserdata);
+            } catch (SQLException e) {
+                TogglePvP.getPlugin().getLogger().severe("Error while saving player data!");
+                e.printStackTrace();
+            }
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+    }
+
+}

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

@@ -0,0 +1,22 @@
+package eu.endermite.togglepvp.util;
+
+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.ChatColor;
+import org.bukkit.entity.Player;
+
+
+public class PluginMessages {
+
+    public static String parseMessage(String message) {
+        //TODO PAPI support
+        return ChatColor.translateAlternateColorCodes('&', message);
+    }
+
+    public static void sendActionBar(Player player, String message) {
+        BaseComponent[] component = TextComponent.fromLegacyText(parseMessage(message));
+        player.spigot().sendMessage(ChatMessageType.ACTION_BAR, component);
+    }
+
+}

src/main/resources/config.yml

@@ -0,0 +1,16 @@
+settings:
+  # Decides if pvp should be enabled or disabled by default
+  pvp_enabled_by_default: false
+
+  # Prevents dumping lava and lighting blocks on fire near players with pvp off
+  lava_and_fire_stopper:
+    enabled: true
+    radius: 2.5
+
+messages:
+  pvp_enabled: "&cYou enabled PvP!"
+  pvp_disabled: "&cYou disabled PvP!"
+  cannot_attack_victim: "&cYou can't attack players that have PvP turned off!"
+  cannot_attack_attacker: "&cYou can't attack players while you have PvP turned off!"
+  no_permission: "&cYou don't have permission to use that."
+  no_such_command: "&cNo such command."

src/main/resources/plugin.yml

@@ -0,0 +1,13 @@
+name: TogglePvP
+version: ${project.version}
+main: eu.endermite.togglepvp.TogglePvP
+authors: [YouHaveTrouble]
+api-version: 1.13
+description: PvP toggle plugin
+commands:
+  pvp:
+    usage: /pvp [args]
+permissions:
+  togglepvp.command.toggle:
+    default: true
+    description: Allows usage of /pvp toggle/enable/disable command