commit aad3d7ad0cee4eb4ec71f8f237c8171d660ad143 Author: YouHaveTrouble Date: Wed Aug 19 02:24:05 2020 +0200 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4788b4b --- /dev/null +++ b/.gitignore @@ -0,0 +1,113 @@ +# User-specific stuff +.idea/ + +*.iml +*.ipr +*.iws + +# IntelliJ +out/ + +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +target/ + +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next + +release.properties +dependency-reduced-pom.xml +buildNumber.properties +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.jar +.flattened-pom.xml + +# Common working directory +run/ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..3e9cc63 --- /dev/null +++ b/pom.xml @@ -0,0 +1,80 @@ + + + 4.0.0 + + eu.endermite + TogglePvP + 1.0 + jar + + TogglePvP + + PvP toggle plugin + + 1.8 + UTF-8 + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.1 + + ${java.version} + ${java.version} + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.4 + + + package + + shade + + + false + + + + + + + + src/main/resources + true + + + + + + + spigotmc-repo + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ + + + sonatype + https://oss.sonatype.org/content/groups/public/ + + + + + + org.spigotmc + spigot-api + 1.16.1-R0.1-SNAPSHOT + provided + + + org.projectlombok + lombok + 1.18.12 + + + diff --git a/src/main/java/eu/endermite/togglepvp/TogglePvP.java b/src/main/java/eu/endermite/togglepvp/TogglePvP.java new file mode 100644 index 0000000..e03500a --- /dev/null +++ b/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;} + + + + +} diff --git a/src/main/java/eu/endermite/togglepvp/commands/HelpCommand.java b/src/main/java/eu/endermite/togglepvp/commands/HelpCommand.java new file mode 100644 index 0000000..01ce900 --- /dev/null +++ b/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 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<oggle &f- toggles PvP status")); + } + String[] helpReady = helpPage.toArray(new String[0]); + sender.sendMessage(helpReady); + + }); + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/commands/MainCommand.java b/src/main/java/eu/endermite/togglepvp/commands/MainCommand.java new file mode 100644 index 0000000..661368a --- /dev/null +++ b/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 onTabComplete(CommandSender sender, Command command, String alias, String[] args) { + List commands = new ArrayList<>(); + String arg1 = args[0].toLowerCase(); + + List noPerm = new ArrayList<>(); + noPerm.add("help"); + + List 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; + } +} diff --git a/src/main/java/eu/endermite/togglepvp/commands/PvpToggleCommand.java b/src/main/java/eu/endermite/togglepvp/commands/PvpToggleCommand.java new file mode 100644 index 0000000..3afeb48 --- /dev/null +++ b/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 "); + } + } + + }); + } + + 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 "); + } + } + } + + 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 "); + } + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/config/ConfigCache.java b/src/main/java/eu/endermite/togglepvp/config/ConfigCache.java new file mode 100644 index 0000000..368bf67 --- /dev/null +++ b/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."); + } +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/WolfTargettingListener.java b/src/main/java/eu/endermite/togglepvp/listeners/WolfTargettingListener.java new file mode 100644 index 0000000..20c3a4b --- /dev/null +++ b/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); + } + } + } + } + } +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/AreaEffectCloudApplyListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/AreaEffectCloudApplyListener.java new file mode 100644 index 0000000..8b5b3e8 --- /dev/null +++ b/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 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()); + } + } + } + } + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/FishingListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/FishingListener.java new file mode 100644 index 0000000..e012d91 --- /dev/null +++ b/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()); + } + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/LavaDumpAndIgniteListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/LavaDumpAndIgniteListener.java new file mode 100644 index 0000000..4228705 --- /dev/null +++ b/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); + + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/LightningBlockIgniteListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/LightningBlockIgniteListener.java new file mode 100644 index 0000000..d3f0151 --- /dev/null +++ b/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; + } + } + } + } + + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerAttackListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerAttackListener.java new file mode 100644 index 0000000..fa0dcc0 --- /dev/null +++ b/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()); + } + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByFireworkListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByFireworkListener.java new file mode 100644 index 0000000..5f42222 --- /dev/null +++ b/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); + } + + } + + } + } + + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByLightningListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByLightningListener.java new file mode 100644 index 0000000..aa91941 --- /dev/null +++ b/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())); + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByProjectileListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerHitByProjectileListener.java new file mode 100644 index 0000000..fd2f33b --- /dev/null +++ b/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()); + } + + } + } + + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerJoinAndLeaveListener.java b/src/main/java/eu/endermite/togglepvp/listeners/player/PlayerJoinAndLeaveListener.java new file mode 100644 index 0000000..1719ba3 --- /dev/null +++ b/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 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); + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/players/PlayerManager.java b/src/main/java/eu/endermite/togglepvp/players/PlayerManager.java new file mode 100644 index 0000000..567d8b8 --- /dev/null +++ b/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> playerList = new HashMap<>(); + + public PlayerManager() { + for (Player p : Bukkit.getOnlinePlayers()) { + HashMap playerData; + playerData = TogglePvP.getPlugin().getSqLite().getPlayerInfo(p); + playerList.put(p, playerData); + } + } + + public HashMap getPlayer(Player p) { + return playerList.get(p); + } + + public void addPlayer(Player player, HashMap 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; + } + } +} diff --git a/src/main/java/eu/endermite/togglepvp/util/DatabaseSQLite.java b/src/main/java/eu/endermite/togglepvp/util/DatabaseSQLite.java new file mode 100644 index 0000000..4ac26bf --- /dev/null +++ b/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 getPlayerInfo(Player p) { + HashMap 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 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(); + } + } + +} diff --git a/src/main/java/eu/endermite/togglepvp/util/PluginMessages.java b/src/main/java/eu/endermite/togglepvp/util/PluginMessages.java new file mode 100644 index 0000000..a64e3c8 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..7768d65 --- /dev/null +++ b/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." diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..63efbc1 --- /dev/null +++ b/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 \ No newline at end of file